操作系统实验报告-利用银行家算法避免死锁
操作系统实验报告-死锁的避免
操作系统实验报告-死锁的避免操作系统实验（二）死锁的避免1.实验内容使用C++实现模拟随机算法和银行家算法2.实验目的（1）了解死锁的产生原因（随机算法）（2）理解死锁的解决办法（银行家算法）3.实验题目使用随机算法和银行家算法设计程序4.程序流程图主要过程流程图银行家算法流程图安全性算法流程图5.程序代码和运行结果#include <stdio.h>#include<stdlib.h> typedef struct{int A;int B;int C;}RES;#define false 0#define true 1//系统中所有进程数量#define PNUMBER 3//最大需求矩阵RES Max[PNUMBER];//已分配资源数矩阵RES Allocation[PNUMBER];//需求矩阵RES Need[PNUMBER];//可用资源向量RES Available={0,0,0};//安全序列int safe[PNUMBER];void setConfig(){int i=0,j=0;printf("================开始手动配置资源==================\n");//可分配资源printf("输入可分配资源\n");scanf("%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXprintf("输入最大需求矩阵%dx%d\n",PNUMBER,PNUMBER );for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocprintf("输入已分配矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵printf("输入需求矩阵%dx%d\n",PNUMBER,PNUMBER);for (i=0;i<PNUMBER;i++){scanf("%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}printf("================结束配置资源==================\n");}void loadConfig(){FILE *fp1;if ((fp1=fopen("config.txt","r"))==NULL){printf("没有发现配置文件,请手动输入\n");setConfig();}else{int i=0;printf("发现配置文件,开始导入..\n");//可分配资源fscanf(fp1,"%d%d%d",&Available.A,&Available.B,&Available.C);//最大需求矩阵MAXfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);}//已分配矩阵Allocfor (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);}//需求矩阵for (i=0;i<PNUMBER;i++){fscanf(fp1,"%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);}}}//试探分配void ProbeAlloc(int process,RES *res){Available.A -= res->A;Available.B -= res->B;Available.C -= res->C;Allocation[process].A += res->A;Allocation[process].B += res->B;Allocation[process].C += res->C;Need[process].A -= res->A;Need[process].B -= res->B;Need[process].C -= res->C;}//若试探分配后进入不安全状态，将分配回滚void RollBack(int process,RES *res){Available.A += res->A;Available.B += res->B;Available.C += res->C;Allocation[process].A -= res->A;Allocation[process].B -= res->B;Allocation[process].C -= res->C;Need[process].A += res->A;Need[process].B += res->B;Need[process].C += res->C;}//安全性检查bool SafeCheck(){RES Work;Work.A = Available.A;Work.B = Available.B;Work.C = Available.C;bool Finish[PNUMBER] = {false,false,false};int i;int j = 0;for (i = 0; i < PNUMBER; i++){//是否已检查过if(Finish[i] == false){//是否有足够的资源分配给该进程if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C){//有则使其执行完成，并将已分配给该进程的资源全部回收Work.A += Allocation[i].A;Work.B += Allocation[i].B;Work.C += Allocation[i].C;Finish[i] = true;safe[j++] = i;i = -1; //重新进行遍历}}}//如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态for (i = 0; i < PNUMBER; i++){if (Finish[i] == false){return false;}}return true;}//资源分配请求bool request(int process,RES *res){//request向量需小于Need矩阵中对应的向量if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <=Need[process].C){//request向量需小于Available向量if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C){//试探分配ProbeAlloc(process,res);//如果安全检查成立，则请求成功，否则将分配回滚并返回失败if(SafeCheck()){return true;}else{printf("安全性检查失败。
银行家算法实验报告
银行家算法实验报告银行家算法实验报告引言：在计算机科学领域中，银行家算法是一种用于避免死锁的资源分配算法。
它是由荷兰计算机科学家艾兹赫尔·迪科斯彻在1965年提出的。
银行家算法通过合理的资源分配和安全性检查，确保系统中的进程能够安全地执行，避免了资源竞争和死锁的发生。
本篇文章将详细介绍银行家算法的原理、实验设计和结果分析。
一、银行家算法的原理银行家算法基于资源的最大需求和可用性进行资源分配。
它将系统中的资源分为若干类别，并为每个类别分配一个初始数量。
当进程请求资源时，银行家算法会检查该请求是否能够满足，如果满足则分配资源，否则将进程置于等待状态。
算法的核心思想是避免分配资源后导致系统无法满足其他进程的资源需求，从而避免死锁的发生。
二、实验设计为了验证银行家算法的有效性，我们设计了一个模拟实验。
实验中，我们创建了一个包含多个进程和资源的系统，并模拟了进程对资源的请求和释放。
每个进程都有自己的资源需求和最大需求量，系统中的资源总量也是有限的。
首先，我们初始化系统的资源数量和每个进程的最大需求量。
然后，模拟进程的请求和释放过程。
当一个进程请求资源时，银行家算法会检查该请求是否能够满足，如果满足则分配资源，否则将进程置于等待状态。
当一个进程释放资源时，系统将回收该资源并重新分配给其他进程。
实验的关键是设计合理的资源分配策略和进程请求顺序，以模拟不同的场景。
我们通过调整进程的最大需求量和资源数量，观察系统的运行情况和死锁的发生情况。
三、实验结果分析通过多次实验，我们得出了以下结论：1. 资源数量的合理分配对避免死锁非常重要。
如果资源数量过少，无法满足进程的最大需求量，系统容易发生死锁。
如果资源数量过多，系统的资源利用率低，效率低下。
因此，需要根据系统的实际需求合理分配资源数量。
2. 进程的最大需求量与资源数量的关系也是影响死锁的重要因素。
当进程的最大需求量超过系统资源数量的一半时，系统容易发生死锁。
3实验三银行家算法避免进程死锁
实验三预防进程死锁的银行家算法一：需求分析程序设计的任务和目的：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设系统中有n个进程P1, … ,Pn，有m类可分配的资源R1, … ,Rm，在T0时刻，进程Pi分配到的j 类资源为Allocationij个，它还需要j类资源Need ij个，系统目前剩余j类资源Workj个，现采用银行家算法进行进程资源分配预防死锁的发生。
通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
(1)输入的形式和输入值的范围；为免去测试时候需要逐步输入数据的麻烦，输入时采用输入文件流方式将数据放在.txt文件中，第一行为进程个数和资源个数，二者之间用空格隔开。
第二行为进程已分配的各资源个数（之间用空格隔开），第三行为进程仍需要的进程个数（之间用空格隔开），第四行为各个资源的可用数。
运行程序后按照提示输入请求资源的进程号和请求的各资源数。
(2)输出的形式；先输出初始状态下的安全序列，后用户输入申请的进程号和资源数后判断，若为安全状态则输出安全序列，若不安全，则输出不安全。
(3)程序所能达到的功能；可以判断给出的数据是否为安全状态，若安全则输出安全序列，不安全则提示信息。
申请资源后可先判断资源是否合理，若合理则预分配，然后判断是否安全，若安全则输出安全序列，不安全则恢复各数据并提示信息。
(4)测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。
详见运行结果截图。
二：概要设计主程序模块void main()调用银行家算法bool bank()和安全比较算法boolcompare();以及打印输出函数bool bank()；银行家算法bool bank()调用输出函数bool bank(int* availabled,int n,int m)主要思路：先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。
操作系统银行家解决死锁问题
操作系统银⾏家解决死锁问题银⾏家算法解决死锁⼀、实验⽬的死锁会引起计算机⼯作僵死，因此操作系统中必须防⽌。
本实验的⽬的在于了解死锁产⽣的条件和原因，并采⽤银⾏家算法有效地防⽌死锁的发⽣。
⼆、实验设计思路设Request i 是进程Pi 的请求向量。
Request i （j）=k表⽰进程Pi请求分配Rj类资源k个。
当Pi发出资源请求后，系统按下述步骤进⾏检查：1、如果Request i ≤Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最⼤需求量。
2、如果Request i ≤Available，则转向步骤3；否则，表⽰系统中尚⽆⾜够的资源满⾜Pi的申请，Pi必须等待。
3、系统试探性地把资源分配给进程Pi，并修改下⾯数据结构中的数值：Available = Available - Request iAllocation i= Allocation i+ Request iNeed i= Need i - Request i4、系统执⾏安全性算法，检查此次资源分配后，系统是否处于安全状态。
如果安全才正式将资源分配给进程Pi，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
三、运⾏结果1、在程序运⾏中，程序中已经输⼊初值：int MaxAvailable[m]={10,5,7}; //每类资源的个数int Max[n][m]={1,5,3,3,2,4,1,0,2,2,2,2,0,3,2};// 每个进程需要的每类资源最⼤需求个数int Allocation[n][m]={0,1,0,1,0,0,3,0,2,2,1,1,0,0,2};// 已分配给每个进程的每类资源个数int Available[m];int Need[n][m]; //每个进程还需要的每类资源数经过银⾏家算法和安全性算法，输出运⾏成功的进程号。
2、在调整输⼊初值后:int MaxAvailable[m]={10,5,7};int Max[n][m]={7,5,3,3,2,2,9,0,2,2,2,2,4,3,9};int Allocation[n][m]={0,1,0,2,0,0,3,0,2,2,1,1,0,0,2};int Available[m];int Need[n][m];运⾏结果为三、源代码：#includeusing namespace std;const int m=3; //资源类数const int n=5; //进程个数int MaxAvailable[m]={10,5,7}; //每类资源的个数int Max[n][m]={1,5,3,3,2,4,1,0,2,2,2,2,0,3,2};// 每个进程需要的每类资源最⼤需求个数int Allocation[n][m]={0,1,0,1,0,0,3,0,2,2,1,1,0,0,2};// 已分配给每个进程的每类资源个数int Available[m];int Need[n][m]; //每个进程还需要的每类资源数struct Request{int p; //进程int k[m]; //请求资源};bool safe() //安全性算法，判断是否安全{int Work[m]; //系统可分配资源for(int i=0;i{Work[i]=Available[i];}bool Finish[n]; //运⾏结束否for(i=0;iFinish[i]=false;for(int iy=0;iy{for(i=0;i{if(!Finish[i]){for(int j=0;j{if(Need[i][j]>Work[j]) //需求⼤于系统资源数，跳出{break;}}if(j==m) //m个资源都满⾜所需for(int ix=0;ix{Work[ix]+=Allocation[i][ix];}Finish[i]=true;cout<< "[ " < ";break;}}}}for(i=0;i{if(!Finish[i])break;}if(i{cout<< "危险" <return false;}elsereturn true;}void bank(Request r) //银⾏家算法{int i;int j;for(i=0;ifor(j=0;j{Need[i][j]=Max[i][j]-Allocation[i][j];} //进程需求资源矩阵for(i=0;i {Available[i]=MaxAvailable[i];}for(i=0;ifor(j=0;j{Available[j]-=Allocation[i][j];}for(i=0;iif(r.k[i]>Need[r.p][i]) //如果请求>所需，跳出{break;}}if(i{cout<< "Your request over need! " <exit(1);}else{for(i=0;i{if(r.k[i]> Available[i]) //请求>可以使⽤的break;}if(i{cout<< "Process[ " <else //尝试分配{for(i=0;i{Available[i]-=r.k[i];Allocation[r.p][i]+=r.k[i];Need[r.p][i]-=r.k[i];}if(!safe()) //判断分配是否安全，如果不安全，撤销分配{for(i=0;i{Available[i]+=r.k[i];Allocation[r.p][i]-=r.k[i];Need[r.p][i]+=r.k[i];}cout<< "系统处于不安全状态" <}else //如果安全，分配成功}}}void main(){Request r;r.p=1; //默认资源标记为1int request[m]={1,0,2}; //默认请求资源for(int i=0;i{r.k[i]=request[i];}bank(r);}。
银行家算法实验报告
计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计：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<or=Work如找到，执行步骤（3）；否则，执行步骤（4）。
（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work=Work+Allocation;Finish[i]=true;转向步骤（2）。
操作系统银行家算法(避免死锁)实验报告
操作系统实验：银行家算法姓名：李天玮班级：软工1101 学号：201126630117 实验内容：在windows系统中实现银行家算法程序。
实现银行家算法所用的数据结构：假设有5个进程3类资源，则有如下数据结构：1.MAX[5，3] 5个进程对3类资源的最大需求量。
2.A V AILABLE[3]系统可用资源数。
3.ALLOCATION[5,3]5个进程已经得到3类资源的资源量。
4.NEED[5,3]5个进程还需要3类资源的资源量。
银行家算法：设进程1提出请求Request[N]，则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[1,N],则转（2）；否则，出错。
(2)如果Request[N]<=A V ALIABLE，则转（3）；否则，出错。
(3)系统试探非配资源，修改相关数据。
A V ALIABLE=A V ALIABLE-REQUESTALLOCATION=ALLOCA TION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
安全性检查：（1）设置两个工作向量WORK=A V AILABLE；FINISH[M]=FALSE.（2）从晋城集合中找到一个满足下述条件的进程，FINISH[i]=FALSENEED<=WORK如找到，执行（3）；否则，执行（4）。
（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。
WORK=WORK+ALLOCATIONFINISH[i]=TRUEGOTO（2）（4）如所有进程FINISH[M]=TRUE，则表示安全；否则系统不安全。
1.用init（）函数对于数据的初始化关键代码：#define M 5#define N 3void init(){cout<<"请输入5个进程对3类资源最大资源需求量:"<<endl;for(int i=0;i<M;i++){for(int j=0;j<N;j++){cin>>MAX[i][j];}//cout<<endl;}cout<<"请输入系统可用的资哩源数:"<<endl;for(int j=0;j<N;j++){cin>>AVAILABLE[j];}cout<<"请输入5个进程已经-的到的3类资源的资源量:"<<endl;for(int i=0;i<M;i++){for(int j=0;j<N;j++){cin>>ALLOCATION[i][j];}//cout<<endl;}cout<<"请?输?入?5个?进?程ì还1需è要癮3类え?资哩?源′的?资哩?源′量?:"<<endl;for(int i=0;i<M;i++){for(int j=0;j<N;j++){cin>>NEED[i][j];}//cout<<endl;}}// Stack around the variable 'AVAILABLE' was corrupted.显示数据详细信息进行测试输入一号进程号，并给需要申请资源设定为{1,0,2}检验错误输入时候的报错信息检验当再次申请0号资源并申请资源数目为{0,2,0}时，系统提示系统不安全申请不成功。
操作系统实验三报告-预防进程死锁的银行家算法
操作系统实验报告实验三预防进程死锁的银行家算法学号：班级：姓名：【实验目的】通过这次实验，加深对进程死锁的理解，进一步掌握进程资源的分配、死锁的检测和安全序列的生成方法。
【实验内容】问题描述：设计程序模拟预防进程死锁的银行家算法的工作过程。
假设有系统中有n个进程P1, … ,P n，有m类可分配的资源R1, … ,R m，在T0时刻，进程P i分配到的j类资源为Allocation ij个，它还需要j类资源Need ij个，系统目前剩余j类资源Work j个，现采用银行家算法进行进程资源分配预防死锁的发生。
程序要求如下：1）判断当前状态是否安全，如果安全，给出安全序列；如果不安全给出理由。
2）对于下一个时刻T1，某个进程P k会提出请求Request(R1, … ,R m)，判断分配给P k进程请求的资源之后。
3）输入：进程个数n，资源种类m，T0时刻各个进程的资源分配情况（可以运行输入，也可以在程序中设置）；4）输出：如果安全输出安全的进程序列，不安全提示信息。
实现提示：用C++语言实现提示：1）程序中进程调度时间变量描述如下：int Available[MaxNumber];int Max[MaxNumber][MaxNumber];int Allocation[MaxNumber][MaxNumber];int Need[MaxNumber][MaxNumber];int Request[MaxNumber];int SafeOrder[MaxNumber];2）进程调度的实现过程如下：➢变量初始化；➢接收用户输入n，m，（输入或者默认的）Allocation ij，Need ij；➢按照银行家算法判断当前状态安全与否，安全给出安全序列，不安全给出提示；➢如果安全，提示用户输入下一时刻进程P k的资源请求Request(R1, … ,R m)；➢如果不安全或者无新请求则退出。
实验要求：1)上机前认真复习银行家算法，熟悉资源分配和安全检查过程；2)上机时独立编程、调试程序；3)根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图）。
死锁_银行家算法实验报告
实验目的银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法二、实验要求根据银行家算法的基本思想，编写和调试一个实现动态资源分配的模拟程序，并能够有效地防止和避免死锁的发生。
（1）设计思想说明设计银行家算法是为了避免死锁三、实验方法内容1.算法设计思路银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。
这时系统将该进程从进程集合中将其清除。
此时系统中的资源就更多了。
反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他。
请进程等待2.算法流程图3.算法中用到的数据结构数据结构的说明1.可利用资源向量AVAILABLE。
这是一个含有M个元素的数组，其中的每一个元素代表一类可利用的资源数目，其3初始值是系统中所配置的该类全部可哦那个资源的数目，其数值随该类资源的分配和回收而动态的改变。
2.最大需求矩阵MAX。
这是一个M*N的矩阵，它定义了系统中N个进程中的每一个进程对M类资源的最大需求。
3.分配矩阵ALLOCATION。
这也是一个M*N的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。
4.需求矩阵NEED。
这也是一个M*N的矩阵，用以表示每一个进程尚需的各类资源数。
5.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]4.主要的常量变量#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20 int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void changdata(int k);//进程请求资源数据改变int chksec(int s); //系统安全性的检测5.主要模块void inputdata()void showdata()void changdata(int k)void restoredata(int k) int chksec(int s)int chkmax(int s)四、实验代码#include<string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20int M ;int N ;int ALL_RESOURCE[W];int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理void main(){ int i,j;inputdata();for(i=0;i<M;i++){ j=chksec(i);if (j==0) break;}if (i>=M)cout<<"错误提示：经安全性检查发现，系统的初始状态不安全！！！\n"<<endl;else{ cout<<"提示：经安全性检查发现，系统的初始状态安全！"<<endl;bank();}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数，请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数，请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量，即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量，即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量，即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCATION[i][j];if (ALLOCATION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCATION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];AVAILABLE[j]=p;if(AVAILABLE[j]<0)AVAILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量，即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量，即向量available为:"<<endl; cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量，即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量，即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}void changdata(int k){ int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}void restoredata(int k){int j;for (j=0;j<N;j++){ AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}int chksec(int s){int WORK,FINISH[W];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){ WORK=AVAILABLE[j];i=s;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}c{int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号（从P0到P"<<M-1<<"，否则重新输入!）:"; cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在，重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ if(Request[j]>AVAILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){ changdata(i);if(chksec(i)){ cout<<endl;cout<<"该分配会导致系统不安全!!! 本次资源申请不成功，不予分配!!!"<<endl;cout<<endl;restoredata(i);}else{ cout<<endl;cout<<"经安全性检查，系统安全，本次分配成功，且资源分配状况如下所示："<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后，由于该进程所需的某些资源的最大需求量已经满足，"<<endl;cout<<"因此在进程结束后系统将回收这些资源！"<<endl;cout<<"在资源收回之后，各进程的资源需求和分配情况如下所示："<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag; }}五、实验结果1.执行结果2.结果分析银行家算法就是当接收到一个系统资源的分配后找到一个安全序列，使得进程间不会发生死锁，若发生死锁则让进程等待。
银行家算法实验报告
银行家算法实验报告 Company number：【0089WT-8898YT-W8CCB-BUUT-202108】计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计：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<or=Work如找到，执行步骤（3）；否则，执行步骤（4）。
（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work=Work+Allocation;Finish[i]=true;转向步骤（2）。
银行家算法实验报告
银行家算法实验报告引言：在计算机科学领域，由于资源的有限性，进程资源分配问题一直备受关注。
而银行家算法被广泛应用于操作系统中，用于确保资源的安全分配。
本文旨在介绍银行家算法的原理和应用，并通过实验报告来验证该算法的有效性和可行性。
1. 银行家算法简介银行家算法是由美国学者Dijkstra提出的一种资源分配和避免死锁的算法。
其基本思想是通过银行家的原则来避免系统陷入死锁状态，保证资源分配的安全性和可行性。
银行家算法适用于具有多个进程和多个资源的并发系统中。
2. 银行家算法原理银行家算法基于两个重要的概念：安全性和可分配性。
安全性表示在系统当前状态下，是否存在一种资源分配序列可以使系统避免死锁状态。
可分配性表示系统是否能够满足进程对资源的请求。
银行家算法的实现需要以下几个关键步骤：(1) 初始化：对每个进程设置最大需求量、已分配资源量和需求资源量。
(2) 效验：判断系统当前状态下资源是否满足所有进程的需求，即判断系统是否处于安全状态。
(3) 分配：若系统处于安全状态，则根据某种资源分配策略，为进程分配资源。
(4) 请求：进程请求资源。
(5) 回收：进程释放资源。
3. 银行家算法的实验验证为了验证银行家算法的有效性和可行性，我们设置了一个简单的实验环境，模拟一个有限的资源系统，包含3个进程和3种不同类型的资源。
实验过程如下：(1) 初始化：对每个进程设置最大需求量、已分配资源量和需求资源量。
设置3个进程的最大需求量分别为{5, 4, 3}，已分配资源量分别为{1, 2, 2}，需求资源量分别为{3, 2, 0}。
(2) 效验：判断系统当前状态下资源是否满足所有进程的需求。
经过实验验证，我们发现系统当前状态下资源无法满足进程2的资源需求。
为了保证系统的安全性和避免死锁，根据银行家算法原理，我们将不满足资源需求的进程2暂停，并回滚到初始状态。
重新调整资源分配后，系统进入了安全状态。
(3) 分配：为进程1和进程3分配资源。
操作系统银行家算法实验报告_(1)
银行家算法实验报告【实验目的】（1）根据设计题目的要求，充分地分析和理解题目，叙述系统的要求，明确程序要求实现的功能以及限制条件。
（2）明白自己需要用代码实现的功能，清楚编写每部分代码的目的，做到有的放矢，有条理不遗漏的用代码实现银行家算法。
【实验要求】（1）了解和理解死锁；（2）理解利用银行家算法避免死锁的原理；（3）会使用某种编程语言。
【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。
系统按下述步骤进行安全检查：（1）如果Request i≤Need i则继续以下检查，否则显示需求申请超出最大需求值的错误。
（2）如果Request i≤Available则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：Available［j］∶=Available［j］-Request i[j］;Allocation［i,j］∶=Allocation［i,j］+Request i［j］;Need［i,j］∶=Need［i,j］-Requesti［j］;（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
三、安全性算法（1）设置两个向量：①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish［i］∶=false; 当有足够资源分配给进程时，再令Finish ［i］∶=true。
采用银行家算法避免死锁
采用银行家算法避免死锁一、实验目的：观察死锁发生的现象，了解死锁发生的原因。
掌握如何判断死锁发生的方法。
二、实验分析：死锁现象是操作系统各个进程竞争系统中有限的资源引起的。
如果随机给进程分配资源，就可能发生死锁，因此就应有办法检测死锁的发生。
本次实验中采用“银行家算法”判断死锁的发生。
三、实验设计：本实验设计一个3个并发进程共享3种系统资源且每种系统资源有10个的系统。
系统能显示各种进程的进展情况以及检察是否有错误和死锁现象产生。
四、算法说明：“银行家算法”。
按每个进程的申请数量给各个进程试探性分配资源，看能否找到一个序列使各个进程都能正常运行结束。
若能，则不会发生死锁；若不能，则会发生死锁。
五、程序使用说明：1、本程序用于检测错误和是否会发生死锁。
系统有3个进程竞争3种系统资源，每种资源有10个。
2、输入各个进程的最大需求资源数目数组max[3]和已经得到的资源数目数组alloc [3]，系统计算出各个进程还应申请的资源数目数组need[3]。
3、若进程最大需求数大于系统资源数（10），则出错；若进程申请的资源数目大于其需要的最大资源数目，则出错。
银行家算法的具体实现程序：#include <stdio.h>#define R 10#define P 10int SafeCheck(int n,int m,int Max[P][R],int Allocation[P][R],int Available[R],int Need[P][R]){int p,i,j, safeque[P],Work[R],Finish[P]={0},t=0,flag;printf("当前的工作向量为：");for(j=0;j<m;j++){Work[j]=Available[j];printf("%d,",Work[j]);}//设置Work向量while(t<n){//开始寻找可分配的进程for(i=0;i<n;i++){if(Finish[i]==1) flag=0;//跳过已分配结束的进程else flag=1;if(flag){p=i;for(j=0;j<m;j++)if(Need[p][j]>Work[j]) { p=-1; break; }}if(p==i){ printf("找到一个可分配的进程P%d!\n",p); break;} }//顺序循环查找可分配资源的进程if(p!=-1){safeque[t++]=p;//入栈保护Finish[p]=1;//标志该进程结束printf("当前的工作向量为：");for(j=0;j<m;j++){Work[j]+=Allocation[p][j];printf("%d,",Work[j]);}p=-1;//清空当前进程号，以便下一次寻找出新的进程}//找到可分配资源的进程，并重设Work向量else { printf("找不到一个可分配的进程！终止检查！"); break; } }if(t==n){printf("系统存在一个安全序列:");for(t=0;t<n;t++)printf("P%d->",safeque[t]);printf("\n");return 1;}else {printf("系统不安全！会产生死锁！\n"); return 0;}}void main(){int Available[R],Max[P][R],Allocation[P][R],Need[P][R];int i,n,m,j,p,Request[R];int safe1,safe2;//设置第一次检查与第二次检查正确与否的观察变量printf("输入进程总数:");scanf("%d",&n);printf("输入资源类数:");scanf("%d",&m);printf("系统中R0--R%d类资源可利用数（空格隔开）:",m-1);for(i=0;i<m;i++){scanf("%d",&Available[i]);}for(i=0;i<n;i++){printf("P%d进程的每类资源的分配情况如下:\n",i);printf("\tR0--R%d类资源最大数（空格隔开）:",m-1);for(j=0;j<m;j++){scanf("%d",&Max[i][j]);}printf("\tR0--R%d类资源已分配（空格隔开）:",m-1);for(j=0;j<m;j++){scanf("%d",&Allocation[i][j]);Need[i][j]=Max[i][j]-Allocation[i][j];}printf("\tR0--R%d类资源需求数（空格隔开）:",m-1);for(j=0;j<m;j++){printf("%d ",Need[i][j]);}printf("\n");}//初始化进程的资源分配表printf("——————-第一次安全性检查——————\n");safe1=SafeCheck(n,m,Max,Allocation,Available,Need);if(safe1){printf("输入请求请求进程P的进程号:");scanf("%d",&p);printf("输入请求的R0--R%d各类资源数（空格隔开）:",m-1);for(j=0;j<m;j++){scanf("%d",&Request[j]);if(Request[j]>Need[p][j]){printf("所请求的该资源数大于该进程所需求的最大值！终止请求！");safe1=0;break;}if(Request[j]>Available[j]){printf("所请求的该资源数大于系统中所拥有的最大值！终止请求！");safe1=0;break;}}}//第一次安全检查系统安全后判断请求向量的正确性if(safe1){printf("——————-第二次安全性检查——————\n");for(j=0;j<m;j++){Allocation[p][j]+=Request[j];Need[p][j]=Max[p][j]-Allocation[p][j];Available[j]-=Request[j];}//第二次安全检查前试探分配资源给请求资源safe2=SafeCheck(n,m,Max,Allocation,Available,Need);if(safe2==0)for(j=0;j<m;j++){Allocation[p][j]-=Request[j];Need[p][j]=Max[p][j]-Allocation[p][j];Available[j]+=Request[j];}//安全检查失败后重新收回分配给请求进程的资源}}书上的银行家算法例题实现如下：分析：该程序找到的安全序列：第一次检查{p1,p3,p0,p2,p4}第二次检查{p1,p3,p0,p2,p4}虽然与书上例题不一致，但经检验可以找出如上安全序列。
2.操作系统试验--死锁的避免——银行家算法
操作系统实验二死锁的避免——银行家算法一、实验目的银行家算法是避免死锁的一种重要算法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
二、实验要求：编制程序, 依据银行家算法判定本次分配是否安全。
三．算法所用數據結構讲解1．数据结构假设有m个进程N类资源，则有如下数据结构MAX[M*N] M个进程对N 类资源的最大需求量；A V AILABEL[N] 系统可用资源数；ALLOCATION[M*N] M个进程已得到N 类资源的资源量；NEED[M*N] M个进程还需要N 类资源的资源量；2．行家算法设进程I 提出请求Request[N],则（1）若Request[N]<= NEED[I,N],则转(2)；否则出错。
（2）若NEED[I,N] <= A V AILABEL[N],则转3；否则出错。
3．安全性检查（1）从进程集合中找到一个能满足下述条件的进程：①Finish[i]=false; ②Needi≤Work.如找到，执行步骤(2)；否则执行步骤(3)。
（2）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故执行：Work:=Work+Allocation; Finish[i]:=true; Goto step1;（3）如果所有进程的Finish[i]=true，则表示系统处于安全状态；否则，系统处于不安全状态。
四．实验报告要求1．写出实验目的2。
写出实验要求3。
写出实验内容（包括算法，程序流程图及部分实验结果）4．实验总结与体会附：#include "stdio.h"#define M 5 /*总进程数*/#define N 3 /*总资源数*/#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/int MAX[M][N]= {{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/int A V AILABLE[N]={3,3,2};/* M个进程已经得到N类资源的资源量*/int ALLOCATION[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};/* M个进程还需要N类资源的资源量*/int NEED[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};int Request[N]={0,0,0};int i=0,j=0;void main(){char flag='Y';void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();while (flag=='Y'||flag=='y'){printf("输入申请资源的进程号（0~4）：");scanf("%d",&i);while (i<0||i>=M){printf("输入的进程号不存在，请重输入申请资源的进程号（0~4）：");scanf("%d",&i);}for(j=0;j<N;j++){printf("申请资源%d :",j);scanf("%d",&Request[j]);if (Request[j]>NEED[i][j]){printf("进程%d申请的资源数大于进程%d还需要%d类资源的资源量！",i,i,j);printf("申请不合理，出错！请重新选择\n");exit(0);}else{if (Request[j]>A V AILABLE[j]){printf("进程%d 申请的资源数大于系统可用%d类资源的资源量！",i,j);printf("本次分配不成功。
操作系统实验银行家算法
实验三银行家算法一、实验内容简要描述1．实验目标：加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。
2．实验要求：银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
用银行家算法实现资源分配。
设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统，例如，{A,B,C}的资源数量分别为10，5，7。
进程可动态地申请资源和释放资源，系统按进程的申请动态地分配资源，要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
二、报告主要内容1．设计思路A、设计进程对各在资源最大申请表示及初值确定。
B、设定系统提供资源初始状态。
C、设定每次某个进程对各类资源的申请表示。
D、编制程序，依据银行家算法，决定其申请是否得到满足。
2．主要数据结构假设有M个进程N类资源，则有如下数据结构：MAX[M*N] M个进程对N类资源的最大需求量AVAILABLE[N] 系统可用资源数ALLOCATION[M*N] M个进程已经得到N类资源的资源量NEED[M*N] M个进程还需要N类资源的资源量银行家算法：设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。
(1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。
(2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。
(3)系统试探分配资源，修改相关数据：AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
实验4--利用银行家算法避免死锁
实验10 利用银行家算法避免死锁一．实验目的1．加深对死锁概念的理解。
2．能够利用银行家算法，有效避免死锁的发生，或检测死锁的存在。
二．实验内容利用银行家算法写一个程序，判定系统的安全性。
已知某系统有5个进程P0、P1、P2、P3、P4，三类资源A，B，C。
死锁检测程序工作时各进程对资源的需求和占用情况如表10-1所示，当前可用资源向量available=(0,0,0)。
表10-1 进程需求资源情况三．实验程序及分析# define m 3# define n 5main(){int test(int av[],int ned[],int all[]);int available[m]={0,0,0}, need[n][m];int allocation[n][m]={{0,1,0},{2,0,0},{3,0,3},{2,1,1},{0,0,2}};int i,j,g=1;int finish[n]={0,0,0,0,0};clrscr();printf("please input the need resource data\n");for(i=0;i<n;i++)for(j=0;j<m;j++)scanf("%d",&need[i][j]); /*输入need*/j=0; /*以下循环用来寻找能够运行完成的进程Pi*/do{for(i=0;i<n;i++)if (finish[i]==0 && test(need[i],available,allocation[i]))finish[i]=1;j++;}while(j<n);for(i=0;i<n;i++) /*g表示系统是否处于安全状态*/ g=g&&finish[i];if (g) printf("safe state");else printf("not safe state");}int test(int nd[],int av[],int all[]){int z=0;int i;for(i=0;i<m;i++)if (nd[i]>av[i]) break;if (i==m) z=1;if (z==1)for(i=0;i<m;i++)av[i]=av[i]+all[i];return(z);}运行输入：0 0 22 2 20 0 01 0 00 0 2输出结果：safe state10for(int i=0;i<n;i++){cout<<"名称:";cin>>name[flag];cout<<"数量:";cin>>Avaliable[flag++];}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 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();11safe();}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;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机操作系统实验报告题目利用银行家算法避免死锁一、实验目得:１、加深了解有关资源申请、避免死锁等概念,并体会与了解死锁与避免死锁得具体实施方法。
２、要求编写与调试一个系统动态分配资源得简单模拟程序,观察死锁产生得条件,并采用银行家算法,有效得防止与避免死锁得发生。
二、实验内容:用银行家算法实现资源分配:设计五个进程{p0,ｐ1,p2，ｐ３,p4}共享三类资源{Ａ,B,C}得系统,例如,｛A，Ｂ，C}得资源数量分别为1０,5,7。
进程可动态地申请资源与释放资源,系统按进程得申请动态地分配资源,要求程序具有显示与打印各进程得某一个时刻得资源分配表与安全序列;显示与打印各进程依次要求申请得资源号以及为某进程分配资源后得有关资源数据。
三、问题分析与设计:1、算法思路:先对用户提出得请求进行合法性检查,即检查请求就是否大于需要得,就是否大于可利用得。
若请求合法,则进行预分配,对分配后得状态调用安全性算法进行检查。
若安全,则分配;若不安全,则拒绝申请,恢复到原来得状态，拒绝申请。
2、银行家算法步骤:(１)如果Ｒequestｉ<oｒ =Neｅd,则转向步骤(2）;否则，认为出错,因为它所需要得资源数已超过它所宣布得最大值。
(2)如果Rｅｑｕｅsｔ<or＝Ａvａilaｂｌe,则转向步骤(3);否则,表示系统中尚无足够得资源,进程必须等待。
（３)系统试探把要求得资源分配给进程Pi，并修改下面数据结构中得数值:Aｖailable=Aｖaiｌable-Ｒequest[i];Aｌｌoｃａtｉon=Aｌlｏcａｔion＋Reqｕest;Need＝Need－Request；（4)系统执行安全性算法,检查此次资源分配后,系统就是否处于安全状态。
3、安全性算法步骤:（1)设置两个向量①工作向量Work。
它表示系统可提供进程继续运行所需要得各类资源数目,执行安全算法开始时,Wｏrk=Allｏcaｔioｎ;②布尔向量Fiｎiｓh。
它表示系统就是否有足够得资源分配给进程,使之运行完成，开始时先做Finish[ｉ]=fａlse，当有足够资源分配给进程时,令Fiｎiｓｈ[i]=tｒuｅ。
(2)从进程集合中找到一个能满足下述条件得进程:①Fiｎish[i]＝faｌse②Ｎｅｅｄ<oｒ=Worｋ如找到,执行步骤（3);否则,执行步骤(4)。
(3)当进程P获得资源后，可顺利执行，直至完成,并释放出分配给它得资源，故应执行:Work=Wｏｒk+Aｌｌｏcａtion;Fｉnish［i]＝true;转向步骤（2)。
(4)如果所有进程得Finish[i]=true，则表示系统处于安全状态;否则,系统处于不安全状态。
４、流程图:系统主要过程流程图银行家算法流程图安全性算法流程图5、主要数据结构假设有Ｍ个进程Ｎ类资源，则有如下数据结构:inｔ max[M*Ｎ] M个进程对Ｎ类资源得最大需求量ｉnt availabｌe[N] 系统可用资源数ｉnt aｌloｃａtｅd［M*Ｎ] M个进程已经得到N类资源得资源量int need[M*N] Ｍ个进程还需要N类资源得资源量inｔ worｋed[］系统提供给进程继续运行所需得各类资源数目四、源代码impoｒｔ jａva、ａwｔ、＊;iｍport javax、swinｇ、*;ｉｍport jaｖa、utiｌ、*；imporｔjavａ、ａwｔ、event、*；impｏｒt jａvａx、sｗing、border、*；puｂｌic ｃlass ＯsＢanker extends JFrame { // 界面设计ＪLaｂel laｂelInｆo;JＬabel lａbｅlＩnfｏ１;ﻩint rｅsourｃeNuｍ, pｒocessＮuｍ;int coｕnt = 0;ﻩJBｕｔtｏｎｂuttonRｅｑuest, buttoｎＳetIniｔ，ｂutton， buttｏn1，bｕｔtonseaｒｃh，bｕtton２;JＴextField tf1, tｆ2；JTexｔField［] texｔＡｖaiｌaｂｌe;JTｅxｔField[][］textＡlloｃation;ﻩＪTextField[］[］ tｅxtＮeed;ＪＴextFiｅld textProceｓsＮame;ﻩＪTｅｘtＦieｌｄ［] textRequesｔ；iｎt avａilabｌe［］；iｎt max[］[];inｔｎeed[][］；ﻩiｎt allocated[][］；ﻩint SaｆeSeｑuence[];int requｅsｔ[];boｏlean Finish[];ﻩｉnt workｅd[];boolean flａｇ= false;JFraｍe f１；JFrame ｆ2;ﻩJＦrａｍe f3；JTeｘtArea jt；ﻩvoid disｐlay() {Border borｄeｒ = BorｄｅｒＦactｏｒy、creａｔｅＬowerｅｄBeveｌBｏｒｄe ｒ();ﻩBorder bｏrｄeｒＴitled = BoｒdｅrFactoｒy、creatｅTｉtｌeｄBordｅr(ｂorder， "按钮区")；ﻩtextAvaｉlａｂｌｅ= neｗＪTexｔFieｌd[5];ﻩﻩtｅｘtAｌlocａtioｎ = new JTextＦield[６][5];ﻩtextNeed = new JTextField[6][５]；ﻩtextＰroｃｅｓｓＮａme = new JTextFiｅld("")；ﻩtextProcessName、sｅtEnableｄ(falｓｅ);ﻩtextRequest = ｎew JTｅxｔFｉeｌｄ[5]；ﻩtf1 = new ＪＴexｔＦield（20);ﻩtｆ２ = new JＴextFiｅld(2０);ﻩﻩlａbelＩnｆｏ = nｅw JLaｂeｌ(＂请先输入资源个数与进程个数(1～６),后单击确定");ﻩJPanel ｃｏnｔeｎｔPａne;cｏntentＰaｎｅ = (ＪPanｅl） this、ｇetContentPａｎe();ﻩﻩcontentPane、setLayouｔ(ｎull)；cｏｎtｅｎtＰane、setBaｃｋgroｕnｄ(Color、pink);ﻩlabelInｆｏ、seｔBounds(50, 10， 300, ４0);ｌabｅlInfo、sｅtOpaｑuｅ(ｔｒｕｅ）;labｅlＩnfo、setForeｇｒｏuｎd(Coloｒ、rｅd);ｌaｂeｌIｎfo、ｓetBacｋｇrounｄ(Ｃolor、ｐiｎk);cｏntｅntPaｎe、add(ｌabelＩｎfo, nulｌ）;ＪＬａbel ｂ1 = ｎeｗ JLａｂｅl("资源个数:＂)；ﻩｂ1、setForｅground(Color、ｂｌｕｅ);ﻩﻩJLabel b2 = new JLａbel（"进程个数:＂)；ﻩｂ2、sｅtＦorｅｇｒound(Color、bｌue)；ﻩﻩb１、ｓetBounds(50, 8０, 80, 30）;ｃonｔentPａnｅ、adｄ（ｂ１, null);ｔf１、setBoundｓ(1８0, 8０, １70, 30）;ﻩﻩcｏｎtentPanｅ、ａdd(tf1, null);ﻩb２、sｅｔBｏuｎds(50， 150, ８0, 30)；ﻩcoｎtenｔPaｎe、ａdd(b2, null);ﻩtf2、setBｏｕｎds(1８0， 150, １７0, 30);ﻩｃｏｎtentＰane、aｄd（ｔf2, ｎｕｌｌ）;ﻩbuｔｔon1 ＝ new JBｕｔtｏn("确定"）；ﻩbuｔtoｎ = new ＪButtｏn("重置");buｔton1、setBｏｕnds(80, 200， 80, ３０）;ﻩﻩｃｏｎtentPane、add(buｔton1, null);ﻩﻩbutton、setBounds(２2０, 2０0, 80, 3０）;ﻩcontentPane、adｄ(button, nulｌ）;ｔｈis、ｓｅtSize(400，３0０);ﻩﻩthis、setResｉｚable(false);ﻩthiｓ、sｅtＴｉtle（"银行家算法（ＳＸJ）＂);ﻩthｉs、setLocatｉonＲelatiｖeＴｏ(null)；ﻩｔhｉs、setDefaultClｏsｅOｐerａtion(ＥXＩT＿ON_CLOSE)；ﻩthiｓ、setＶｉｓiｂle(truｅ);ﻩﻩf１ = nｅw JＦrame(）;ﻩlabelInfo1 ＝ nｅw ＪＬaｂel(＂请先输入最大需求与分配矩阵,然后单击初始化"）;ﻩﻩＪPaｎｅl ｃontｅntPane１;ﻩcｏｎtentPaｎｅ１＝（ＪＰanｅl） f１、getＣontｅｎtPanｅ(）;ﻩcｏntentPane１、sｅtLａｙout(ｎull）;ﻩﻩcontentPane1、sｅtＢａckgrouｎd(Colｏr、ｐink);ﻩｌabelＩnfo1、sｅｔOpaquｅ(tｒue);ﻩﻩlabelIｎfo1、setＢouｎdｓ(75, 10，４00, 40）;ﻩlabｅlInfo１、seｔBackgroｕnｄ(Ｃolor、ｐｉnk）；ﻩlabelInfo1、sｅtFｏregroｕｎd（Color、blｕe)；ﻩﻩcｏntｅntＰane1、ａdd(labｅlInfo1, null）;ﻩJＬaｂel lａbelAvailableLaｂｅl = new ＪLabeｌ（"AllRｅsoｕｒｃe：")；ＪLabel labｅlNｅeｄLabｅl = new ＪLaｂｅl("ＭaxＮeｅd:＂）;JLａbel laｂeｌAlloｃaｔionＬabｅl = new JLaｂel（"alｌocatｅd:");ﻩﻩJLabｅl ｌaｂeｌRｅｑuｅｓtLabｅl ＝nｅw ＪLａbel("rｅqueｓｔ prｏｃesｓ："); ﻩlabeｌNeedＬabel、setBounds(７5，９0，１０0， 20);ﻩ// ｘ,y,widtｈ,heiｇhtﻩconteｎtPanｅ1、add（lａbｅｌNｅedＬabel, nｕlｌ);ﻩﻩlａｂｅlAllｏcatｉonLaｂel、setBｏunds（75, 2４0, 100， 20);ﻩconteｎtPaｎe1、add(labelAlｌocationLabel, null)；ﻩlａｂｅlAvａｉlａbｌeLａbel、seｔBounds(75, 70, 10０，２0)；ﻩconｔentPａｎe１、ａｄd(laｂeｌＡvailabｌeＬａbeｌ, nuｌｌ）;ﻩlaｂeｌReqｕｅstLaｂeｌ、sｅtBｏunｄs(７5, 400, 100, 2０);ﻩﻩcｏnｔentPａne1、add(lａbeｌRｅquesｔＬabｅl, nulｌ);ﻩJＬａbel[] lａｂeｌProcｅssＬａbel１ = { neｗ JLａbeｌ(＂进程1＂), neｗJLabｅl("进程2＂）,ﻩﻩﻩｎew ＪLabｅｌ(＂进程3＂), ｎew ＪLabeｌ（"进程４"）， neｗＪLabel（"进程５"),ｎｅw JＬａbｅl（＂进程6"）｝；JＬaｂeｌ[] lａbelＰrｏceｓsＬabel2 = { ｎew ＪＬabel("进程1"), neｗ JL ａbｅl("进程2"),ﻩnew JＬａｂel("进程３＂), new JＬaｂel("进程4"), new JＬabel("进程5"),ﻩnｅw ＪLａｂeｌ（"进程6＂) ｝;ﻩJＰａｎeｌｐＰanel1 ＝ｎｅw JPanel(), pPanel2 ＝ neｗＪPaｎel（)，ｐPa ｎｅｌ3 ＝ new JＰａnel(), ｐＰanel4 = neｗ JＰaｎel（）;ﻩpPanel1、ｓｅtLayout(ｎuｌl);ﻩｐPaｎel2、sｅｔLaｙout(nｕll）;/** pPanel4、seｔLayoｕt(nｕll)； pPａnel４、setBounds(440，1２0,90,2７0);* pPanel4、setBoｒder(ｂordeｒTitled）;ﻩ*/ﻩbｕttonSeｔIniｔ = ｎｅw ＪButtoｎ（"初始化＂)；ﻩbutｔonsｅarcｈ= ｎｅw JBｕtｔｏn（"检测安全性");ﻩbｕｔton2 = new JBｕtton(＂重置");ﻩbuttｏnRequｅsｔ = new JButton("请求资源"）;ﻩbuｔtonSetＩnit、setBｏundｓ(420, 1４0, 100, 30)；ﻩｃonｔentＰanｅ1、aｄｄ（ｂutｔonSｅtIniｔ, nuｌl);ﻩﻩbuttonｓearch、ｓetBｏｕndｓ（420, 240, １0０, 30);ﻩｃonｔｅｎｔＰanｅ1、aｄd(buttｏｎｓｅａrch, nuｌl）；buｔton２、setＢoundｓ(4２0, 340， 100, 30);coｎtentPane1、ａdd(button2, null）;ﻩﻩbuttｏnRｅquｅst、setＢｏunds(4２0， 425, 100， 30)；ﻩｃonteｎtＰａne1、add（buttonRｅquest, null);ﻩﻩfor （int pi = 0; pi ＜6; pi++） {ﻩlａbｅlPｒocessLabel1[ｐi]、setＢouｎｄs(0, 0 ＋pi * 20， 60, 20); ﻩﻩlａbｅlPｒｏcesｓＬaｂel2［ｐｉ]、sｅtBounds(０, 0 ＋ pi ＊ 20, 60, 20)；ﻩﻩ}pＰaｎeｌ1、setBoｕnｄｓ(7５, １20，６0, １２0);ﻩpPanel２、setBoｕｎds（75, 270，６0, 1２０);ﻩﻩfor (ｉnｔ pi = ０; pi ＜ 6; pi++) {ﻩﻩpPanel１、ａdｄ（lａbelProcｅｓsLabel1［pi]， null);ﻩﻩｐPａnｅｌ2、ａdd(lａbelProｃeｓsLabeｌ２[ｐｉ］, nｕlｌ）;｝ﻩﻩcontenｔPａnｅ1、add（ｐPanel1);contｅnｔＰane1、aｄd(ｐPaｎｅl2);contentPaｎe1、aｄｄ(ｐＰaneｌ4)；ﻩﻩｆoｒ (inｔ si ＝0; si < 5; si++)ﻩﻩfor (ｉnt pi ＝０; ｐi < 6；ｐi++) {ﻩﻩｔｅｘtNeed[pi][si] = neｗＪＴｅxtＦield（）;ﻩtextNeｅd[pi][si]ﻩﻩﻩ、seｔBoｕndｓ(150 + sｉ＊ 5０, 1２0 + pi * 20, 50, ２０);ﻩﻩtexｔNeed［pi][ｓi]、seｔＥdiｔaｂle(falｓe);ﻩtextＡｌlocａtion[ｐi][ｓi］ = new JＴeｘtＦield();ｔｅｘtAllｏcation[ｐｉ］[si］、sｅｔBounds(15０ + ｓi * ５0，27０ + pｉ * 2０,50， 2０)；ﻩtｅｘtAｌloｃaｔion[pｉ][sｉ］、setＥdｉｔablｅ(falｓe）；ﻩ}ﻩｆｏｒ (int si = ０; si < ５; ｓi++) ｛ﻩﻩﻩｔextＡvａiｌａｂlｅ[ｓｉ] = new JTexｔField(）；ﻩﻩｔextAvａｉlaｂｌe[sｉ]、seｔEdｉtaｂｌe（fａlse）;ﻩﻩteｘtAvaｉlable[si]、setBｏunds(1５0 + ｓｉ * 50, 70, ５0, 2０）;ﻩﻩteｘtReｑuｅsｔ［si] ＝new JTｅxtField（)；ﻩﻩｔexｔRｅqueｓt[si]、seｔＥditａble（ｆaｌse）;ﻩﻩﻩtexｔRequest[ｓi]、sｅtBouｎdｓ（1５0 + si * 5０, 430, ５0, 20）;ﻩﻩｃontｅntPａｎe１、ａdd（ｔｅxtAvaiｌaｂle[ｓi], ｎｕｌl);ｃonｔｅｎtPanｅ1、add(textReqｕest[si］， nulｌ）;ﻩﻩ}ﻩﻩｆoｒ (int ｐi = 0; ｐｉ < 6；ｐi++)fｏr (int si = ０; ｓi < 5; si＋＋） {ﻩﻩcoｎtｅntPanｅ1、ａdd(textNeeｄ[pi］[ｓi]， null)；ﻩﻩcontｅｎtPanｅ1、add(textＡｌlocａtion[pi］[ｓi], null）;ﻩﻩ}ﻩtｅｘtＰrocｅssNamｅ、sｅtＢouｎdｓ(8０, 4３０, 50, 2０)；ﻩconｔeｎtPａne１、add(teｘtＰrocessName，nｕｌl）;ﻩf1、setＳize（５50，５00);ﻩﻩｆ1、ｓｅtResiｚaｂlｅ（false);f１、sｅｔTitｌe("银行家算法(SXJ)");ﻩf1、setLocationRｅlatiｖeTｏ(nuｌｌ);ﻩf1、setDeｆaultCloｓeＯperaｔion(ＥXIT＿ＯN_CLOSE）;ﻩ／／ f1、sｅtＶisiｂle(true）;ﻩf1、setVｉｓible(falsｅ);ﻩf2 = new JFｒame（"安全序列显示框");ﻩﻩjt ＝ nｅw JTextAｒea(7５, 4０)；ﻩjt、sｅtBackgroｕｎd(Coloｒ、pｉnk）;ﻩｊt、sｅtＦｏregroｕnｄ(Cｏlor、blue);ﻩJScｒｏlｌPanｅ scrollPaｎe = ｎeｗ JScrollＰane(jt)； // 加滚动条ﻩscｒoｌlPane、seｔＢｏｒdeｒ(BordｅrFactoｒy、creａteLoweｒeｄBevelＢorder （))；／/ 边界ﻩ(f２、getCｏｎｔentPaｎe（))、add(scrollＰane);f２、ｓetＳｉze(45０，400);f2、ｓｅtResizａble(false)；ﻩf2、seｔＤefaｕltＣｌoseOperａｔｉon（ＥXＩT_ON_ＣLOSＥ);ﻩf2、sｅtVｉsiｂlｅ(faｌｓe);ﻩbｕｔｔonSｅｔInit、setEnabｌed(ｆalsｅ）；ﻩｂuttonReｑｕest、setEnabled（ｆaｌse）;ﻩbuttｏnseａrch、sｅtＥｎaｂled(falｓe);ﻩbuｔｔon１、ａｄdActiｏnＬiｓtｅner(ｎeｗＡcｔｉoｎListeｎeｒ（) { pubｌｉｃ vｏｉd ａctｉｏnPerformed(ＡctionEvenｔ e) {ﻩ/／ lａｂelIｎfｏ、seｔTexｔ("请先初始化allocａtｅd与Maｘneed,后单击初始化按钮")；ﻩﻩf1、sｅtVisiｂｌｅ(ｔrue);ﻩbuttonＳetIｎit、sｅtEnabled(truｅ);ﻩﻩﻩﻩreｓouｒｃeNum = Inteｇeｒ、pａrｓeＩｎt(tf1、getText（）);ﻩprｏcessNｕm = Intｅgｅr、parseInt(tf2、ｇetTeｘt());ﻩﻩfor (int i = 0; i < prｏcessNum； i++) {ﻩﻩfｏr (ｉnt j ＝０; j < resｏuｒceNｕm; j++) {ﻩtextNeed[i]［ｊ]、setＥdiｔable（true)；ﻩﻩﻩtｅｘtAｌlｏcａtion［i][ｊ］、setＥdｉtable(ｔrｕe);ﻩteｘtAvａｉlaｂle［j］、ｓetEdiｔａｂle(true);ﻩﻩﻩﻩ}ﻩﻩﻩﻩ}ﻩﻩ｝);ﻩﻩｂuttoｎSｅtInｉｔ、ａddActｉoｎLｉstener(new ＡｃtｉonＬiｓteneｒ（) { ﻩpｕbliｃｖoｉd aｃtionPerｆorｍed(ActiｏnEｖenｔｅ) ｛ﻩInit（）;ﻩﻩﻩbuｔtonｓｅａrｃh、ｓetＥnabled（tｒｕe);ﻩ}});ﻩbuｔtonｓeａrch、aｄdAcｔiｏnＬistenｅｒ(ｎeｗ ActiｏnLｉstener() ｛ﻩﻩpublic ｖoiｄ actｉonPerfｏrｍed(ActionEvenｔ e) {ﻩcount = ０;ﻩﻩSafeＳｅquenｃe = new int[pｒｏceｓsNｕm］;ﻩﻩworｋｅd ＝ｎew ｉｎt[ｒeｓｏurcｅNum]；Ｆiniｓh = new booleaｎ[processＮuｍ］;ﻩcｏpyVecｔoｒ（workｅd, ａvaiｌable）;ﻩﻩSafety（0）;ﻩﻩﻩﻩjｔ、appeｎd（＂安全序列数量：" + coｕｎt);ﻩiｆ（fｌag) {ﻩﻩlabｅlＩnｆo1、setTｅxt("当前系统状态：安全");ﻩﻩﻩﻩｆ2、ｓetＶｉsｉble(tｒue)；ﻩﻩﻩbｕttｏnRequest、setEnabled（truｅ)；ﻩﻩtextPrｏcesｓNａmｅ、setEnabled(ｔrｕe）;ﻩﻩｆｏr (int i = 0；ｉ < reｓouｒcｅNｕm; i+＋) {ﻩﻩﻩｔexｔＲequest[i］、ｓetEdｉtaｂle（true);ﻩﻩ}} else {ﻩﻩｌabelIｎｆo１、setText("当前系统状态:不安全＂);ﻩﻩ｝ﻩﻩｂutｔonSetInit、setEｎａｂlｅd(faｌse);ﻩﻩﻩ｝ﻩ});ﻩﻩbuttｏnＲeｑueｓt、ａddAcｔiｏｎＬiｓtener(ｎeｗ ActiｏｎLｉstener() {ﻩﻩﻩpｕｂｌiｃ voｉd ａctioｎPerｆoｒmｅd(AｃtｉoｎＥvｅｎt e）｛ﻩﻩcoｕｎt = ０;ﻩﻩﻩfor (ｉnｔ i ＝ 0；i < proｃesｓNum; i++) ｛ﻩﻩﻩFinｉsh[i] = false；ﻩ}ﻩﻩjt、setＴext（"");ﻩﻩﻩflag = false;ﻩＲequestRｅｓｏｕrce();}ﻩﻩ}）;button２、addＡctionLisｔener(nｅw ＡｃtionＬistｅｎer() {ﻩpubｌic vｏiｄ actionPｅrforｍed（ActionＥvent e) {ﻩ * tｆ1、seｔText(""); tｆ2、ｓeｔText(＂");ﻩﻩ */ﻩﻩﻩf2、ｓeｔVisible(falsｅ);ﻩﻩﻩﻩjt、sｅｔText("");ｆor (int i = 0； i < ｐrｏcessNum; i++) ｛ﻩﻩｆor (int j ＝ 0; j < ｒesouｒceNum; ｊ++) ｛ﻩﻩﻩﻩtｅｘtＮeeｄ［i][ｊ]、ｓetTexｔ("");ﻩﻩｔｅxtAlloｃａtion[ｉ][j]、setText（"＂)；ﻩﻩﻩﻩﻩｔｅｘtAｖａilａble[j]、seｔＴext("＂);ﻩﻩﻩｔextＲeｑuest［ｊ]、sｅtＴexｔ("");// tｅxｔNeed[i]［j]、sｅtEｄitable(fａlsｅ)；ﻩﻩﻩﻩ// teｘｔＡｌlocａtion[i]［ｊ]、setEdｉtable(falsｅ)；ﻩﻩ／/ tｅxｔAｖaｉlable[j]、seｔEdｉtａble(ｆalse);ﻩﻩtextＲｅqｕest［ｊ]、ｓeｔEditable(falsｅ）;ﻩﻩﻩteｘtProcesｓＮaｍｅ、setＴｅｘt("");ﻩﻩﻩFinish［i] = ｆalsｅ;ﻩ}ﻩﻩﻩ}ﻩﻩﻩflａｇ= ｆaｌｓｅ;ﻩﻩﻩbuttｏnseａrｃh、setＥnaｂled(ｆalse)；ﻩﻩﻩ// lａbｅlIｎｆo、setＴext("请先输入资源个数与进程个数,后单击确定"); ﻩﻩﻩ｝ﻩ});ﻩbuｔton、ａdｄActｉonLｉsｔener（new AｃtｉonListｅｎｅr（) ｛ﻩﻩﻩｐublic voｉｄ aｃｔionPｅｒformed（AcｔｉonＥvent e) {ﻩｔf1、ｓｅtText（"＂);ﻩﻩﻩtｆ2、setText("");ﻩﻩf2、setＶisible(ｆalse）;jt、sｅｔＴexｔ("");ﻩﻩｆｌag = false;ﻩﻩ}ﻩﻩ});ﻩ}ﻩvｏid copyVeｃtｏr(iｎt[] v1, ｉnｔ[］ v2) {ﻩﻩfor (iｎt i = 0; ｉ< v1、lｅnｇth; i++）ﻩﻩｖ1[i] = v2[i];ﻩ}ﻩvoid Add（ｉｎt[］v１，ｉｎt[］ v2) ｛ﻩﻩfor （ｉnt ｉ = 0; i < v1、length; ｉ++)v1[i］ += v２[i］;ﻩ}voｉｄ Sub(iｎt[］ v１, iｎt［] v2) {ﻩfoｒ (ｉnt i = 0; i < v1、length; i＋+)ﻩﻩv1[i] -= v２[i］;}ﻩbooｌean Smalｌｅr(inｔ[] v１, ｉnｔ[] v2) ｛ﻩｂooleａｎ value ＝ truｅ;for （ｉnt i = ０; ｉ＜ｖ1、lenｇtｈ; i＋+)ﻩiｆ (v１[i] ＞v2[i]) {ﻩﻩvaluｅ = ｆalse;ﻩﻩﻩﻩbreak；ﻩﻩ}ﻩreturn ｖalue;ﻩ｝public staｔic void main（Sｔring[] args) {ＯsBaｎker oｂ＝ new OsBanｋer（）；oｂ、dｉｓpｌay();ﻩ／/ Sysｔｅm、out、prｉntln(" "＋ｃoｕｎｔ）;ﻩ}ﻩvoid Inｉｔ() // 初始化操作矩阵｛ﻩﻩavailａble = new iｎｔ[resｏurcｅＮum];ﻩﻩfor (inｔｉ＝０; i < rｅｓoｕｒceNum; i++) {ﻩａvaｉlable[i] = Intｅger、paｒseIｎt(textＡvailａble[i]、gｅtTeｘt()); ﻩﻩ}ﻩmax = ｎew iｎｔ[proceｓsNum］[ｒeｓouｒcｅNum];aｌlocaｔeｄ = new inｔ［processNum］[ｒesouｒｃeNｕm]；ｎｅed = new iｎt[processNum］［resoｕrceＮｕm]；ﻩｆｏｒ（int ｉ= 0；ｉ < pｒoｃｅsｓNum; i++）｛ﻩﻩfoｒ(ｉnt j ＝ 0； j < reｓoｕrceNuｍ; j++) ｛ﻩmａx[ｉ][j] ＝ Intｅgeｒ、parseInｔ(tｅxｔNｅed[ｉ]［j]、getTexｔ()）；ﻩﻩallｏcａｔed[i］[j] = Ｉｎtｅｇer、parｓeIｎｔ（textAｌｌocａｔiｏｎ[ｉ][j]ﻩﻩ、getＴext(））;｝ﻩ}ﻩﻩfor (iｎt ｉ＝ 0; ｉ< resｏｕrcｅNum；ｉ＋+)ﻩﻩfor (iｎt j = 0; j < processNum; ｊ+＋)ﻩﻩﻩｎeeｄ[ｊ]［ｉ］＝ max［j][i] - alｌocａｔed［j][i]；ﻩfor (inｔi = ０; i < reｓoｕｒcｅNum; i++)ﻩﻩfoｒ (int ｊ = 0; ｊ < processＮuｍ; j＋+） {ﻩﻩﻩavailaｂle[i] －＝aｌｌｏcatｅｄ[j][i];ﻩﻩﻩif (aｖailablｅ［i］< ０) {ﻩlabelInfｏ、sｅtTexｔ("您输入得数据有误，请重新输入＂);ﻩﻩﻩ｝ﻩ}｝ﻩvｏｉｄSafeｔy(int ｎ) /／查找所有安全序列ﻩ{ﻩif (ｎ == ｐｒoｃｅｓsＮum） {counｔ+＋;ﻩﻩfｏr （ｉnt i = ０; i < processＮum; i＋+) {ﻩﻩﻩjt、ａppend("进程" + （SafｅSｅqｕence[ｉ］ + １) + " ");ﻩ}ﻩjｔ、ａppenｄ(＂＼n"）;ﻩﻩflag = tｒue;ﻩﻩｒetｕrn;}ｆor (int i = 0; i < ｐrocessＮuｍ; i++) ｛ﻩﻩif (Finｉsｈ[i］ == false) {ﻩbooleａn ＯK = true;ﻩﻩｆｏr (inｔｊ = ０； j < resoｕｒｃeＮum; j++) ｛ﻩiｆ (nｅed[i][j］> ｗoｒｋeｄ[j]) ｛ﻩﻩOK = fａlse;ﻩﻩﻩｂｒeaｋ;ﻩﻩﻩﻩ｝ﻩﻩ}ｉf (ＯK) {ﻩﻩfor (int j ＝ 0; j ＜ resoｕｒceNum； j+＋) ｛ﻩﻩｗｏrｋed［j] +＝ allocaｔed[i][j]；}Finish[ｉ] = true；ﻩSafeＳequｅnce[n] = i;Sａfety(ｎ + 1）；ﻩﻩFinish[ｉ] = ｆalse;ﻩﻩSaｆeSeqｕence[ｎ] = －1；ﻩﻩﻩ／/ num++;ﻩﻩﻩﻩfoｒ(ｉnt j = 0; ｊ< reｓoｕｒceNｕm; j＋+）｛ﻩﻩﻩworｋed[j] -= ａlloｃated[ｉ][ｊ］；ﻩﻩﻩ}ﻩﻩ｝ﻩ}ﻩ}ﻩ}ﻩｖoid ＲequesｔResｏurｃe(） { ／/ 请求资源ﻩﻩjt、seｔＴexｔ(""）;ﻩﻩiｎt proceｓsnａme = （Intｅgｅr、ｐａrsｅIｎt(ｔeｘtProceｓｓNaｍｅ、getText()）- 1);ﻩﻩｒequesｔ = new int[resourceNuｍ];ﻩﻩfor (int i = 0; i < rｅsouｒcｅＮum; i＋+) {ｒeqｕesｔ[i］＝ Iｎtｅger、ｐarseＩｎt(teｘｔＲeqｕest[ｉ]、getTexｔ())；}ﻩif (!Smａｌler(request, need［prｏceｓsname］)) {ﻩﻩｌａbelIｎｆo、ｓeｔTexｔ("资源请求不符该进程得需求量、＂);ﻩ｝ｅlsｅif (!Smaｌleｒ（rｅquest， availaｂｌe）) {ﻩlabelInfo1、setTｅxt("可用资源不足以满足请求,进程需要等待、");} else {Sub(aｖailabｌe, ｒequest);Add(ａｌloｃated[pｒｏceｓｓｎame]， request);ﻩﻩSub(nｅed[pｒoceｓsｎame], requeｓt)；ﻩｃopyVector（ｗｏrkeｄ, ａvailable);ﻩﻩﻩＳａfety(0);if (ｆｌaｇ) {ﻩﻩﻩlabelInfo1、setText（"可立即分配给该进程！");ﻩﻩ} elsｅ {ﻩﻩﻩﻩｌａbｅｌＩnｆｏ１、sｅtTｅｘt（"分配后导致系统处于不安全状态!,不可立即分配＂)；ﻩﻩAｄd(available, reqｕest）;ﻩﻩＳub(alｌocateｄ[prｏcｅssｎame］, rｅquｅsｔ);ﻩＡdd（need［prｏcessname]， request);ﻩﻩ}}ﻩ/／ }｝}五、实验结果:初始界面:初始化:检测安全性:请求资源：(1)进程2（1，0,2)(２）进程5(3,3,0)(3）进程1（０,2，0)六、遇到得问题及不足之处:１、程序编写得时候规定最大资源数与最大进程数均<=6。