模拟实现银行家算法

操作系统课程设计（银行家算法的模拟实现）一、设计目的1、进一步了解进程的并发执行。

2、加强对进程死锁的理解。

3、用银行家算法完成死锁检测。

二、设计内容给出进程需求矩阵C、资源向量R以及一个进程的申请序列。

使用进程启动拒绝和资源分配拒绝（银行家算法）模拟该进程组的执行情况。

三、设计要求1、初始状态没有进程启动。

2、计算每次进程申请是否分配，如：计算出预分配后的状态情况（安全状态、不安全状态），如果是安全状态，输出安全序列。

3、每次进程申请被允许后，输出资源分配矩阵A和可用资源向量V。

4、每次申请情况应可单步查看，如：输入一个空格，继续下个申请。

四、算法原理1、银行家算法中的数据结构(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。

（4）、需求矩阵Need。

这也是一个n*m的矩阵，用以表示每个进程尚需要的各类资源数。

如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。

上述三个矩阵间存在以下关系：Need[i,j]=Max[i,j]-Allocation[i,j]2、银行家算法应用模拟实现Dijkstra的银行家算法以避免死锁的出现，分两部分组成：一是银行家算法（扫描）；二是安全性算法。

（1）银行家算法（扫描）设Requesti是进程Pi的请求向量，如果Requesti[j]=K，表示进程Pi需要K个Ri类型的资源。

银行家算法模拟实验四银行家算法模拟【开发语言及实现平台或实验环境】C++/C#Microsoft Visual Studio 6.0/ Microsoft Visual Studio .NET 2019【实验目的】（1）进一步理解利用银行家算法避免死锁的问题；（2）在了解和掌握银行家算法。

（3）理解和掌握安全序列、安全性算法【实验内容】（1）编写安全性算法；（2）编写银行家算法，并编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

【实验原理】一、安全状态指系统能按照某种顺序如(称为序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。

二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。

系统按下述步骤进行安全检查：（1）如果Requesti≤Needi则继续以下检查，否则显示需求申请超出最大需求值的错误。

（2）如果Requesti≤Available则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。

（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：Available［j］∶=Available［j］-Requesti[j］;Allocation［i,j］∶=Allocation［i,j］+Requesti［j］;Need［i,j］∶=Need［i,j］-Requesti［j］;（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

三、安全性算法（1）设置两个向量：①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。

实验报告附录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. 实验内容设Request[i]是进程Pi的请求向量(1)如果Request[i][j]<=Need[i][j],转向步骤(2);否则认为出错，因为它所需的资源已超过它所宣布的最大值。

(2)如果Request[i][j]<=Available[j],转向步骤（3）；否则，表示尚无足够资源，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]- Request[i][j];(4)系统执行安全性算法，检测本次资源分配后系统是否处于安全状态。

若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，回复原来的资源分配状态，让Pi等待。

安全性算法描述如下：(1)设置两个向量：①工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全性算法开始时，Work：= Available[j]。

②Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。

开始时先做Finish[i]:=false;当有足够资源分配给进程时，再令Finish[i]:=true。

(2)从进程集合中找到一个能满足下述条件的进程：①Finish[i]:=false;；②Need[i][j]<=Work[j];若找到，执行步骤（3），否则，执行步骤（4）。

(3)当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work[j]:= Work[j]+ Allocation[i][j];Finish[i]:=true;go to step 2;(5)如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

《银行家算法的模拟实现》 --实验报告题目: 银行家算法的模拟实现专业:班级:组员:指导老师:一、实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。

本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。

二、实验内容模拟实现银行家算法实现死锁避免。

要求：初始数据（如系统在T0时刻的资源分配情况、每一种资源的总数量）从文本文件读入，文件中给出最大需求矩阵Max、分配矩阵Allocation，在程序中求得需求矩阵Need和可利用资源向量Available。

三、实验分析过程1、整个银行家算法的思路。

先对用户提出的请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查。

1)进程一开始向系统提出最大需求量.?2)进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.?3)若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的?剩余资源量,若不超出,则分配,否则等待2、算法用到的主要数据结构和C语言说明。

（1）、可利用资源向量 INT AVAILABLE[M] M为资源的类型。

（2）、最大需求矩阵 INT MAX[N][M] N为进程的数量。

