计算机操作系统【银行家算法】

实验二 银行家算法

一、实验目的
运用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地避免死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验内容
完成银行家算法的模拟实现：设计有m个进程共享n个系统资源的系统，进程可动态的申请和释放资源。系统按各进程的申请动态的分配资源时，采用银行家算法有效地避免死锁的发生。
三、实验准备
1.相关理论知识
（1）银行家算法的思路
对进程的资源请求进行合法性检查；若请求合法，则进行试分配。试分配后，调用安全性检查算法进行安全性检查。若安全，则满足该进程请求，分配资源；若不安全，则拒绝该进程申请，不分配资源，并恢复系统试分配前的资源状态。
（2）银行家算法中用到的主要数据结构
可利用资源向量 int Available[j] // j为资源的种类。
最大需求矩阵 int Max[i][j] // i为进程的数量。
分配矩阵 int Allocation[i][j]
需求矩阵 int Need[i][j]= Max[i][j]- Allocation[i][j]
申请各类资源数量 int Requesti[j] //i进程申请j资源的数量
工作向量 int Work[x] int Finish[y]
（3）银行家算法Bank()
进程i发出请求申请k个j资源，Requesti[j]=k
① 检查申请量是否不大于需求量：
Request i[j]<=Need[i,j],若条件不符重新输入，不允许申请大于需求量。
② 检查申请量是否小于系统中的可利用资源数量：
Request i[j]<=Available[j]，若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源。
③ 若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：
Available[j]= Available[j]- Requesti[j]；
Allocation[i][j]= Allocation[i][j]+ Requesti[j]；
Need[i][j]= Need[i][j]- Request i[j]；
④ 试分配后，执行安全性检查，调用Safe()函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
⑤ 用while循环实现输入字符Y/y判断是否继续请求资源分配。
（4）安全性检查算法（Safe()函数）
① 设置两个向量：
工作向量Work：表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work= Available。
Finish：表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=false；当有足够的资源分配给进程时，再令Finish[i]=true。
② 在进程中查找符合以下条件的进程：
条件1：Finish[i]=0；
条件2：Need[i][j]<=Work[j]
若找到，则执行步骤③否则，执行步骤④
③ 当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]= Work[j]+ Allocation[i][j]；
Finish[i]=true；
跳至 ②；
④ 若所有进程的Finish[i]=true都满足，则表示已找到安全序列，系统处于安全状态，试分配成功；否则，系统处于不安全状态，不予分配。
2.测试数据
系统有5个进程（p0,p1,p2,p3,p4）和4类资源（A，B，C，D），在T0时刻的资源分配情况如下表所示：
Process Max Allocation Need Available
P0 0 0 4 4 0 0 3 2 0 0 1 2 1 6 2 2
P1 2 7 5 0 1 0 0 0 1 7 5 0
P2 3 6 10 10 1 3 5 4 2 3 5 6
P3 0 9 8 4 0 3 3 2 0 6 5 2
P4 0 6 6 10 0 0 1 4 0 6 5 6
试问：（1）该状态是否安全？–该状态是安全的。
（2）如果进程P2提出请求Request2（1，2，2，2）后，系统能否将资源分配给它？–不能。
四、实验过程
1.流程图

