下载文档原格式
实验八银行家算法模拟实现一．实验目的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）系统进行安全性检查，检查此次资源分配后，系统是否安全。
如果安全，则正式分配资源，否则撤销此次分配。
实验报告附录3程序源代码：#include<string.h>#include<stdio.h>#include<stdlib.h># define m 50# define false 0#define true 1int no1; //进程数int no2; //资源数int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m]; //定义全局变量void main(){void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf("**********************************************\n");printf("* 银行家算法的设计与实现*\n");printf("**********************************************\n");printf("请输入进程总数:\n");scanf("%d",&no1);printf("请输入资源种类数:\n");scanf("%d",&no2);printf("请输入Max矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&max[i][j]); //输入已知进程最大资源需求量printf("请输入Allocation矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&allocation[i][j]); //输入已知的进程已分配的资源数for(i=0;i<no1;i++)for(j=0;j<no2;j++)need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值printf("请输入Available矩阵\n");for(i=0;i<no2;i++)scanf("%d",&available[i]); //输入已知的可用资源数print(); //输出已知条件check(); //检测T0时刻已知条件的安全状态if(r==1) //如果安全则执行以下代码{do{printf("\n请输入请求资源的进程号(0~4)：\n");for(j=0;j<=no2;j++){scanf("%d",&i);if(i>=no1){printf("输入错误，请重新输入：\n");continue;}else break;}printf("\n请输入该进程所请求的资源数request[j]:\n");for(j=0;j<no2;j++)scanf("%d",&request[j]);for(j=0;j<no2;j++)if(request[j]<=need[i][j]) p=0;//判断请求是否超过该进程所需要的资源数if(p)printf("请求资源超过该进程资源需求量，请求失败！\n");else{for(j=0;j<no2;j++)if(request[j]<=available[j]) q=0; //判断请求是否超过可用资源数if(q)printf("没有做够的资源分配，请求失败！\n");else //请求满足条件{for(j=0;j<no2;j++){available1[j]=available[j];allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];//保存原已分配的资源数，仍需要的资源数和可用的资源数available[j]=available[j]-request[j];allocation[i][j]=allocation+request[j];need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程}print();check(); //检测分配后的安全性if(r==0) //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];//还原已分配的资源数，仍需要的资源数和可用的资源数}printf("返回分配前资源数\n");print();}}}printf("\n你还要继续分配吗？Y or N ?\n");//判断是否继续进行资源分配c=getchar();}while(c=='y'||c=='Y');}}void check() //安全算法函数{int k,f,v=0,i,j;int work[m],a[m];int finish[m];r=1;for(i=0;i<no1;i++)finish[i]=false; // 初始化进程均没得到足够资源数并完成for(i=0;i<no2;i++)work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数k=no1;do{for(i=0;i<no1;i++){if(finish[i]==false){f=1;for(j=0;j<no2;j++)if(need[i][j]>work[j])f=0;if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程{finish[i]=true;a[v++]=i; //记录安全序列号for(j=0;j<no2;j++)work[j]+=allocation[i][j]; //释放该进程已分配的资源}}}k--; //每完成一个进程分配，未完成的进程数就减1}while(k>0);f=1;for(i=0;i<no1;i++) //判断是否所有的进程都完成{if(finish[i]==false){f=0;break;}}if(f==0) //若有进程没完成，则为不安全状态{printf("系统处在不安全状态！");r=0;}else{printf("\n系统当前为安全状态，安全序列为：\n");for(i=0;i<no1;i++)printf("p%d ",a[i]); //输出安全序列}}void print() //输出函数{int i,j;printf("\n");printf("*************此时刻资源分配情况*********************\n");printf("进程名/号| Max | Allocation | Need |\n");for (i = 0; i < no1; i++){printf(" p%d/%d ",i,i);for (j = 0; j < no2; j++){printf("%d ",max[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",allocation[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",need[i][j]);}printf("\n");}printf("\n");printf("各类资源可利用的资源数为:");for (j = 0; j < no2; j++){printf(" %d",available[j]);}printf("\n");}（程序结束）附录 4程序运行调试结果：1、程序初始化2、检测系统资源分配是否安全结果。
操作系统实验⼆：银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态；2、了解如何避免系统死锁；3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法，掌握其实现原理及实现过程。
⼆、实验内容根据银⾏家算法的基本思想，编写和调试⼀个实现动态资源分配的模拟程序，并能够有效避免死锁的发⽣。
三、实验原理进程申请资源时，系统通过⼀定的算法判断本次申请是否不可能产⽣死锁（处于安全状态）。
若可能产⽣死锁（处于不安全状态），则暂不进⾏本次资源分配，以避免死锁。
算法有著名的银⾏家算法。
1、什么是系统的安全状态和不安全状态？所谓安全状态，是指如果系统中存在某种进程序列＜P1，P2，…，Pn＞，系统按该序列为每个进程分配其所需要的资源，直⾄最⼤需求，则最终能使每个进程都可顺利完成，称该进程序列＜P1，P2，…，Pn，＞为安全序列。
如果不存在这样的安全序列，则称系统处于不安全状态。
2、银⾏家算法把操作系统看作是银⾏家，操作系统管理的资源相当于银⾏家管理的资⾦，进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。
为保证资⾦的安全，银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款，但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。
操作系统按照银⾏家制定的规则设计的银⾏家算法为：（1）进程⾸次申请资源的分配：如果系统现存资源可以满⾜该进程的最⼤需求量，则按当前的申请量分配资源，否则推迟分配。
（2）进程在执⾏中继续申请资源的分配：若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量，且现存资源能满⾜该进程尚需的最⼤资源量，则按当前申请量分配资源，否则推迟分配。
（3）⾄少⼀个进程能完成：在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。
江南大学理学院实验报告课程名称：计算机操作系统实验名称：银行家算法实验日期：2013.11.29 班级：信计1103 姓名：陈鹭学号：1301110301实验报告要求：1.实验目的 2.实验内容与要求 3.流程图与模块调用 4.实验分析5.运行情况6.实验体会1.实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
2.实验内容与要求内容：银行家算法流程安全算法流程要求：设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；3.流程图与模块调用数据结构1．可利用资源向量Available ，它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available（j）=k，标是系统中现有Rj类资源k个。
2．最大需求矩阵Max，这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max（i，j）=k，表示进程i需要Rj类资源的最大数目为k。
3．分配矩阵Allocation，这是一个n×m的矩阵，它定义了系统中的每类资源当前一分配到每一个进程的资源数。
如果Allocation（i，j）=k，表示进程i当前已经分到Rj类资源的数目为k。
Allocation 表示进程i的分配向量，有矩阵Allocation的第i行构成。
i4．需求矩阵Need，这是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。
如果Need （i，j）=k，表示进程i还需要Rj类资源k个，才能完成其任务。
《银行家算法的模拟实现》 --实验报告题目: 银行家算法的模拟实现专业:班级:组员:指导老师:一、实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验内容模拟实现银行家算法实现死锁避免。
要求：初始数据（如系统在T0时刻的资源分配情况、每一种资源的总数量）从文本文件读入，文件中给出最大需求矩阵Max、分配矩阵Allocation，在程序中求得需求矩阵Need和可利用资源向量Available。
三、实验分析过程1、整个银行家算法的思路。
先对用户提出的请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查。
1)进程一开始向系统提出最大需求量.2)进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.3)若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待2、算法用到的主要数据结构和C语言说明。
（1）、可利用资源向量INT A V AILABLE[M] M为资源的类型。
（2）、最大需求矩阵INT MAX[N][M] N为进程的数量。
（3）、已分配矩阵INT ALLOCA TION[N][M]（4）、还需求矩阵INT NEED[N][N]（5）、申请各类资源数量int Request[x]; //（6）、工作向量int Work[x];（7）、int Finish[y]; //表示系统是否有足够的资源分配给进程，0为否，非0为是3、银行家算法（主程序）（1）、系统初始化。
输入进程数量，资源种类，各进程已分配、还需求各资源数量，各资源可用数量等（2）、输入用户的请求三元组（I，J，K），为进程I申请K个J类资源。
（3）、检查用户的请求是否小于还需求的数量，条件是K<=NEED[I,J]。
武汉理工大学华夏学院课程设计报告书课程名称：操作系统原理题目：编程序模拟银行家算法系名：信息工程系专业班级：计应2091姓名：王汝平学号： 10225509118 指导教师:苏永红2011 年 7 月 6 日课程设计任务书学生姓名：王汝平专业班级：计应2091指导教师：苏永红工作单位：信息工程系设计题目：编程序模拟银行家算法初始条件：Linux操作系统，GCC编译环境要求完成的主要任务：主要任务：银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
思想：将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。
银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。
用银行家算法分配资源时，测试进程对资源的最大需求量，若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。
设计报告撰写格式要求：1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析（其中包括实验的检查结果、程序的运行情况）7 自我评价与总结 8 附录：程序清单，注意加注释（包括关键字、方法、变量等），在每个模块前加注释；时间安排7月 4日布置课程设计任务；分配题目后，查阅资料、准备程序；7月 5 ～7月7 日上机调试程序、书写课程设计报告；7月8 日提交课程设计报告及相关文档。
指导教师签名：2011年7月2日系主任签名：2011年7月3日目录1.需求分析 (4)1.1课程设计题目 (4)1.2课程设计目的 (4)1.3设计任务 (4)1.4设计思想 (4)2.设计思想和过程 (5)2.1 概要设计 (5)2.2程序源代码 (7)3.调试及运行结果 (13)4.实验心得体会 (15)5.参考文献 (15)1.需求分析1.1课程设计题目：编程序模拟银行家算法1.2设计目的1.2.1银行家算法是避免死锁的一种重要方法，本实验要求用级语言编写和调试一个简单的银行家算法程序。
精品课程银行家算法的模拟实现1 课设简介：1.1 课程设计题目银行家算法的模拟实现1.2 课程设计目的通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁地发生。
1.3 课程设计内容模拟实现动态资源分配。
同时要求编写和调试一个系统动态资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生。
2 实验原理分析：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
死锁的产生，必须同时满足四个条件，即一个资源每次只能由一个进程张勇；第二个为等待条件，即一个进程请求资源不能满足时，它必须等待，单它仍继续宝石已得到的所有其他资源；第三个为非剥夺条件，即在出现死锁的系统中一定有不可剥夺使用的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一个进程所持有的资源。
防止死锁的机构只能确保上述四个条件之一不出现，则系统就不会发生死锁。
通过这个算法可以用来解决生活中的实际问题，如银行贷款等。
3 程序结构分析：3.2 程序模块划分3.2.1.银行家算法:设进程i提出请求Request[n]，则银行家算法按如下规则进行判断。
(1)如果Request[n]>Need[i，n]，则报错返回。
(2)如果Request[n]>Available，则进程i进入等待资源状态，返回。
(3)假设进程i的申请已获批准，于是修改系统状态：Available=Available-RequestAllocation=Allocation+RequestNeed=Need-Request(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
3.2.2.安全性检查(1)设置两个工作向量Work=Available；Finish[M]=False(2)从进程集合中找到一个满足下述条件的进程，Finish [i]=FalseNeed<=Work如找到，执行(3)；否则，执行(4)(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
模拟实现银行家算法院系：专业：学号：姓名：指导教师：2014年3月17日星期一目录银行家算法的模拟实现................................. 错误！未定义书签。
一、课设简介：........................................... 错误！未定义书签。
(1) 课程设计题目.................................... 错误！未定义书签。
(2) 课程设计目的.................................... 错误！未定义书签。
(3) 课程设计内容.................................... 错误！未定义书签。
二、实验原理分析：................................... 错误！未定义书签。
(1) 整个银行家算法的思路........ ………….错误！未定义书签。
(2) 算法用到的主要数据结构和C语言说明。
错误！未定义书签。
(3) 银行家算法主程序............................ 错误！未定义书签。
(4) 安全性检查算法（safe()函数） ....... 错误！未定义书签。
三、程序结构分析：................................... 错误！未定义书签。
(1) 程序模块划分 ............................ 错误！未定义书签。
四、流程图 .................................................. 错误！未定义书签。
五、程序代码 .............................................. 错误！未定义书签。
六、程序运行结果....................................... 错误！未定义书签。
银行家算法分析、设计与实现一、设计理论描述本设计的目的是通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁地发生。
要求如下：（1）模拟一个银行家算法；（2）初始化时让系统拥有一定的资源；（3）用键盘输入的方式申请资源；（4）如果预分配后，系统处于安全状态，则修改系统的资源分配情况；（5）如果预分配后，系统处于不安全状态，则提示不能满足请求，设计的主要内容是模拟实现动态资源分配。
同时编写和调试一个系统动态资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生。
银行家算法.顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行加资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。
在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。
如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。
把一个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。
当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。
“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。
显然，，每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.二、算法描述及数据结构模型1.银行家算法:设进程i提出请求Request[n]，则银行家算法按如下规则进行判断。
(1)如果Request[n]>Need[i，n]，则报错返回。
(2)如果Request[n]>Available，则进程i进入等待资源状态，返回。
(3)假设进程i的申请已获批准，于是修改系统状态：Available=Available-RequestAllocation=Allocation+RequestNeed=Need-Request(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
2.安全性检查(1)设置两个工作向量Work=Available；Finish[M]=False(2)从进程集合中找到一个满足下述条件的进程，Finish [i]=False ， Need<=Work如找到，执行(3)；否则，执行(4)(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。
Work=Work+Allocation ， Finish=True， GO TO 2(4)如所有的进程Finish[M]=true，则表示安全；否则系统不安全。
3.数据结构#define False 0#define True 1int Max[100][100]={0};//各进程所需各类资源的最大需求int Avaliable[100]={0};//系统可用资源char name[100]={0};//资源的名称int Allocation[100][100]={0};//系统已分配资源int Need[100][100]={0};//还需要资源int Request[100]={0};//请求资源向量int temp[100]={0};//存放安全序列int Work[100]={0};//存放系统可提供资源int M=100;//作业的最大数为100int N=100;//资源的最大数为100void showdata()//显示资源矩阵4.相关流程图②银行家算法流程图：三、源代码#include<iostream.h>#include<string.h>#include<stdio.h>#define False 0#define True 1int Max[100][100]={0};//各进程所需各类资源的最大需求int Avaliable[100]={0};//系统可用资源char name[100]={0};//资源的名称int Allocation[100][100]={0};//系统已分配资源int Need[100][100]={0};//还需要资源int Request[100]={0};//请求资源向量int temp[100]={0};//存放安全序列int Work[100]={0};//存放系统可提供资源int M=100;//作业的最大数为100int N=100;//资源的最大数为100void showdata()//显示资源矩阵{int i,j;cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<endl;for (j=0;j<N;j++)cout<<Avaliable[j]<<" ";//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl; cout<<"进程名 ";for(j=0;j<3;j++){for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<" ";}cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";for(j=0;j<N;j++)cout<<Max[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Allocation[i][j]<<" ";cout<<" ";for(j=0;j<N;j++)cout<<Need[i][j]<<" ";cout<<endl;}}int changdata(int i)//进行资源分配{int j;for (j=0;j<M;j++) {Avaliable[j]=Avaliable[j]-Request[j];Allocation[i][j]=Allocation[i][j]+Request[j]; Need[i][j]=Need[i][j]-Request[j];}return 1;}int safe()//安全性算法{int i,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){ apply++;if(apply==N){for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数 Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){cout<<"系统不安全"<<endl;//不成功系统不安全return -1;}}cout<<"系统是安全的!"<<endl;//如果安全，输出成功cout<<"分配的序列:";for(i=0;i<M;i++){//输出运行进程数组cout<<temp[i];if(i<M-1) cout<<"->";}cout<<endl;return 0;}void share()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;//输入须申请的资源号cout<<"请输入进程 "<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<name[j]<<":";cin>>Request[j];//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错{cout<<"进程 "<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理，不予分配！"<<endl;ch='n';break;}else {if(Request[j]>Avaliable[j])//判断申请是否大于当前资源，若大于则 { //出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错，不予分配!"<<endl;ch='n';break;}}}if(ch=='y') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源 safe();//根据进程需求量进行银行家算法判断 }}void addresources(){//添加资源int n,flag;cout<<"请输入需要添加资源种类的数量:";cin>>n;flag=N;N=N+n;for(int i=0;i<n;i++){cout<<"名称:";cin>>name[flag];cout<<"数量:";cin>>Avaliable[flag++];}showdata();safe();}void delresources(){//删除资源char ming;int i,flag=1;cout<<"请输入需要删除的资源名称：";do{cin>>ming;for(i=0;i<N;i++)if(ming==name[i]){flag=0;break;}if(i==N)cout<<"该资源名称不存在，请重新输入：";}while(flag);for(int j=i;j<N-1;j++){name[j]=name[j+1];Avaliable[j]=Avaliable[j+1];}N=N-1;showdata();safe();}void changeresources(){//修改资源函数cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(int i=0;i<N;i++)cout<<name[i]<<":"<<Avaliable[i]<<endl;cout<<"输入系统可用资源[Avaliable]:"<<endl;cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];cout<<"经修改后的系统可用资源为"<<endl;for (int k=0;k<N;k++)cout<<name[k]<<":"<<Avaliable[k]<<endl;showdata();safe();}void addprocess(){//添加作业int flag=M;M=M+1;cout<<"请输入该作业的最打需求量[Max]"<<endl;for(int i=0;i<N;i++){cout<<name[i]<<":";cin>>Max[flag][i];Need[flag][i]=Max[flag][i]-Allocation[flag][i];}showdata();safe();}int main()//主函数{int i,j,number,choice,m,n,flag;char ming;cout<<"*****************银行家算法*****************"<<endl; cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m;cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>Max[i][j];do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j])flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)cout<<"申请的资源大于最大需求量，请重新输入!\n";}while(flag);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){cout<<"**************模拟实现银行家算法***************"<<endl;cout<<" 1:增加资源 "<<endl;cout<<" 2:删除资源 "<<endl;cout<<" 3:修改资源 "<<endl;cout<<" 4:分配资源 "<<endl;cout<<" 5:增加作业 "<<endl;cout<<" 0:离开 "<<endl;cout<<"*******************************************"<<endl;cout<<"请选择功能号：";cin>>choice;switch(choice){case 1: addresources();break;case 2: delresources();break;case 3: changeresources();break;case 4: share();break;case 5: addprocess();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1; }四、程序运行结果及分析T 0 时刻的资源分配表(各种资源的数量分别为：10、5、7)运行结果 1、开始2、增加资源3、删除资源4、修改资源5、分配资源6、增加作业五、课程设计心得与体会银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
