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

实验二
课程名称：操作系统
课程类型：必修
实验项目名称：银行家算法
实验题目：采用银行家算法避免死锁
一、实验目的
通过本次实验，使学生掌握死锁的概念和产生死锁的原因和必要条件，预防和避免死锁的方法，死锁的检测与解除。

通过本次实验，使学生加深了对死锁概念的理解和掌握，深刻领会银行家算法的实质及实现过程。

二、实验要求及实验环境
设计一个能动态检查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("安全性检查失败。

利用银行家算法避免死锁一、实现银行家算法中的几个数据结构假设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等待。

实验三预防进程死锁的银行家算法一：需求分析程序设计的任务和目的：设计程序模拟预防进程死锁的银行家算法的工作过程。

假设系统中有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）设计思想说明设计银行家算法是为了避免死锁三、实验方法内容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.结果分析银行家算法就是当接收到一个系统资源的分配后找到一个安全序列，使得进程间不会发生死锁，若发生死锁则让进程等待。

模拟通过银行家算法避免死锁一、银行家算法产生(de)背景及目(de)1：在多道程序系统中,虽然借助于多个进程(de)并发执行来改善系统(de)利用率,提高系统(de)吞吐量,但可能发生一种危险—死锁.死锁就是多个进程在运行过程中因争夺资源而造成(de)一种僵局,当进程处于这种僵局状态时,如无外力作用,他们将无法再向前进行,如再把信号量作为同步工具时,多个Wait和Signal操作顺序不当,会产生进程死锁.然而产生死锁(de)必要条件有互斥条件,请求和保持条件,不剥夺条件和环路等待条件.在预防死锁(de)几种方法中,都施加了较强(de)限制条件,在避免死锁(de)方法中,所施加(de)条件较弱,有可能获得令人满意(de)系统性能.在该方法中把系统(de)状态分为安全状态和不安全状态,只要能使系统都处于安全状态,便可避免死锁.2：实验目(de)：让学生独立(de)使用编程语言编写和调试一个系统分配资源(de)简单模拟程序,了解死锁产生(de)原因及条件.采用银行家算法及时避免死锁(de)产生,进一步理解课堂上老师讲(de)相关知识点.银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作(de)客户.如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全(de).二：银行家算法中(de)数据结构1：可利用资源向量Available.这是一个含有m个元素(de)数组,其中(de)每个元素代表一类可利用(de)资源数目,其初始值是系统中所配置(de)该类全部可用资源(de)数目,其数值随该类资源(de)分配和回收而动态(de)改变.如果Available[j]=k,z则表示系统中现有Rj类资源K 个.2：最大需求矩阵Max.这是一个nm(de)矩阵,它定义了系统中n个进程中(de)每一个进程对m类资源(de)最大需求.如果Max[i,j]=k,表示第i个进程需要第Rj类资源(de)最大数目k个.3: 分配矩阵Allocation,也是nm(de)矩阵,若Allocation[i,j]=k,表示第i个进程已分配Rj类资源(de)数目为k个.4：需求矩阵Need.也是一个nm(de)矩阵,Need[i,j]=k,表示第i个进程还需Rj类资源k个.三、银行家算法及安全性算法1：银行家算法设Request[i]是进程Pi(de)请求向量,若Request[i][j]=k;表示进程需要j类资源k个.当Pi发出资源请求时,系统按下属步骤进行检查；(1)如果Request[i][j]<=Need[i][j];便转向步骤（2）,否则认为出错,因为它所需要(de)资源数已超过他所宣布(de)最大值.(2)如果Request[i][j]<=Available[i][j],便转向步骤（3）,否则认为尚无足够资源,进程需等待.(3)系统试探着把资源分配给进程,并修改下面数据结构(de)数据Available[i][j]=Available[i][j]-Request[i][j];Allocation[i][j]=Allocation[i][j]+Request[i][j];Need[i][j]=Need[i][j]-Request[i][j];(4)系统执行安全性算法,检查此次资源分配后系统是否处于安全状态.若安全,才正式将资源分配给进程Pi,已完成此次分配.否则,将本次(de)试探分配作废,回复原来(de)资源分配状态,将进程Pi等待.2：安全性算法（1）设置两个向量；1：工作向量Work,表示系统可提供给进程运行所需(de)各类资源数目,它含有m个元素,初始时Work=Available2：Finish ,表示系统是否有足够(de)资源分配给进程,使之运行完成.开始时先做Finish[i]=true（2）从进程中找到一个能满需下属条件(de)进程1；Finish[i]=false；2：Need[i][j]<=Work[j];若找到执行步骤（3）,否则执行步骤（4）（3）当进程Pi顺利获得资源后,直至完成,并释放分配给它(de)资源,执行：Work[j]=Work[j]+Allocation[i][j];Finish[i]=true;Go to step (2);(5)如果所有(de)进程Finish[i]都满足,则表示系统处于安全状态,否则,处于不安全状态.四、模块设计与分析及整体功能概述模块设计与分析：整个银行家算法分为初始化函数Init（）,安全性算法函数 safe（）,银行家算法函数bank（）三部分.初始化函数生成开始时刻系统中(de)进程和资源情况,安全性算法判断当某进程申请资源时,系统能否处于安全状态.在本实验中,若系统处于安全状态,便生成一个安全进程序列（安全序列可能有多个）.银行家算法函数bank（）负责整体(de)检查与异常判断.整体功能概述：死锁会引起系统陷入僵局,操作系统必须防止此现象(de)发生.本实验通过一个动态分配资源(de)模拟程序,更清楚(de)理解死锁产生(de)原因和条件.Dijkstra(de)银行家算法是最有代表性(de)避免死锁(de)方法.运行程序时用户设定系统中进程和可利用资源(de)种类数目.输入各进程(de)可利用资源Available,最大需求MAX,已分配资源Allocation ,需求资源Need,之后各系统发出资源请求Request,利用实验中(de)安全性算法判断能否产生一个安全性队列,若能,则给该进程分配成功,否则,不予分配.五、流程图设计六、源代码及调试分析include<>define MAXm 50用Vc++编译程序编写银行家算法,进一步理解到通过银行家算法避免死锁(de)思想,同时也理解了系统死锁产生(de)原因及条件.2.在实验过程中所有(de)设计步骤遵循老师教授(de)程序功能化(de)思想,分别定义了三个函数,init()初始化函数,safealg()安全性算法函数,bank（）银行家算法函数,体现了函数(de)模块化思想.这样(de)话,不仅提高了程序(de)可读性和可操作性,而且还提高了CPU(de)利用率和内存(de)利用率,因为程序(de)运行是局部性(de),这种思想对于段页式存储管理系统尤为重要.3.实验过程中遇到(de)种种疑难问题通过自己上网查找答案,锻炼了自己纠错能力和搜索有价值信息(de)能力及自学(de)能力,并且进一步巩固了自己以前学过(de)专业知识.。

采用银行家算法避免死锁一、实验目的：观察死锁发生的现象，了解死锁发生的原因。

掌握如何判断死锁发生的方法。

二、实验分析：死锁现象是操作系统各个进程竞争系统中有限的资源引起的。

如果随机给进程分配资源，就可能发生死锁，因此就应有办法检测死锁的发生。

本次实验中采用“银行家算法”判断死锁的发生。

三、实验设计：本实验设计一个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}虽然与书上例题不一致，但经检验可以找出如上安全序列。

