操作系统实验报告利用银行家算法避免死锁
银行家算法模拟实验

实验二
课程名称:操作系统
课程类型:必修
实验项目名称:银行家算法
实验题目:采用银行家算法避免死锁
一、实验目的
通过本次实验,使学生掌握死锁的概念和产生死锁的原因和必要条件,预防和避免死锁的方法,死锁的检测与解除。
通过本次实验,使学生加深了对死锁概念的理解和掌握,深刻领会银行家算法的实质及实现过程。
二、实验要求及实验环境
设计一个能动态检查n个资源、m个进程的系统是否安全并且能实施动态分配的程序。
(具体个数可由键盘输入)。
每一个进程可动态、随机提出申请各个资源的数量,如果系统能满足并且分配后系统仍处于安全状态,那么写出一个安全序列,表明系统是安全的;若系统不安全,那么不分配资源。
三、设计思想
1
图1-1主程序的流程图
图1-2初始化算法init()的流程图
图1-3银行家算法allo()的流程图
? 不满足,等待
F
T F 请求超量,
图1-4模拟资源分配算法require ()的流程图
图1-5安全算法()的流程图
2.逻辑设计
用结构体数组表示m个进程,其中包括使用数组形式的线性表表示进程对各个资源需要的总资源数、对各个资源已占用的资源数,还需要的资源数。
3、物理设计
全局变量
int n,m;
struct info//进程信息
{
int claim[50];//最大占用资源数
int allocation[50];//已经占有的资源数
int need[50]; //还需要的资源数
}pro[50];
int available[50];//剩余资源数
int request[50];//需求资源数量。
操作系统实验报告-死锁的避免

操作系统实验报告-死锁的避免操作系统实验(二)死锁的避免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("安全性检查失败。
实验6 银行家算法避免死锁

#define m 3
#define n 5
main()
{
inttest(ntav[],intned[],intall[]);
intavailable[m]={0,0,0},need[n][m];
intallocation[n][m]={{0,1,0},{2,0,0},{3,0,3},{2,1,1},{0,0,2}};
资源
请求进程
已占有资源Allocation
A B C
尚需资源Need
A B C
P0
0 11
0 0 2
P1
2 00
2 2 2
P2
3 0 3
0 0 0
P3
2 1 1
1 0 0
P4
0 0 2
0 0 2
#define m 3
#define n 5
main(){
inttest(intav[],intned[],all[]);
intavailable[m]={0,0,0},need[n][m];
intallocation[n][m]={{0,1,0},{2,0,0},{3,0,3},{2,1,1},{0,0,2}};//已占有资源
inti,j,g=1;
intfinish[n]={0,0,0,0,0};//已完成的进程
clrscr();//清屏
else
printf("not safe state");
}
inttest(intav,intned[n],intall[n])//安全性算法
{
intFinish=0;
intwork;
work=av;
利用银行家算法避免死锁

利用银行家算法避免死锁一、实现银行家算法中的几个数据结构假设n为系统中的进程数量,m为资源的种类数量,我们需要下列数据结构1)、可使用资源向量Available.为一个长度为m的数组,其中每一个元素代表该类可使用资源的数量。
其初始值为系统中所配置的该类参数全部可使用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果A vailable [j] = k 则表示系统中R j类资源有k个可被使用。
2)、最大需求矩阵Max为一个n*m的矩阵,表示系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max_vector[i][j] == k 则表示进程P i需要R j类资源数目为k。
3)、已分配矩阵Allocation为一个n*m的矩阵,表示系统中每一类资源当前已分配给每一个进程的资源数。
如果allocation [i][j] == k表示进程P i当前已分配得到R j类的资源的数目为k。
4)、需求矩阵Need为一个n*m的矩阵,表示系统中每一个进程为了完成任务还需要的各类资源数目。
如果Need[i][j] == k表示进程P i还需要R j类资源k个才能完成任务。
上述数据结构之间的关系为Need[i][j] = Max[i][j] – Allocation[i][j]资源请求算法假设Request i为进程P i的请求向量。
如果Request i[j] ==k,表示进程P i需要k个Rj类型的资源。
当进程P i发出资源分配的请求之后,系统按照下述步骤进行检查。
Step1) if Request i<= Need i, go to step 2.Otherwise, raise an error condition,because the process has exceeded its maximum claim.Step2) if Request i<= A vailable, go to step3. Otherwise, P i must wait, because the rousouces are not enough.Step3) 系统试探把要求的资源分配给进程P i ,并修改下面数据结构中的数值Available = Available -Request iAllocation i = Allocation i+Request iNeed i = Need i -Request iStep4) 系统执行安全性算法,检查此次资源分配之后,系统是否处在安全状态,若安全,才正是将资源分配给进程P i,以完成本次分配;否则将试探分配作废,恢复原来的资源分配状态,让进程P i等待。
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);}。
利用银行家算法避免死锁