（3）、已分配矩阵 INT ALLOCATION[N][M]（4）、还需求矩阵 INT NEED[N][N]（5）、申请各类资源数量int Request[x]; ."<<endl;cout<<"|-------|------------|-----------|----------|-----------|"<<endl;cout<<"|-------|最大需求矩阵|已分配矩阵-|-需求矩阵-|可利用资源-|"<<endl;cout<<"| 资源 | Max | Allocation| Need | available |"<<endl;cout<<"| | A B C | A B C | A B C | A B C |"<<endl;cout<<"|进程 | | | | |"<<endl;cout<<"|-------|------------|-----------|----------|-----------|"<<endl;for(i=0;i<5;i++){cout<<"| p"<<i<<" | ";for(j=0;j<3;j++) {cout<<max[i][j]<<" "; }cout<<" | ";for(j=0;j<3;j++) {cout<<" "<<allocation[i][j]; }cout<<" | ";for(j=0;j<3;j++) {cout<<" "<<need[i][j]; }cout<<" |";if(i==0) {for(j=0;j<3;j++) {cout<<" "<<available[j]; }cout<<" |"; }if(i>0){cout<<" |"; }cout<<endl; }cout<<"|-------|------------|-----------|----------|-----------|"<<endl; }/*--------试分配函数-------*/void tryfenpei(int i){for(int f=0;f<c;f++){available[f]=available[f]-request[f];allocation[i][f]=allocation[i][f]+request[f];need[i][f]=need[i][f]-request[f];}}/*--------恢复数据函数-------*/void refenpei(int i){for(int f=0;f<c;f++){available[f]=available[f]+request[f];allocation[i][f]=allocation[i][f]-request[f];need[i][f]=need[i][f]+request[f];}}int com(int *p,int *q){int i;for(i=0;i<c;i++)if(p[i]>q[i])return 0;return 1;}/*--------安全检测函数---------*/void checksafe(int s)int flag,temp[t],i,j,l,k=0;bool finish[t];for(i=0;i<t;i++)finish[i]=false;for(j=0;j<c;j++)work[j]=available[j];cout<<"|-------|-----------------|----------|"<<endl;cout<<"| resource |-Work+Allocation-|--Finish--|"<<endl;cout<<"| | A B C | T/F |"<<endl;cout<<"|programme | | |"<<endl;cout<<"|-------|-----------------|----------|"<<endl;for(i=0;i<t;i++){l=0;for(j=0;j<c;j++){if(need[i][j]>work[j])l=1;break;}if(finish[i]==false&&l==0){cout<<"| p"<<i<<" | ";for(j=0;j<c;j++){work[j]=work[j]+allocation[i][j];if(work[j]>9)cout<<" "<<work[j]<<" ";elsecout<<" "<<work[j]<<" ";}cout<<" ";cout<<"|";cout<<" ";finish[i]=true;cout<<"true ";cout<<"|";temp[k]=i;."<<endl;refenpei(in);cout<<"恢复数据成功!正在打印输出..."<<endl;print();}elsecout<<"找到一个安全系列：";for(i=0;i<t;i++)cout<<"P"<<temp[i]<<"--->";cout<<endl<<"已通过安全性测试!"<<endl<<endl<<endl;cout<<"开始给第"<<"p]"<<in<<"]"<<"进程分配资源..."<<endl;cout<<"分配完成!打印输出..."<<endl<<endl;print();cout<<endl;}}}五、程序运行结果及分析1、运行结果输入初值，进行安全性测试，结果安全序列，依次为P4-P0-P1-P2-P3分配资源：资源不足，无法继续实验：2、出现问题及解决方案本程序考虑了程序功能实现、格式显示合理化、输入错误异常处理等各个方面的设计，尽可能使程序设计的更加完美。

OS模拟银行家算法分享一下最近的劳动成果，事无巨细，勿以细小而不为。

1：作业流程1.1 阅读算法，得出问题的求解方法；1.2 作程序流程图；1.3 构造所需的数据模型；1.4 开始敲代码啦，伴随着漫长的纠错排错调试过程，当error:100变成error:0的时候会很爽；1.5 功能基本实现了，可以再完善一下，美化一下界面；1.6 测试程序：回归测试，黑盒测试各种测试，代码写得好，测试要求就可以相对严格一些；1.7 通过测试一般就算完成作业了，其实还可以写一些相关的文档。