操作系统实验二死锁的避免——银行家算法一、实验目的银行家算法是避免死锁的一种重要算法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

二、实验要求：编制程序, 依据银行家算法判定本次分配是否安全。

三．算法所用數據結構讲解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("本次分配不成功。

操作系统实验报告银行家算法避免死锁时间：2014-04-17计122吴泽元1213023057计122 刘奔1213023062一、实验内容(1)死锁的避免编写一个程序，实现银行家算法，当系统将资源分配给某一进程而不会死锁时，就分配之。

否则，推迟分配，并显示适当的信息。

(2)死锁的检测分别使用检测“进程—资源循环等待链”的方法和Coffman 的算法来检测进程的死锁状态。

对于相同的进程资源分配、占用次序，比较两个算法的结果。

二、实验目的通过本实验使学生进一步理解死锁的概念，并能选择一个算法来避免死锁，让学生进一步加深理解和掌握死锁的检测算法三、实验题目题目：死锁的避免和死锁的检测。

①数据结构struct Bank{int Available[m];//可利用资源向量int Max[m][n];//最大需求矩阵int Allocation[m][n];//分配矩阵int Need[m][n]; //需求矩阵};②程序总体框图四、源程序#include<iostream>using namespace std;#define m 5 //进程数#define n 3 //资源种类数struct Bank{int Available[m]; //可利用资源向量int Max[m][n]; //最大需求矩阵int Allocation[m][n]; //分配矩阵int Need[m][n]; //需求矩阵}void Initilize(Bank &); //初始化int SafeTest(Bank); //检查安全性void ResoureAllocate(Bank &); //系统对进程资源申请的处理void main(){cout<<"当前系统中存在"<<m<<"个进程"<<n<<"种资源"<<endl;Bank current; //定义变量int flag=1,temp;Initilize(current); //初始化SafeTest(current); //检查安全性while(flag) //循环执行进程申请资源和系统对申请的处理{cout<<"要退出吗？（0=退出，1=继续）"<<endl;cin>>temp;flag=temp;if(flag==1){ResoureAllocate(current);}}}void Initilize(Bank &bank){int i,j;cout<<"输入各进程的相关信息\n";cout<<"请输入进程的最大需求矩阵Max："<<'\n';for(i=0;i<m;i++) //设置最大需求矩阵for(j=0;j<n;j++){ cin>>bank.Max[i][j];}cout<<"请输入分配矩阵Allocation："<<endl;for(i=0;i<m;i++) //设置分配矩阵for(j=0;j<n;j++){ cin>>bank.Allocation[i][j];}for(i=0;i<m;i++) //设置需求矩阵for(j=0;j<n;j++){ bank.Need[i][j]=bank.Max[i][j]-bank.Allocation[i][j];} cout<<"请输入系统当前可利用资源向量："<<'\n';for(i=0;i<n;i++) //设置可利用资源向量cin>>bank.Allocation[i];}int SafeTest(Bank bank){int i,j;int safePCB[m]; //安全序列向量int work[n]; //空闲资源矩阵int Finish[m]; //进程完成标志矩阵for(i=0;i<m;i++)work[i]=bank.Allocation[i];for(i=0;i<m;i++)Finish[i]=false;int k=0;for(i=0;i<m;i++){if(Finish[i]==false){for(j=0;j<n;j++){if(bank.Need[i][j]>work[j])break;}if(j==n){safePCB[k++]=i;for(int q=0;q<n;q++)work[q]+=bank.Allocation[i][q];Finish[i]=ture;i=-1;}}}for(i=0;i<m;i++)if(!Finish[i]){ cout<<"找不到安全序列，系统处于不安全状态！\n";return 0;}cout<<"存在安全序列：";for(i=0;i<m;i++)cout<<"P"<<safePCB[i]+1<<"";cout<<"\n系统处于安全状态";return 1;void ResoureAllocate(Bank &bank){Bank temp=bank;int Request[n];int PCBNum;int i;cout<<"请输入要申请资源的进程序号（1~5）：\n";cin>>PCBNum;cout<<"请输入请求向量：\n";for(i=0;i<n;i++)cin>>Request[i];for(i=0;i<n;i++){if(Request[i]>bank.Need[PCBNum-1][i]){cout<<"进程所需要的资源数已超过它所宣布的最大值，系统不予分派资源！\n";return ;}if(Request[i]>bank.Available[i]){cout<<"系统中无足够的资源满足进程的申请，系统不予分配资源！\n";return ;}}for(i=0;i<n;i++){bank.Available[i]-=Request[i];bank.Need[PCBNum-1][i]-=Request[i];bank.Allocation[PCBNum-1][i]+=Request[i];}if(SafeTest(bank)){cout<<"系统可以为该进程分配资源\n";return ;}else{cout<<"系统不为该进程分配资源\n";bank=temp;return ;}六、实验总结银行家算法是一个经典的避免死锁的算法，它可以有效的避免资源分配时产生死锁。

实验六银行家算法避免死锁一.实验目的1、加深对死锁概念的理解2、能够利用银行家算法有效地避免死锁的发生、或检测死锁的存在二.实验内容及步骤本实验在winTC环境下实现，winTC安装程序在ftp上，请自行安装。

1.利用银行家算法写一个程序，判定系统的安全性。

已知某系统有5个进程P0，P1，P2，P3，P4，三类资源A、B、C。

死锁检测程序工作时0)。

#define m 3#define n 5main(){int test(int av[],int ned[],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]);//输入各个进程需要的资源j=0;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&&finish[i];//判断各个进程是否在安全性算法内全部通过if(g)printf(“safe state”);elseprintf(“not safe state”);}三．实验讨论谈谈你今天上实验课的收获，存在的问题或疑问。

如果有实验内容以外的发现也可谈谈。

实验三银行家算法一、实验内容简要描述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个条件：●互斥条件，即一个资源每次只能由一个进程占用。

●请求与保持条件，即一进程请求资源不能满足时，它必须等待，同时它仍保持已得到的所有其它资源。

●不可剥夺条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源。

●环路等待条件，系统进入死锁的状态时，进程和资源之间形成一个封闭的环路。

⑵银行家算法是一种具有代表性的避免死锁的算法。

银行家算法为资源分配定义了两种状态，安全状态和不安全状态。

●安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。

处于安全状态的系统一定没有死锁发生。

●不安全状态：当系统中不存在一个安全序列时系统处于不安全状态。

不安全状态下一定导致死锁发生。

五、实验过程记录1.流程图安全算法流程图银行家算法2.实验结果图1图2图3图43.结果分析1.对于图1来说因为P0 申请的资源大于他所需求的，所以认为此次分配出错2.对于图2来说因为P0申请的资源大于剩余的资源，所以此次分配出错3对于图3来说对于系统安全且能分配序列的t0安全时刻表资源情况进程max Need allocation Work+allocationfinishQ W QWQ W Q WP0 4 5 1 2 3 3 4 11 true P1 3 6 1 2 2 4 6 15 true P2 5 7 1 2 4 5 10 20 trueP0申请资源是的安全性检查资源情况进程work need allocation Work+allocation finish Q W Q W Q W Q WP0 0 7 0 1 4 4 4 11 truep1 4 11 1 2 2 4 6 15 True P2 6 15 1 2 4 5 10 20 TRUE4.对于图4来说因为最大需求大于可利用资源所以系统不安全五、成绩评定优良中及格不及格出勤内容格式分析总评指导教师：年月日源代码#include <iostream>using namespace std;#define False 0#define True 1int Max[100][100]={0};int Allocation[100][100]={0};int Need[100][100]={0};int Available[100]={0};int Work[100]={0};char name[100]={0};int temp[100]={0};int S=100,P=100;int safequeue[100]={0};int Request[100]={0};//void Showdata(){int i,j,k,l;cout<<"\t资源分配情况\n"<<endl;cout<<"\tMax"<<"\t已分配"<<"\tNeed"<<endl;cout<<"\t";for(j=0;j<3;j++){for (i=0;i<S;i++){cout<<name[i]<<" ";}cout<<"\t";}cout<<endl;for(i=0;i<P;i++){cout<<i<<"\t";for (j=0;j<S;j++){cout<<Max[i][j]<<" ";}cout<<"\t";for (k=0;k<S;k++){cout<<Allocation[i][k]<<" ";}cout<<"\t";for (l=0;l<S;l++){cout<<Need[i][l]<<" ";}cout<<endl;}cout<<"\nAvailable"<<endl;for (i=0;i<S;i++){cout<<name[i]<<" ";}cout<<endl;for (i=0;i<S;i++){cout<<Available[i]<<" ";}cout<<endl;}int Judgesafe(){int tempwork[100][100]={0};int i,x,k=0,m,apply,Finish[100]={0};int j;int flag=0;for (i=0;i<S;i++){Work[i]=Available[i];}for(i=0;i<P;i++){apply=0;for(j=0;j<S;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==S){for(m=0;m<S;m++){tempwork[i][m]=Work[m];Work[m]=Work[m]+Allocation[i][m];}Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<P;i++)if(Finish[i]==False){cout<<"系统不安全"<<endl;return -1;}}cout<<"系统是安全的"<<endl;cout<<"分配的序列:";for(i=0;i<P;i++){cout<<temp[i];if(i<P-1) cout<<"->";}cout<<endl;return 0;}void Changedata(int flag){for (int i=0;i<S;i++){Available[i]=Available[i]-Request[i];Allocation[flag][i]=Allocation[flag][i]+Request[i];Need[flag][i]=Need[flag][i]-Request[i];}//void Share(){int i,flag;char ch='Y';cout<<"输入请求资源的进程："<<endl;cin>>flag;if (flag>=P){cout<<"此进程不存在!"<<endl;}else{cout<<"输入此进程对各个资源的请求数量："<<endl;for (i=0;i<S;i++){cin>>Request[i];}for (i=0;i<S;i++){if (Request[i]>Need[flag][i]){cout<<"进程"<<flag<<"申请的资源大于它所需要的资源!"<<endl;cout<<"分配不合理不予分配!"<<endl;ch='N';break;}else if (Request[i]>Available[i]){cout<<"进程"<<flag<<"申请的资源大于可利用的资源。

计算机操作系统实验报告题目利用银行家算法避免死锁一、实验目的：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。