操作系统实验_银行家算法

教师签字 成绩

实验报告

【实验名称】 【实验目的】

掌握银行家算法，用银行家算法模拟操作系统防止死锁的方法

银行家算法

【实验原理】

银行家算法又称“资源分配拒绝〞法，其根本思想是，系统中的所有进程放入进程集合，在平安状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比拟，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。这时系统将该进程从进程集合中将其去除。此时系统中的资源就更多了。反复执行上面的步骤，最后检查进程的集合为空时就说明本次申请可行，系统处于平安状态，可以实施本次分配，否那么，只要进程集合非空，系统便处于不平安状态，本次不能分配给他。请进程等待

用C语言编写一个简单的银行家算法模拟程序，用银行家算法实现资源分配。程序能模拟多个进程共享多种资源的情形。进程可动态地申请资源，系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和平安序列；显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况

【数据构造和符号说明】

页脚下载后可删除，如有侵权请告知删除！

可利用资源向量Available 最大需求矩阵Max 分配矩阵Allocation 需求矩阵Need 工作向量Work 标记向量Finish

char name[100][10];//定义最大100个进程，每个大小为10 int Max[100][100]; //定义

int Allocation[100][100];//可利用资源向量资源数 int Need[100][100]; //需求矩阵

int avaiable[100]; //系统可利用资源 int avaiable1[100];

int state[100]; //进程状态数组 char name1[100][10];//进程名 int bigger; ;//是否大于 int N; //进程数 int n; //资源数 int counter;

函数：

void Input()//输入函数 void Init()//初始化

void output()//输出平安序列或等待 void insert_pcb()//请求进程或更新进程

void show()//显示界面与选择int CmpRequestAvailable(int Pos,int n)//比拟Request和Available的大小

int CmpRequestNeed(int Pos,int n)//比拟Request和Need的大小 void Reset(int n,int Pos)//更新request之后的Need，Allocation，Available的值void Banker()//银行家算法

【实验流程图及算法实现】

用C语言编写一个简单的银行家算法模拟程序，用银行家算法实现资源分配。程序能模拟多个进程共享多种资源的情形。进程可动态地申请资源，系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和平安序列；显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况

页脚下载后可删除，如有侵权请告知删除！

【流程图】

开始输入进程数目与资源个数输入现有的资源个数及各进程信息计算每个进程所需的资源数是进程状态释放与否否是否满足当前进程需求 否当前资源个数等于自身加上该进程所拥有进程数目，标记状态输出信息已扫描到最后一个进程是否转向下一个进程输出所有安全序列结束

页脚下载后可删除，如有侵权请告知删除！

代码：

#include using namespace std;

char name[100][10];定义最大100个进程，每个大小为10 int Max[100][100]; //定义

int Allocation[100][100];//可利用资源向量资源数 int Need[100][100]; //需求矩阵 int avaiable[100]; //

int state[100]; //进程状态数组 int dayu; ;是否大于 int N; int n;