在Readme中写一些开发总结，用户帮助，修复bug和改进方案等信息。

2：银行家算法程序实现流程图：3：bankers_ALG.cpp CODE:--------------------------------------------------------------------------------------------------------------------------------------------------#include<iostream>using namespace std;int *one_array_malloc(int n); //一维数组分配int **two_array_malloc(int n,int m); //二维数组分配int compare21(int b,int m,int **Li,int *Bi);//向量比较函数=0->Li<=Bi Li是二维数组int compare11(int b,int m,int *Li,int *Bi);//向量比较函数=0->Li<=Bi Li是一维数组int compare12(int b,int m,int *Li,int **Bi);//向量比较函数=0->Li<=Bi Li是一维数组void print(int n,int m,int **Max,int **Allocation,int **Need,int *Available);//输出函数void print_space(int n);//输出n个空格函数int security_check(int n,int m,int *xl,int *work,int **Allocation,int **Need,int *Available);//安全性检查函数void allocation(int b,int m,int *Request,int *Available_temp,int **Allocation_temp,int **Need_temp);//试分配void copy1(int n,int *s1,int *s2);//转储函数s2->s1 一维数组void copy2(int n,int m,int **s1,int **s2);//转储函数s2->s1 二维数组int in(int n,int i,int *xl);//判断进程是否在安全序列中void main(){int n,m,i,j;int *Available,*xl; int **Max;int **Allocation;int **Need;FILE *fp;if((fp=fopen("input53.txt","r"))==NULL){printf("cannot open this file!\n");return;}fscanf(fp,"%d%d",&n,&m);Available=one_array_malloc(m);xl=one_array_malloc(n);Max=two_array_malloc(n,m);Allocation=two_array_malloc(n,m);Need=two_array_malloc(n,m);for(i=0;i<m;i++){fscanf(fp,"%d",&Available[i]);}for(i=0;i<n;i++)for(j=0;j<m;j++){fscanf(fp,"%d",&Max[i][j]);}for(i=0;i<n;i++)for(j=0;j<m;j++){fscanf(fp,"%d",&Allocation[i][j]);Need[i][j]=Max[i][j]-Allocation[i][j];}fclose(fp);print(n,m,Max,Allocation,Need,Available);int *work,*Request;int *Available_temp,**Allocation_temp,**Need_temp;int jc,p; work=one_array_malloc(n);Available_temp=one_array_malloc(m);Allocation_temp=two_array_malloc(n,m);Need_temp=two_array_malloc(n,m);copy1(m,Available_temp,Available);copy2(n,m,Allocation_temp,Allocation);copy2(n,m,Need_temp,Need);Request=one_array_malloc(n);if(security_check(n,m,xl,work,Allocation,Need,Available)==0)cout<<"载入数据正确,系统处于安全状态。

操作系统实验系别计算机科学与技术专业网络工程班级07级2班题目银行家算法模拟姓名张昆学号E30714012【实验目的】（1）进一步理解利用银行家算法避免死锁的问题；（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

（3）理解和掌握安全序列、安全性算法 【实验步骤】（1）参考图1-1所示流程图编写安全性算法。

（2）编写统一的输出格式。

每次提出申请之后输出申请成功与否的结果。

如果成功还需要输出变化前后的各种数据，并且输出安全序列。

（3）参考图1-2所示流程图编写银行家算法。