2. 源代码
   #include
   using namespace std;
   #define MAXPROCESS 50 /最大进程数/
   #define MAXRESOURCE 100 /最大资源数/
   int AVAILABLE[MAXRESOURCE]; /可用资源数组/
   int MAX[MAXPROCESS][MAXRESOURCE]; /最大需求矩阵/
   int ALLOCATION[MAXPROCESS][MAXRESOURCE]; /分配矩阵/
   int NEED[MAXPROCESS][MAXRESOURCE]; /需求矩阵/
   int REQUEST[MAXPROCESS][MAXRESOURCE]; /进程需要资源数/
   bool FINISH[MAXPROCESS]; /系统是否有足够的资源分配/
   int p[MAXPROCESS]; /记录序列/
   int m,n; /m个进程,n个资源/
   void Init();
   bool Safe();
   void Bank();
   int main()
   {
   a: Init();
   if(!Safe()) goto a;
   Bank();
   return 0;
   }
   //银行家算法和安全性算法区别
   //100页当进程发出资源的请求时采用银行家算法，当 判断系统能否给每一个进程分配资源时采用安全性算法
   void Init() /初始化/
   {
   int i,j;
   cout<<“…银行家算法模拟实验…”< cout<<“请输入进程数目m:”;
   cin>>m;
   cout <<“请输入进程的种类n:”;
   cin>>n;
   cout<<“请输入每个进程对资源数的最大需求，按照”< for(i=0;i for(j=0;j cin>>MAX[i][j];
   cout<<“输入每个进程已分配的资源数，同样按照”< for(i=0;i {
   for(j=0;j {
   cin>>ALLOCATION[i][j];
   //请写出NEED[i][j]的计算公式!!!
   NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];
   if(NEED[i][j]<0)
   {
   cout<<“进程”< j–;
   continue;
   }
   }
   }
   cout<<“请输入各个资源现有的数目：”< for(i=0;i {
   cin>>AVAILABLE[i];
   }
   cout<<“…”< }
   void Bank() /银行家算法/
   {
   int i,r;
   char again;
   while(1)
   {
   cout<<“请输入要申请资源的进程号（注：第一个进程号为0，以此类推）”< cin>>r;
   cout<<“请输入进程所请求的各资源的数量”< for(i=0;i {
   cin>>REQUEST[r][i];
   }
   for(i=0;i {
   if(REQUEST[r][i]>NEED[r][i])
   {
   cout<<“您输入的请求数超过进程的需求量！请重新输入”< break;
   }
   if(REQUEST[r][i]>AVAILABLE[i])
   {
   cout<<“您输入的请求数超过进程的需求量！请重新输入”< break;
   }
   }
   if(i for(i=0;i {
   AVAILABLE[i]=AVAILABLE[i]-REQUEST[r][i];
   ALLOCATION[r][i]=ALLOCATION[r][i]+REQUEST[r][i];
   NEED[r][i]= NEED[r][i]-REQUEST[r][i];
   }
   if(Safe())//调用安全性算法：判定系统是否处于安全状态
   {
   cout<<“同意分配请求！”< }
   else
   {
   cout<<“您的请求被拒绝！”< for(i=0;i {
   AVAILABLE[i]+=REQUEST[r][i];
   ALLOCATION[r][i]=REQUEST[r][i];
   NEED[r][i]+=REQUEST[r][i];
   }
   }
   cout<<“您还想再次请求分配资源吗？是请按y/Y，否请按其他键”< cin>>again;
   if(again==‘y’||again==‘Y’)
   {
   continue;
   }
   break;
   }
   }
   bool Safe() /安全性算法/
   {
   int i,j,k,l=0;
   int Work[MAXRESOURCE];
   for(i=0;i Work[i]=AVAILABLE[i];
   for(i=0;j {
   FINISH[i]=false; //输入FINSH值
   }
   for(i=0;i {
   if(FINISH[i]true)
   {
   continue;
   }
   else
   {
   for(j=0;j {
   if(NEED[i][j]>Work[j])
   {
   break;
   }
   }
   if(jn)
   {
   FINISH[i]=true;
   for(k=0;k {
   Work[k]=Work[k] + ALLOCATION[i][k];//输入
   }
   p[l++]=i;
   i=-1;
   }
   else
   {
   continue;
   }
   }
   }
   if(l==m)
   {
   cout<<“系统是安全的”< cout<<“安全序列”< for(i=0;i {
   cout< if(i!=l-1)
   {
   cout<<“–>”;
   }
   }
   cout<<“”< return true;
   }
   else{
   cout<<“系统是不安全的”< }
   return false;}
3. 运行界面
   
   

五、实验心得
银行家算法就是当接收到一个系统资源的分配后找到一个安全序列，使得进程间不会发生死锁.，若发生死锁则让进程等待。
通过本次上机实验，我对银行家算法有了更深的了解。银行家算法可以保证系统中，所有进程都能在有限的时间内得到需要的全部资源。银行家算法是一种用来避免操作系统死锁出现的有效算法。