12
利用银行家算法避免死锁
(3)安全性算法 安全性算法执行步骤如下: ⅰ. 初始化设置工作向量Work[m]表示 系统可提供的各类资源数目,用以保 护原数据结构有关值。Work = Available,设置完成标志向量 Finish[n]。Finish[i] = false 表示i进程 尚末完成,如值为true则表示进程i已 完成。 ⅱ.从进程集合n中找到一个能满足下述 二个条件: Finish[i] = false和 Necdi≤Work,如找到则执行步骤ⅲ, 如找不到同时满足以上二条件的进程 则执行步骤ⅳ。
3
死锁的预防(Deadlock Prevention)
预防死锁的方法是破坏四个产生死锁的必要条件之一。 破坏互斥条件
互斥使用是资源本身特征所决定的。使用硬软件结合 可改变资源本身特性,例如采用SPOOLing技术可将“ 独享” 打印机改变为“共享”的打印机。
破坏不可抢占条件
如果一个进程的申请没有实现,它要释放所有占 有的资源 破坏请求和保持条件
7 5
3 0 2 7 2 1 1
0 0 2
6 0 0
0 1 1 4 3 1
⑤ 7 5
② 5 3 2 ③ 7 4 3 7 7
The system is in a safe state since the sequence 16
(2) P1 Request (1,0,2)
检查Request1(1,0,2)≤Need1(1,2,2), (that is
13
利用银行家算法避免死锁-4
当进程Pi获得资源后可顺利执行直到完 成,并释放出分配给它的资源,表示如下:
ⅲ.
work = work+Allocationi ; Finish[i]=true ;转 执行步骤 ⅱ 。
实验10 利用银行家算法避免死锁

3
实验10 利用银行家算法避免死锁 实验
三.实验程序及分析
4
THE END
5
一、 实验目的 二、 实验内容 三、 实验程序及结果分析
1
实验10 利用银行家算法避免死锁 实验
实验10 利用银行家算法避免死锁 实验 实验10 利用银行家算法避免死锁 实验
一.实验目的: 实验目的:
(1)加深对死锁概念的理解。 )加深对死锁概念的理解。 (2)能够利用银行家算法,有效避免死锁的 )能够利用银行家算法, 发生,或检测死锁的存在。 发生,或检测死锁的存在。
2
实验10 利用银行家算法避免死锁 实验
二.实验内容: 实验内容:
利用银行家算法,写一程序, 利用银行家算法,写一程序,判定系统的 安全性。已知某系统有5个进程 个进程P1, , , 安全性。已知某系统有 个进程 ,P2,P3, P4,P5,三类资源 ,B,C。资源类 共有 个 共有7个 , ,三类资源A, , 。资源类A共有 资源,资源类B共有 个资源,资源类C共有 共有2个资源 共有6个 资源,资源类 共有 个资源,资源类 共有 个 资源。 资源。如果死锁检测程序工作时各进程对资源的 需求和占用情况如下表所示。 需求和占用情况如下表所示。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
计算机操作系统实验报告题目利用银行家算法避免死锁一、实验目的:1、加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
2、要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用银行家算法,有效的防止和避免死锁的发生。
二、实验内容:用银行家算法实现资源分配:设计五个进程{p0,p1,p2,p3,p4}共享三类资源{A,B,C}的系统,例如,{A,B,C}的资源数量分别为10,5,7。
进程可动态地申请资源和释放资源,系统按进程的申请动态地分配资源,要求程序具有显示和打印各进程的某一个时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
三、问题分析与设计: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)。
(4)如果所有进程的Finish[i]=true,则表示系统处于安全状态;否则,系统处于不安全状态。
4、流程图:系统主要过程流程图银行家算法流程图安全性算法流程图5、主要数据结构假设有M个进程N类资源,则有如下数据结构:int max[M*N] M个进程对N类资源的最大需求量int available[N] 系统可用资源数int allocated[M*N] M个进程已经得到N类资源的资源量int need[M*N] M个进程还需要N类资源的资源量int worked[] 系统提供给进程继续运行所需的各类资源数目四、源代码import .*;import .*;import .*;public class OsBanker extends JFrame { etBounds(0, 0 + pi * 20, 60,20);labelProcessLabel2[pi].setBounds(0, 0 + pi * 20, 60, 20);}(75, 120, 60, 120);(75, 270, 60, 120);for (int pi = 0; pi < 6; pi++) {(labelProcessLabel1[pi], null);(labelProcessLabel2[pi], null);}(pPanel1);(pPanel2);(pPanel4);for (int si = 0; si < 5; si++)for (int pi = 0; pi < 6; pi++) {textNeed[pi][si] = new JTextField();textNeed[pi][si].setBounds(150 + si * 50, 120 + pi * 20, 50, 20);textNeed[pi][si].setEditable(false);textAllocation[pi][si] = new JTextField();textAllocation[pi][si].setBounds(150 + si * 50, 270 + pi * 20,50, 20);textAllocation[pi][si].setEditable(false);}for (int si = 0; si < 5; si++) {textAvailable[si] = new JTextField();textAvailable[si].setEditable(false);textAvailable[si].setBounds(150 + si * 50, 70, 50, 20);textRequest[si] = new JTextField();textRequest[si].setEditable(false);textRequest[si].setBounds(150 + si * 50, 430, 50, 20);(textAvailable[si], null);(textRequest[si], null);}for (int pi = 0; pi < 6; pi++)for (int si = 0; si < 5; si++) {(textNeed[pi][si], null);(textAllocation[pi][si], null);}(80, 430, 50, 20);(textProcessName, null);(550, 500);(false);("银行家算法(SXJ)");(null);(EXIT_ON_CLOSE);dd(scrollPane);(450, 400);(false);(EXIT_ON_CLOSE);(false);(false);(false);(false);(new ActionListener() {public void actionPerformed(ActionEvent e) { etEditable(true);textAllocation[i][j].setEditable(true);textAvailable[j].setEditable(true);}}}});(new ActionListener() {public void actionPerformed(ActionEvent e) { Init();(true);}});(new ActionListener() {public void actionPerformed(ActionEvent e) { count = 0;SafeSequence = new int[processNum];worked = new int[resourceNum];Finish = new boolean[processNum];copyVector(worked, available);Safety(0);("安全序列数量:" + count);if (flag) {("当前系统状态:安全");(true);(true);(true);for (int i = 0; i < resourceNum; i++) { textRequest[i].setEditable(true);}} else {("当前系统状态:不安全");}(false);}});(new ActionListener() {public void actionPerformed(ActionEvent e) { count = 0;for (int i = 0; i < processNum; i++) { Finish[i] = false;}("");flag = false;RequestResource();}});(new ActionListener() {public void actionPerformed(ActionEvent e) { /** (""); ("");*/(false);("");for (int j = 0; j < resourceNum; j++) { textNeed[i][j].setText("");textAllocation[i][j].setText("");textAvailable[j].setText("");textRequest[j].setText("");etEditable(false);etEditable(false);etEditable(false);textRequest[j].setEditable(false);("");Finish[i] = false;}}flag = false;(false);etText());}max = new int[processNum][resourceNum]; allocated = new int[processNum][resourceNum]; need = new int[processNum][resourceNum];for (int i = 0; i < processNum; i++) {max[i][j] = (textNeed[i][j].getText());allocated[i][j] = (textAllocation[i][j].getText());}}for (int i = 0; i < resourceNum; i++)for (int j = 0; j < processNum; j++)need[j][i] = max[j][i] - allocated[j][i];for (int i = 0; i < resourceNum; i++)for (int j = 0; j < processNum; j++) {available[i] -= allocated[j][i];if (available[i] < 0) {("您输入的数据有误,请重新输入");}}}void Safety(int n) etText());}if (!Smaller(request, need[processname])) { ("资源请求不符该进程的需求量.");} else if (!Smaller(request, available)) {("可用资源不足以满足请求,进程需要等待.");} else {Sub(available, request);Add(allocated[processname], request);Sub(need[processname], request);copyVector(worked, available);Safety(0);if (flag) {("可立即分配给该进程!");} else {("分配后导致系统处于不安全状态!,不可立即分配");Add(available, request);Sub(allocated[processname], request);Add(need[processname], request);}}// }}}五、实验结果:初始界面:初始化:检测安全性:请求资源:(1)进程2(1,0,2)(2)进程5(3,3,0)(3)进程1(0,2,0)六、遇到的问题及不足之处:1、程序编写的时候规定最大资源数和最大进程数均<=6。