（4【源程序】#include<stdio.h>#define M 5 /*进程数*/#define N 3 /*资源种类*/#include<stdlib.h>int safe(int available[N],int allocation[M][N],int need[M][N])/*安全性算法*/{int work[N],finish[M],p[M];/*p数组时用来记录安全序列的*/int i,j,k,l=0，flag=0;for(j=0;j<N;j++)work[j]=available[j];for(i=0;i<M;i++){finish[i]=0;p[i]=0;}for(i=0;i<M;i++){if(finish[i]==0){ flag++;k=1;/*k为1表示该进程满足need[i][j]<=work[j]*/for(j=0;j<N;j++)if(need[i][j]>work[j]){k=0;break;}if(k==1){for(j=0;j<N;j++)work[j]=work[j]+allocation[i][j];finish[i]=1;p[l++]=i;}//检查该进程满足need[i][j]<=work[j]if(i==4){if(l&&flag<5)i=-1;else {printf("系统处于不安全状态！\n") ;return 0;}}}//if(finish[i]==0)}//循环扫描数组寻找安全序列k=1;/*k为1表示所有finish元素都为1(true)*/for(i=0;i<M;i++){if(finish[i]==0)k=0;break;}//判断是否存在安全序列if(k==1){printf("系统处于安全状态!安全序列为：");for(i=0;i<M;i++)printf("%2d",p[i]);printf("\n");return 1;}//若存在安全序列则输出，并返回1else {printf("系统处于不安全状态！\n");printf("\n");return 0;}}/*safe*/void input_data(int available[N],int allocation[M][N],int max[M][N],int need[M][N]) {int i,j;printf("输入系统可分配的各类资源数：\n");for(i=0;i<N;i++){printf("第%d类资源的数量：",i);scanf("%d",&available[i]);}//输入系统可分配的各类资源数printf("输入各进程的最大的资源需求量已分配的资源数：\n");for(i=0;i<M;i++){printf("第%d个进程：\n",i);for(j=0;j<N;j++){ printf("第%d类资源最大需求量:",j);scanf("%d",&max[i][j]);printf("第%d类资源已分配数量",j);scanf("%d",&allocation[i][j]);}}//输入各进程的最大的资源需求量和已分配的资源数for(i=0;i<M;i++)for(j=0;j<N;j++)need[i][j]=max[i][j]-allocation[i][j];}//输入初始化参数void banker(int available[N],int allocation[M][N],int max[M][N],int need[M][N],int count,int request[N]){int i,j,k;k=1;for(i=0;i<N;i++)if(need[count][i]<request[i]){k=0;break;}if(k==0){printf("出错啦！\n");return;}//判断该进程的请求量是否小于它的需求量k=1;for(i=0;i<N;i++)if(available[i]<request[i]){k=0;break;}if(k==0){printf("进程阻塞！\n");return;}//判断该进程的请求量是否小于系统可分配的资源数，若小于，进程阻塞for(j=0;j<N;j++){available[j]=available[j]-request[j];//系统可分配资源数减去请求的资源数allocation[count][j]=allocation[count][j]+request[j];//进程已分配资源数加上请求量need[count][j]=need[count][j]-request[j];//进程需求资源数减去请求量}//假定可为该进程分配资源，修改相应值if(safe(available,allocation,need)){printf("分配成功！\n");printf(" 进程资源最大需求量/已分配数量/还需要分配数量\n");printf(" ");for(i=0;i<N;i++)printf("第%d类资源",i);printf("\n");printf("当前系统可分配的各类资源数：");for(i=0;i<N;i++)printf("%5d ",available[i]);printf("\n");for(i=0;i<M;i++){printf("第%d个进程：",i);for(j=0;j<N;j++){printf("%2d",max[i][j]);printf("%2d",allocation[i][j]);printf("%2d ",need[i][j]);}printf("\n");}}//安全,输出分配资源后各数据的值else{printf("分配失败！\n");for(j=0;j<N;j++){available[j]=available[j]+request[j];allocation[count][j]=allocation[count][j]-request[j];need[count][j]=need[count][j]+request[j];}//分配失败，否则还原数值}//进行安全性检查，若安全则输出分配资源后各数据的值，否则还原数值return;}//银行家算法void main(){int i,count,available[N],allocation[M][N],max[M][N],need[M][N],request[N];/*定义可利用资源available，最大需求矩阵max，已分配矩阵allocation，需求矩阵need，请求资源request*/char c;input_data(available,allocation,max,need);//输入初始化矩阵if(safe(available,allocation,need)==0)return;//初始时刻安全性检查printf("现在进行银行家算法模拟吗？\nY/N");c=getchar();c=getchar();while(c=='Y'||c=='y'){printf("第几个进程请求资源？");scanf("%d",&count);printf("输入该进程各类资源的请求量：\n");for(i=0;i<N;i++){ printf("第%d类资源请求量:",i);scanf("%d",&request[i]);}//输入某进程的请求资源量banker(available,allocation,max,need,count,request);//调用银行家算法printf("继续进行银行家算法模拟吗？\nY/N");c=getchar();c=getchar();}//循环调用银行家算法}【实验结果】。

实验六编程模拟实现银行家算法（综合性编程实验4学时）一. 目的要求通过对银行家算法的模拟，了解死锁概念、死锁的本质以及掌握解决死锁的方法。