void input () {

cout<<\"输入进程个数\"<>N;

cout<<\"输入资源个数\"<>n;

cout<<\"系统现有的各资源的个数\"<>avaiable[i]; for(int i=0; icout<<\"输入第\"<>name[i];

cout<<\"输入第\"<>Max[i][j];

cout<<\"输入第\"<cin>>Allocation[i][j]; state[i]=0; }

for(int i=0; ifor(int j=0; jNeed[i][j]=Max[i][j]-Allocation[i][j]; }

void yinhangjia() {

int i,j,k;

for( i=0; i页脚下载后可删除，如有侵权请告知删除！

for( j=0; jif(state[j]==1) continue; dayu=0;

for( k=0; kif(avaiable[k]>=Need[j][k]) dayu=1; else {

dayu=0; break; } }

if(dayu==1)//判断状态 {

state[j]=1;

cout<avaiable[m]+=Allocation[j][m]; break; } } } }

int main() {

input();//输入 yinhangjia(); }

截图：

页脚下载后可删除，如有侵权请告知删除！

页脚下载后可删除，如有侵权请告知删除！

带有resquest请求更新的银行家算法： 描述：

1〕如果Request[i] 是进程Pi的请求向量，如果Request[i，j]=K,表示进程Pi需要K个Rj类型的资源。当发出资源请求后，系统按下述步骤进展检查： 如果Requesti[j]<= Need[i,j]，便转向步骤2；否那么认为出错，因为它所需要的资源数已超过它所宣布的最大值。

2〕如果Requesti[j]<=Available[j],便转向步骤3，否那么，表示尚无足够资源，进程Pi须等待。

3〕系统试探着把资源分配给进程，并修改下面数据构造中的数值。

4〕系统执行平安性算法，检查此次资源分配后，系统是否处于平安状态。假设平安，才正式将资源分配给进i，以完本钱次分配；否那么，将本次的试探分配作废，恢复原来的资源分配状态，让进程等待。

页脚下载后可删除，如有侵权请告知删除！

流程图：

开始输出安全序列输入进程、资源数目，max、allocationAvailable矩阵进入银行家算法计算need矩阵初始化work、finish向量输入请求资源的信息Finish==false&Need<=work？否Resquest代码：

#include #include using namespace std;

char name[100][10];//定义最大100个进程，每个大小为10 int Max[100][100]; //定义

int Allocation[100][100];//可利用资源向量资源数

页脚下载后可删除，如有侵权请告知删除！

int Need[100][100]; //需求矩阵 int avaiable[100]; // int avaiable1[100];

int state[100]; //进程状态数组 char name1[100][10]; int bigger; ;//是否大于 int N; int n;

int counter;

void input ()//输入函数 {

cout<<\"输入进程个数\"<>N;

cout<<\"输入资源个数\"<>n;

cout<<\"系统现有的各资源的个数\"<cin>>avaiable[i];

avaiable1[i]=avaiable[i]; }

for(int i=0; icout<<\"输入第\"<>name[i];

cout<<\"输入第\"<>Max[i][j];

cout<<\"输入第\"<cin>>Allocation[i][j]; state[i]=0; }

for(int i=0; ifor(int j=0; jvoid Banker()//银行家算法 {

int i,j,k; counter=0;

页脚下载后可删除，如有侵权请告知删除！

for(i=0; ifor( i=0; ifor( j=0; jif(state[j]==1) continue; bigger=0;

for( k=0; kif(avaiable[k]>=Need[j][k])//每一个大于需求 bigger =1; else {

bigger=0;

break;//跳出需求循环 } }

if( bigger==1)//判断状态，此时该进程所有need<= avaiable {

state[j]=1;

strcpy(name1[counter++],name[j]);

for(k=0; kavaiable[k]+=Allocation[j][k];//更新avaiable向量 break; } } } }

void output()//输出平安序列或等待 {

int i;

if (counter==N) {

cout<<\"平安序列为:\"; for(i=0; icout<< name1[i]<<\"--> \"; cout<< name[i]<else cout<<\"不存在平安序列,插入失败\"<页脚下载后可删除，如有侵权请告知删除！

}

void insert_pcb()//请求进程或更新进程 {

char name1[10]; int choose; int add[100];

cout<<\"1、增加新的进程\"<cout<<\"2、对原有进程增加资源申请\"<>choose; if(choose==1) {

int bigger=0;

cout<<\"输入插入进程的名字\"<>name[N];

cout<<\"输入该进程拥有的资源个数\"<cin>>Allocation[N][j]; state[N]=0;

cout<<\"输入该所需要各资源最大数目\"<for(int j=0; jcin>>Max[N][j];

Need[N][j]=Max[N][j]-Allocation[N][j];

}

state[N]=0;

for( int k=0; kif(avaiable[k]>=Need[N][k])//每一个大于需求 bigger =1; else {

bigger=0;

break;//跳出需求循环 } }

if(bigger==1) {

cout<<\"插入成功\"<页脚下载后可删除，如有侵权请告知删除！

Banker(); output();

} else

cout<<\"插入失败，进程等待！\"<int pos;//找到需更新进程的位置 cout<<\"输入原有进程的名字\"<>name1[10]; for(int i=0; iif(!strcmp(name1,name[i])) {

pos=i; break; }

cout<<\"输入该进程还需要的各资源数\"<>add[j];

for( int k=0; kif(avaiable[k]>=add[k])//每一个大于需求 bigger =1; else {

bigger=0;

break;//跳出需求循环 } }

if(bigger==1) {

cout<<\"插入成功\"<Max[pos][m]+=add[m]; Need[pos][m]+=add[m]; avaiable[m]=avaiable1[m]; }

页脚下载后可删除，如有侵权请告知删除！

Banker(); output(); }

else cout<<\"插入失败，进程等待！\"<void show()//显示界面与选择 {

int i,j;

cout<cout<<\"max[\"<cout<cout<cout<<\"***************************************************\"<cout<<\"Allocation[\"<cout<cout<cout<<\"***************************************************\"<cout<<\" Need[\"<cout<页脚下载后可删除，如有侵权请告知删除！

for(j=0; jcout<< Need[i][j]<<\"\\\"; cout<cout<<\"***************************************************\"<int main() {

int select;

cout<<\"银行家算法\"<cout<<\"1、更新\"<cout<<\"2、查看各进程的信息\"<>select; if(select==3) break;

else if(select==1) insert_pcb(); else show(); }

while(1); }

截图：

输入资源种类数目，输入最大需求矩阵，输入分配矩阵，输入可用资源数目，得到平安序列

页脚下载后可删除，如有侵权请告知删除！

对进程P1进展请求，此时会形成一个新的平安序列,p1进程的need和max发生相应的变化。

页脚下载后可删除，如有侵权请告知删除！

继续修改良程4，插入各需求3 3 0，不存在平安序列，此时需要等待。

页脚下载后可删除，如有侵权请告知删除！

请求一个新进程，所需求的最大资源为3 3 4，现有为2 2 3，形成新的平安序列。

页脚下载后可删除，如有侵权请告知删除！

查看各进程信息，并输出平安序列。

再请求一个新的大进程，此时资源缺乏，需要等待。

资源数为4：

页脚下载后可删除，如有侵权请告知删除！

页脚下载后可删除，如有侵权请告知删除！

更新P1进程，程序阻塞，进程等待。

请求一个新进程，P5。插入成功，此时有平安序列。

页脚下载后可删除，如有侵权请告知删除！

【小结或讨论】

1、银行家算法名字源于该算法实际上是用于确保银行系统不会用尽系统资

源，因为当银行系统不再满足所有客户的需求，系统将不会分配钱〔看作资源〕给客户，银行必须确保对钱的请求不会导致银行系统处于不平安状态。如果上述情况不会发生，那么该情况下请求是被允许的，否那么，客户必须等到其他客户往银行存进足够银行分配的资金。

2、银行家算法就是当接收到一个系统资源的分配后找到一个平安序列，使得进程间不会发生死锁，假设发生死锁那么让进程等待。这次实验的核心问题在于试探分配，假设试探分配得到的结果是系统不平安那么分配作废，恢复原先资源分配状态，转而寻找其他可能的平安序列，只要找到一个平安序列即可完毕程序，请求向量也被认定是平安的。假设遍历了所有的可能序列都不平安，那么请求向量也就是不平安的。

页脚下载后可删除，如有侵权请告知删除！

2、银行家算法中有两处涉及到进程“等待〞，一处是当请求资源小于可利用资源的时候，还有一处是平安性算法判断出系统不平安的时候。在平安性检查的函数中调用银行家算法的函数需要注意初始化Work等向量。

3、银行家算法名字源于该算法实际上是用于确保银行系统不会用尽系统资源，因为当银行系统不再满足所有客户的需求，系统将不会分配钱〔看作资源〕给客户，银行必须确保对钱的请求不会导致银行系统处于不平安状态。如果上述情况不会发生，那么该情况下请求是被允许的，否那么，客户必须等到其他客户往银行存进足够银行分配的资金。

4、同其他的算法相似，银行家算法运行时也有一些局限。特别是，必须知道每个进程所能请求的资源。在大多数系统，该信息是不可知的，使的无法顺利运行银行家算法。而且也无法去假设进程数量是不变的，因为大多数的系统的进程数量是动态变化的。再者，对于正确的算法，进程会释放其全部的资源〔当进程完毕运行〕，然而对于实际中的系统那么是不可行。为了资源的释放等上数小时甚至几天，通常是不可承受的。

5、通过本次实验，我对于银行家算法有了一定的认识，了解了死锁产生的根本条件。对死锁的产生有了更加深刻的体会，同时掌握了解决死锁的银行家算法的根本思想。

【本文档内容可以自由复制内容或自由编辑修改内容期待你的好评和关注，我们将会做得更好】

页脚下载后可删除，如有侵权请告知删除！