银行家算法的模拟实现实验报告
- 格式:doc
- 大小:80.50 KB
- 文档页数:9
淮海工学院计算机工程学院实验报告书课程名:《操作系统原理》题目:银行家算法班级:学号:姓名:一、实验目的银行家算法是操作系统中避免死锁的典型算法,本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。
实验环境Turbo C 2.0/3.0或VC++6.0实验学时4学时,必做实验。
二、实验内容用C语言编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。
程序能模拟多个进程共享多种资源的情形。
进程可动态地申请资源,系统按各进程的申请动态地分配资源。
要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。
三、实验说明实验中进程的数量、资源的种类以及每种资源的总量Total[j]最好允许动态指定。
初始时每个进程运行过程中的最大资源需求量Max[i,j]和系统已分配给该进程的资源量Allocation[i,j]均为已知(这些数值可以在程序运行时动态输入),而算法中其他数据结构的值(包括Need[i,j]、Available[j])则需要由程序根据已知量的值计算产生。
四、实验步骤1、理解本实验中关于两种调度算法的说明。
2、根据调度算法的说明,画出相应的程序流程图。
3、按照程序流程图,用C语言编程并实现。
五、分析与思考1.要找出某一状态下所有可能的安全序列,程序该如何实现?答:要找出这个状态下的所有可能的安全序列,前提是要是使这个系统先处于安全状态,而系统的状态可通过以下来描述:进程剩余申请数=最大申请数-占有数;可分配资源数=总数-占有数之和;通过这个描述来算出系统是否安全,从而找出所有的安全序列。
2.银行家算法的局限性有哪些?答:银行家算法是一种最有代表性的避免死锁的算法。
银行家算法即把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
竭诚为您提供优质文档/双击可除银行家算法操作系统实验报告篇一:计算机操作系统银行家算法实验报告计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计:1、算法思路:先对用户提出的请求进行合法性检查,即检查请求是否大于需要的,是否大于可利用的。
若请求合法,则进行预分配,对分配后的状态调用安全性算法进行检查。
若安全,则分配;若不安全,则拒绝申请,恢复到原来的状态,拒绝申请。
2、银行家算法步骤:(1)如果Requesti<or=need,则转向步骤(2);否则,认为出错,因为它所需要的资源数已超过它所宣布的最大值。
(2)如果Request<or=Available,则转向步骤(3);否则,表示系统中尚无足够的资源,进程必须等待。
(3)系统试探把要求的资源分配给进程pi,并修改下面数据结构中的数值:Available=Available-Request[i];Allocation=Allocation+Request;need=need-Request;(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
3、安全性算法步骤:(1)设置两个向量①工作向量work。
它表示系统可提供进程继续运行所需要的各类资源数目,执行安全算法开始时,work=Allocation;②布尔向量Finish。
它表示系统是否有足够的资源分配给进程,使之运行完成,开始时先做Finish[i]=false,当有足够资源分配给进程时,令Finish[i]=true。
(2)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false②need 如找到,执行步骤(3);否则,执行步骤(4)。
(3)当进程p获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:work=work+Allocation;Finish[i]=true;转向步骤(2)。
《操作系统》课程综合性实验报告 : 学号: 2016 年 11 月 20 日 实验题目 进程调度算法程序设计
一、实验目的 通过对安全性算法和银行家算法的模拟,进一步理解资源分配的基本概念,加深对资源申请,资源分配(银行家算法)以及系统是否能分配(安全性算法)资源的理解。 二、设备与环境 1. 硬件设备:PC机一台
2. 软件环境:安装Windows操作系统或者Linux操作系统,并安装相关的程序开发环境,如C \C++\Java 等编程语言环境。 三、实验容 用C语言(或其它语言,如Java)实现对资源的资源申请与分配; (一)银行家算法(bank()函数): 进程i发出请求资源申请, (1)如果Request [j]<=need[i,j],转向步骤(2),否则认为出错,因为他所需要的资源数已经超过它所宣布的最大值。 (2)如果:Request i[j]<=available[i,j],转向步骤(3),否则表示尚无足够资源,进程i需等待。 (3)若以上两个条件都满足,则系统试探着将资源分配给申请的进程,并修改下面数据结构中的数值: Available[i,j]= Available[i,j]- Request [j]; Allocation[i][j]= Allocation[i][j]+ Request [j]; need[i][j]= need[i][j]- Request [j]; (4)试分配后,执行安全性检查,调用check()函数检查此次资源分配后系统是否处于安全状态。若安全,才正式将资源分配给进程。否则本次试探分配作废,恢复原来的资源分配状态,让该进程等待。 (5)用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请。 (二)安全性算法(safe()函数): (1)设置两个向量: 工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目,在执行安全性算法开始时,Work= Available。 工作向量Finish,它表示系统是否有足够的资源分配给进程,使之运行完成。开始时先做Finish[i]=false;当有足够的资源分配给进程时, 再令Finish[i]=true。 (2)在进程中查找符合以下条件的进程: 条件1:Finish[i]=false; 条件2:need[i][j]<=Work[j] 若找到,则执行步骤(3)否则,执行步骤(4) (3)当进程获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行: Work[j]= Work[j]+ Allocation[i][j]; Finish[i]=true; goto step (2); (4)如果所有的Finish[i]=true都满足,则表示系统处于安全状态,否则,处于不安全状态。 四、实验结果及分析 1.实验设计说明 按0由用户输入,按1由系统提供数据
操作系统实验银行家算法模拟实现(强烈推荐)银行家算法模拟实现一.实验目的1) 理解死锁避免相关内容;2) 掌握银行家算法主要流程;3) 掌握安全性检查流程。
二.实验描述本实验主要对操作系统中的死锁预防部分的理论进行实验。
要求实验者设计一个程序,该程序可对每一次资源申请采用银行家算法进行分配。
三.实验内容1) 设计多个资源(≥3);2) 设计多个进程(≥3);3) 设计银行家算法相关的数据结构;4) 动态进行资源申请、分配、安全性检测并给出分配结果。
四.实验要求1) 编写程序完成实验内容;2) 画出安全性检测函数流程图;3) 小组派1人上台用PPT演讲实现过程;4) 撰写实验报告。
测试要求1) 进行Request请求,输入参数为进程号、资源号和资源数;2) 进行3次以上的Request请求;3) 至少进行1次资源数目少于可用资源数,但不安全的请求。
五.实验设备PC机1台,要求安装DOS7.1、Turbo C3.0、Windows2000。
六.实验结果七.实验思考1)针对死锁有哪些可行方案?2)死锁解除的难点是什么?八.银行家算法介绍8.1银行家算法的数据结构1) 可利用资源向量Available。
其中每个元素代表每类资源的数目。
2) 最大需求矩阵Max。
其中每个元素代表每个进程对于每类资源的最大需求量。
Max[i,j]=K表示i进程对于j类资源的最大需求量为K。
3) 分配矩阵Allocation。
其中每个元素代表每个进程已得到的每类资源的数目。
4) 需求矩阵Need。
其中每个元素代表每个进程还需要的每类资源的数目。
8.2银行家算法Request i [j]=K表示进程Pi需要K个j类资源。
1)如果Request i [j]≤Need[i , j],便转向步骤2,否则认为出错。
2)如果Request i [j]≤Available[j],便转向步骤3,否则表示无足够资源,Pi需等待;3)系统尝试分配资源给Pi;4)系统进行安全性检查,检查此次资源分配后,系统是否安全。
实验七银行家算法模拟实验一、实验目的(1)进一步理解利用银行家算法避免死锁的问题;(2)在了解和掌握银行家算法的基础上,编写银行家算法通用程序,友好显示调试结果;(3)理解和掌握安全序列、安全性算法。
二、实验环境(1)装有Microsoft Visual Studio C++6.0专业版或企业版。
三、实验内容及原理(一)实验内容理解什么是死锁?理解利用银行家算法避免死锁的原理;会使用某种编程语言模拟实验银行家算法。
(二)实验原理1、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。
2、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。
系统按下述步骤进行安全检查:(1)如果Request i[]≤Need[]则继续以下检查,否则显示需求申请超出最大需求值的错误。
(2)如果Request i[]≤Available[]则继续以下检查,否则显示系统无足够资源,Pi阻塞等待。
(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:Available[j]:=Available[j]-Requesti[j];Allocation[i,j]:=Allocation[i,j]+Requesti[j];Need[i,j]:=Need[i,j]-Requesti[j];(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。
3、安全性算法(1)设置两个向量:①工作向量Work:它表示系统可提供给进程继续运行所需的各类资源数目,它含有m 个元素,在执行安全算法开始时,Work:=Available;②Finish:它表示系统是否有足够的资源分配给进程,使之运行完成。
计算机学院《操作系统》课程设计报告设计题目:银行家算法的实现姓名:学号:班级: 06网络工程班完成日期: 2009年6月13日银行家算法分析、设计与实现一、设计理论描述本设计的目的是通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。
要求如下:(1)模拟一个银行家算法;(2)初始化时让系统拥有一定的资源;(3)用键盘输入的方式申请资源;(4)如果预分配后,系统处于安全状态,则修改系统的资源分配情况;(5)如果预分配后,系统处于不安全状态,则提示不能满足请求,设计的主要内容是模拟实现动态资源分配。
同时编写和调试一个系统动态资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生。
银行家算法.顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。
在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。
如果资源分配不得到就会发生进程循环等待资源,则进程都无法继续执行下去的死锁现象。
把一个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。
当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。
“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。
显然,,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.二、算法描述及数据结构模型1.银行家算法:设进程i提出请求Request[n],则银行家算法按如下规则进行判断。
(1)如果Request[n]>Need[i,n],则报错返回。
(2)如果Request[n]>Available,则进程i进入等待资源状态,返回。
实验二银行家算法实验报告一、实验目的通过本次实验,主要学习了解了银行家算法的原理和实现方式,掌握银行家算法的应用场景,了解了安全序列的概念和判断方法,并通过代码实现加深对银行家算法的理解和掌握。
二、实验过程1、阅读银行家算法的相关理论知识。
2、编写银行家算法的代码实现。
3、根据实验要求,设置不同的初始资源分配和不同的进程请求资源情况,分别计算是否存在安全序列。
三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况:可用的资源数目:4 4 4进程数目:4各进程对三种资源的最初需要数目:Max:7 5 33 2 29 0 22 2 2已分配资源数目:Allocation:0 1 02 0 03 0 22 1 1剩余资源数目:Need: 7 4 31 2 26 0 00 1 1根据上述数据,计算出该初试分配情况下的安全序列为:1 -> 3 -> 4 -> 2。
2、然后设置一个进程请求资源的情况:进程 1 请求资源 [3,3,0],进程 2 请求资源 [1,0,1],进程 3 请求资源 [2,2,0],进程 4 请求资源 [0,0,2]。
根据银行家算法,先进行安全性检测,发现该系统不存在安全序列,因此不满足银行家算法的要求,请求不被满足。
3、接着修改初始的资源分配情况和请求的资源情况,进行比较:通过以上的实验操作,得出结论:只有当请求的资源不会导致系统不再安全时,才会满足请求。
银行家算法基于这个假设进行运算,它管理着一个可以分配的表格,该表格显示系统的各种资源已经分配和未分配的情况,并确定哪些进程可以分配资源,哪些不可以。
四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解,对该算法有了更深的认识和理解,并通过代码实现和实验操作,进一步巩固和掌握了该算法的应用方法。
在实验过程中,也有一些需要注意的问题:如需要按照一定的顺序输入原数据,正确地计算资源分配和剩余情况;核实每个请求的资源数目是否足够,才进行安全性检测;注意计算过程中数值的准确性和解题思路的正确性等。
2011-2012学年第一学期计算机操作系统实验报告专业:计算机科学与技术班级:学号:姓名:提交日期:实验三银行家算法模拟【开发语言及实现平台或实验环境】C++/C#Microsoft Visual Studio 6.0/ Microsoft V isual Studio .NET 2003【实验目的】(1)进一步理解利用银行家算法避免死锁的问题;(2)在了解和掌握银行家算法的基础上,编制银行家算法通用程序,将调试结果显示在计算机屏幕上,再检测和笔算的一致性。
(3)理解和掌握安全序列、安全性算法【实验要求】(1)了解和理解死锁;(2)理解利用银行家算法避免死锁的原理;(3)会使用某种编程语言。
【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。
系统按下述步骤进行安全检查:(1)如果Request i≤Need i则继续以下检查,否则显示需求申请超出最大需求值的错误。
(2)如果Request i≤A vailable则继续以下检查,否则显示系统无足够资源,Pi阻塞等待。
(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:A vailable[j]∶=A vailable[j]-Request i[j];Allocation[i,j]∶=Allocation[i,j]+Request i[j];Need[i,j]∶=Need[i,j]-Requesti[j];(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。
XX大学操作系统实验报告姓名:_学号:_班级: ______实验日期:实验丽:预防进程死锁的银行家算法实验三预防进程死锁的银行家算法1 •实验目的:通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。
理解银行家算法的运行原理,进一步掌握预防进程死锁的策略及对系统性能的评价方法。
:2. 需求分析(1)输入的形式和输入值的范围;输入:首先输入系统可供资源种类的数量n 范围:0<n<=100资源1的名称:资源的数量:资源2的名称:资源的数量:OOOOOOOOOOOOOOOO输入作业的数量m 范围:0<m<=100输入个进程的最大需求量<m*n矩阵>[Max]:输入个进程已经申请的资源量<m*n矩阵>[Allocation]:(2)输出的形式分配序列:(3)程序所能达到的功能通过手动输入资源种类数量和各进程的最大需求量、已经申请的资源量,运用银行家算法检测系统是否安全,若安全则给出安全序列,并且当用户继续输入某进程的资源请求时,能够继续判断系统的安全性。
(4)测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果。
正确输入输入参数(已申请资源数)错误3、概要设计所有抽象数据类型的定义:int Max[100][100]; // 各进程所需各类资源的最大需求char name[100] };// 资源的名称int Allocation[100][100]; // 系统已分配资源int Need[100][100] }; // 还需要资源int Request[100]; // 请求资源向量int temp[100]; // 存放安全序列int Work[100];// 存放系统可提供资源int M=100; // 作业的最大数为100int N=100; // 资源的最大数为100 主程序的流程:* 变量初始化;* 接收用户输入n,m,Max ij ,Allocation ij;* 按照银行家算法判断当前状态安全与否,安全给出安全序列,不安全给出提示;* 如果安全,提示用户输入下一时刻进程P k 的资源请求Request(R,…,R);* 如果不安全或者无新请求则退出。
银行家算法的模拟实现一、实验题目:模拟实现银行家算法的处理过程二、实验目的:银行家算法是防止死锁的代表性算法。
本实习旨在加深了解有关资源申请、防止死锁、状态平安性等概念,并体会和运用防止死锁的具体实施方法。
然后依照本实习,自行设计模拟程序。
三、实验原理:1.我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规那么为进程分配资源。
当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量那么按当前的申请量分配资源,否那么就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
假设超过那么拒绝分配资源,假设没有超过那么再测试系统现存的资源能否满足该进程尚需的最大资源量,假设能满足那么按当前的申请量分配资源,否那么也要推迟分配。
2.平安状态:如果存在一个由系统中所有进程构成的平安序列P1,…,Pn,那么系统处于平安状态。
平安状态一定是没有死锁发生。
不平安状态:不存在一个平安序列。
不平安状态一定导致死锁。
平安序列:一个进程序列{P1,…,Pn}是平安的,如果对于每一个进程Pi(1≤i≤n〕,它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
3.设requesti为进程p[i]的请求向量,如果requesti[j]=K,表示进程p[i]需要K个Rj资源。
当系统发出请求后,系统按下述步骤开场检查:1〕如果requesti[j]<=need[i][j],转向步骤2;否那么报告出错,申请的资源已经大于它需要的最大值。
2〕如果requesti[j]<=available[j],转向步骤3;否那么报告出错,尚无足够的资源。
3〕系统试探着把资源分配给p[i],并修改以下数据构造中的值:available[j]=available[j]-request[j]allocation[i][j]=allocation[i][j]+request[j]need[i][j]=need[i][j]-request[j]4〕系统进展平安性算法,检查此次分配后,系统是否还处于平安状态,假设平安,把资源分配给进程p[i];否那么,恢复原来的资源分配状态,让进程p[i]等待。
4. 平安性算法:int work[RESOURCE_NUMBER];bool finish[PROCESS_NUMBER];1) Work=Available;Finish=false;2) 寻找满足条件的i:A、Finish[i]=false;B、Need[i]≤Work;如果不存在,那么转4)3) Work:=Work+Allocation[i];Finish[i]:=true;转2)4) 假设对所有i,Finish[i]=true,那么系统处于平安状态,否那么处于不平安状态四、数据构造:数组五、程序代码:#include<stdio.h>#include<iostream>#include<stdlib.h>#include<time.h>using namespace std;#define N 3 //进程数#define M 3 //资源数int Available[M]; //可用的资源数int Need[N][M]={0}; //还需要的资源数int Max[N][M]; //最大需求量int Allocation[N][M] = {0}; //当前分配到的资源数int Request[N][M]={0}; //请求的资源数int n;time_t t;int isFinish[N] ={0}; //判断进程是否已经请求资源完毕int test1 = 0;void Requester(); //进程随机请求资源数目void Handle(); //处理该请求bool Check(); //平安性算法检查void show(); //打印出当前的进程资源状态int Finish(int); //进程是否已经完成,假设完成返回1,否那么为0void main(){int i;int j;cout << "请输入各个资源的可用数目:";for(i=0; i<M; i++)cin >> Available[i];cout << "请依次输入各个进程对各个资源的最大需求数目:" << endl;for(i=0; i<N; i++)for(j=0; j<M; j++){cin >> Max[i][j];Need[i][j] = Max[i][j] - Allocation[i][j];}cout << "------------------------原始状态------------------------" << endl;show();int test = 0;int testP = 0;int testR = 0;do{Requester ();test++;}while(test != 10);}int Finish(int i){int test = 0;int w = i;for(int j=0; j<M; j++){if(Need[w][j] == 0) //对j资源的需求量已经为0test++;}if(test == M) //如果对每个资源的需求量都已经为0isFinish[w] = 1; //那么将其设为1,代表已经完成return isFinish[w];}void Requester (){time_t t;int test = 0;srand((unsigned)time(&t)+rand());n = rand()%N;for(int j=0; j<M; j++){if(Need[n][j] <= Available[j])test++;}for(j=0; j<M; j++){if(test==N ){Request[n][j] = Need[n][j];}else{srand((unsigned)time(&t)+rand());Request[n][j] = rand()%4;}}Handle();}void Handle() //处理请求{int test1 = 0;int test2 = 0;for(int j=0; j<M; j++)if(Request[n][j]<=Need[n][j]){if(Request[n][j] <= Available[j])test1++;else{cout<< "目前没有足够的资源分配给你的进程" << n << "的请求";for(j=0; j<M; j++)cout << Request[n][j] << " ";cout << ",请等待!" << endl <<endl;}}else{cout << "你的进程" << n << "所请求的资源";for(j=0; j<M; j++)cout << Request[n][j] << " ";cout << "已经超过进程的需求数目!" <<endl <<endl;}if(test1 == M) //请求资源数目均小于可用资源数目{cout << "处理你的进程" << n << "的请求";for(j=0; j<M; j++)cout << Request[n][j] << " ";cout << endl ;for(j=0; j<M; j++){Available[j] = Available[j]- Request[n][j];Allocation[n][j] = Allocation[n][j]+Request[n][j];Need[n][j] = Need[n][j]-Request[n][j];}if(Check()==true) //平安性算法检查是平安的,那么打印出来{show();if(Finish(n) == 1) //如果此次分配后该进程已经完毕,那么久释放其占用的资源数目{cout << "进程" << n << "已经完毕,会释放资源" << endl;for(j=0; j<M; j++){Available[j] = Available[j] + Allocation[n][j];Allocation[n][j] = 0;Need[n][j] = 0;}show();}}else{cout << "你的进程" << n << "所请求的资源";for(j=0; j<M; j++)cout << Request[n][j] << " ";cout << "系统不平安!本次资源申请不成功!"<<endl <<endl;for(j=0; j<M; j++) //如不平安那么收回此次分配的资源数目{Available[j] = Available[j] + Request[n][j];Allocation[n][j] = Allocation[n][j] - Request[n][j];Need[n][j] = Need[n][j] + Request[n][j];}}}}bool Check() //平安性算法检测{int work[M] ={0};bool finish[N];for(int j=0; j<M; j++)work[j] = Available[j];for(int i=0; i<N; i++)finish[i] = false;int test = 0;bool flag;int k=0;for(j=0; j<M; j++){if(Need[n][j] <= work[j])test++;}if(test == M)flag = true;elseflag = false;test = 0;for(i=0;i<N;i++){for(i=0;i<N;i++) //循环检测{if(finish[i] == false && flag == true){for(j=0; j<M; j++)work[j] = work[j] + Allocation[n][j];finish[i] = true;test++;}}}if(test == N)return true;elsereturn false;}void show(){cout << "---------------------------------------------------------" << endl;cout << "资源请求" << "\t" << "已分配资源" << "\t" << "尚需资源"<<"\t" << "剩余可用资源" <<endl;cout << "进程名称" << "\tA B C " << "\tA B C "<< "\t A B C "<<endl;for(int i=0; i<N; i++){cout << " P" << i << " \t";for(int j=0; j<M; j++)cout << Allocation[i][j] << " ";cout << "\t";for(j=0; j<M; j++)cout << Need[i][j] << " ";if( i==0 ){cout << "\t ";for(j=0; j<M; j++)cout << Available[j] << " ";}cout << endl;}cout << "--------------------------------------------------------" << endl <<endl;}六、运行结果:七、实验心得:这次的实验模拟实现银行家算法虽然用程序算法实现了模拟进程请求资源以及根据平安性检测是否要分配资源的整个过程,自己考虑整个代码的框架过程中期初觉得思路清晰,应该比拟简单,但是列出框架以及主要函数之后开场用代码实现的时候,发现了很多隐藏的细节的考虑,比拟繁琐而且环环相扣,要真的实现并没有当初以为的那么简单,比方我现在目前的算法虽然模拟了大致的过程,并且也可以不断循环请求,但是在进程请求资源那一块的实现还是有缺陷,没能很好的优化,目前只是如果有足够的资源,就让随机产生的进程i申请最大需求量,如果无法满足,那么随机产生随机资源数目进展申请。