二．实验任务编程模拟银行家算法中的安全性算法，系统当前状态（最大资源需求、进程已占有的资源、进程还需要的资源）以某种形式输入，程序输出是否安全和不安全的结果。

三．实验环境、设备硬件：586以上的PC系列机，主频大于166M，内存大于16MB，硬盘空闲空间大于500MB。

软件：选择一个自己熟悉的计算机操作系统（如DOS、Windows98／2000／XP、UNIX、linux等，根据各学校的条件与环境而定）和程序设计语言（如Turbo C、C语言、PASCAL语言等）。

编程语言由各位同学自己选择确定，不做统一规定。

四.实验指导模拟银行家算法中的安全性算法，系统当前状态（最大资源需求。

进程已占有的资源、进程还需要的资源）以某种形式输入，程序输出是否安全和不安全的结果。

为简单以见，以教材中的例子做为输入，实现安全性算法。

1．主要数据结构①可用资源数组work，它的长度为资源类型数2，如果work [1]= k表示当前状态下B种资源的可用个数为k个。

例：work[1]=3，表示B类资源当前空闲3台。

②分配矩阵allo(alloction)，它是一个[5,2]的矩阵，allo [3,1］= k表示第4个进程已分配k个B类型的资源数.③剩余需求矩阵need，它是一个[5,2]的矩阵，need［3，1］=k表示第4个进程还需要k个B类型的资源数.④系统拥有资源向量max，它的长度为资源类型数2，如果max [1]= k，表示系统中拥有B种资源数为k个.⑤安全状态标示数组finish，他的长度为进程个数5，用它来表示当前状态下系统是否有足够资源分配给该进程。

2．程序说明该程序对于每一种资源进行安全检验，进行检验的算法详见《操作系统》，该程序没有实现每个进程在系统安全时进行动态的分配资源，而是在静态的条件下输入系统的状态，和每个进程拥有.资源的状态，来判断系统是否安全.因此在程序中定义的request矩阵，没有起到作用.如要实规模拟动态的资源分配，在该程序的基础上稍加改动即可.五．实验源代码import java.util.*;public class os{public static void main(String args[]){int max[][]={{7,5},{3,2},{9,0},{2,2},{4,3}};int allo[][]={{0,1},{2,0},{3,0},{2,1},{0,0}};int need[][]={{7,4},{1,2},{6,0},{0,1},{4,3}};int work[]={3,3};boolean finish[]={false,false,false,false,false};int count=5;int i;while(count>0){for( i=0;i<5;i++){if(finish[i]==false&&need[i][0]<=work[0]&&need[i][1]<=work[1]){work[0]+=allo[i][0];work[1]+=allo[i][1];finish[i]=true;count--;break;}}}if(count==0)System.out.println("系统安全！");elseSystem.out.println("系统不安全!");} }。

操作系统课程设计报告专业计算机科学与技术学生姓名班级计算机科学与技术学号指导教师完成日期2014.3.20题目：银行家算法的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。

二、设计内容1）概述用C或C++语言编制银行家算法通用程序，并检测所给状态的系统安全性。

1.算法介绍：数据结构：1）可利用资源向量 Available；2）最大需求矩阵Max；3）分配矩阵Allocation；4）需求矩阵Need2.功能介绍模拟实现Dijkstra的银行家算法以避免死锁的出现，分两部分组成：第一部分：银行家算法（扫描）；第二部分：安全性算法。

2）设计原理一．银行家算法的基本概念1、死锁概念。

在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险━━死锁。

所谓死锁(Deadlock),是指多个进程在运行中因争夺资源而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。

2、关于死锁的一些结论：参与死锁的进程最少是两个（两个以上进程才会出现死锁）参与死锁的进程至少有两个已经占有资源参与死锁的所有进程都在等待资源参与死锁的进程是当前系统中所有进程的子集注：如果死锁发生，会浪费大量系统资源，甚至导致系统崩溃。

3、资源分类。

永久性资源：可以被多个进程多次使用（可再用资源）可抢占资源不可抢占资源临时性资源：只可使用一次的资源；如信号量,中断信号，同步信号等（可消耗性资源）“申请--分配--使用--释放”模式4、产生死锁的四个必要条件：互斥使用（资源独占）、不可强占（不可剥夺）、请求和保持（部分分配，占有申请）、循环等待。