银行家算法

• 项目实验目的和要求

银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。实验要求用高级语言编写一个银行家的模拟算法。通过本实验可以对预防死锁和银行家算法有更深刻的认识。

• 实验内容

编写一个银行家算法的模拟程序。

• 实验知识点说明

银行家算法是将操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。

规定：

(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客；

(2) 顾客可以分期贷款，但贷款的总数不能超过最大需求量；

(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款；

(4) 当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金.

操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。

• 实验分析

模拟银行家算法实现时要考虑设置基本的数据结构以及安全性算法：

1. 设置数据结构

包括可利用资源向量（Availiable）,最大需求矩阵（Max）,分配矩阵（Allocation）,需求矩阵（Need）。

1. 设计安全性算法

设置工作向量Work 表示系统可提供进程继续运行可利用资源数目，Finish 表示系统是否有足够的资源分配给进程。

1. 模拟银行家算法程序运行效果：

假定：此刻系统中存在的进程：P0  P1  P2  P3  P4 

此刻系统可利用资源（单位：个）： A  B  C

3  3  2

此刻各进程已占有资源如下（单位：个）:

    A  B  C

P0  0  1  0

P1  2  0  0

P2  3  0  2

P3  2  1  1

P4  0  0  2

各进程运行完毕需要各资源最大值如下（单位：个）:

    A  B  C

P0  7  5  3

P1  3  2  2

P2  9  0  2

P3  2  2  2

P4  4  3  3

（五）上机

1、将程序补充完整，调试运行。分别按以下要求输入数据，并将运行结果截图并分析。

①进程P3发出资源请求Request(0,1,0)；

②进程P0发出资源请求Request(4,3,1)；

③进程P1发出资源请求Request(1,2,2)；

④进程P4发出资源请求Request(2,3,1)；

⑤进程P2发出资源请求Request(3,1,0)；

2、修改程序，利用程序验证第七章习题6的（3），结果截图并分析。

3、在2基础上分别设计一个可以分配资源和无法分配资源的请求，并将两次运行结果截图并分析。

4、改进程序，可以由用户动态输入进程个数N、资源个数M，及 Available[M]、Max[N][M]、Allocation[N][M]的值。

//银行家算法

#include<stdio.h>

#include<conio.h>

#include <stdlib.h>

#define N 5  //表示有5个进程

#define M 3  //表示有3类资源

#define true 1

#define false 0

 /*判断所请求的各类资源是否满足所需要的资源数不超过所宣布的资源数：*/

void requestComToNeed(int Request[],int Need[][M],int i)

{

       int j;

       for(j=0;j<3;j++) //从第一个资源开始判断

 {

   if(_______________________)

        continue;//如果符合要求，就继续

       else 

   {

        printf("所需要的资源数已经超过它所宣布的的最大值!!\n"); //否则就输出错误

     exit(0);//退出程序

   }

  } 

}

 /*判断所请求的各类资源是否满足小于系统现有的各类资源的数目*/

void requestComToAvail(int Request[],int Available[])

{    

       int j;

       for(j=0;j<3;j++)//从第一个资源开始判断

 {

       if(_______________________)

              continue; //如果符合要求就继续

       else

       {

              printf("尚无足够资源分配！\n");//否则输出错误

          exit(0);

       }

 }

}

 /*系统把所请求的资源分配给进程i之后，将进程的各个资源进行更新，改变资源数*/

void updateResource(int Available[],int Allocation[][M],int Request[],int Need[][M],int i)

{

       int j;

       for(j=0;j<3;j++)//从第一个资源开始更新

       {

         Available[j]-=Request[j];

         Allocation[i][j]__________________;

         Need[i][j]_______________________;

         //-------------      printf("%d  %d  %d\n",Available[j],Allocation[i][j],Need[i][j]);

       }

}

 /*系统执行安全性算法，检查资源分配后，系统是否处于安全状态。

如果安全，将资源分配给进程；否则，本次分配资源失败；继续等待资源分配*/

int safetyTest(int Work[],int Available[],int Finish[],int Need[][M],int Allocation[][M])

{

  int j,i;

  int pre_count=1,post_count=0;

  for(j=0;j<N;j++) //开始时Finish的各值都赋值false

       Finish[j]=false;

  for(j=0;j<M;j++)  //开始时Work=Available

       Work[j]=Available[j];

  /*当前后两次循环pre_count与post_count不相等时，也就是对其中某个（或某些）进程进行了资源分配,则继续执行；

  若相等，则说明未对任何进程进行资源分配，则应退出循环，以免造成死循环*/

  while(pre_count!=post_count)

  { 

         post_count=pre_count;

         for(i=0;i<N;i++)

         {

              if(Finish[i]==false) //如果进程i未进行各类资源分配

              {

                     for(j=0;j<M;j++)

                     {  

                            //=====================printf("%d  %d!!\n",Need[i][j],Work[j]);

                            if(Need[i][j]<=Work[j])

                                   continue;

                            else

                                   break;

                     }

                     if(j==M) //如果进程i所需要的各类资源都不大于系统可用资源

                     {   for(j=0;j<M;j++)

                            {     _______________________

                                   _______________________

                                   pre_count++;

                            }

                     }

              }

         }

        }

  //判断Finish[i]是否都为true，也就是所有进程是否都已分配资源

  for(i=0;i<N;i++)

         {  

              if(Finish[i]!=true)

                     break;

         }

   if(i==N)

       return true;

  else

       return false;

}

void main()

{

 int Available[M]={3,3,2};//开始时3类资源的剩余数目

 int Max[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//5个进程3类资源所需要的最大资源数

 int Allocation[N][M]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//每个进程已分得的资源数

 int Need[N][M];//每个进程还需要的资源数，Need[i][j]= Max[i][j]- Allocation[i][j]

 int i,j,stat;

 int Request[M];//每个进程申请的资源数

 int Work[M];//系统提供给进程继续运行所需要的资源数

 int Finish[N];//用来判断是否有足够的资源分配给进程

 /*计算Need[i][j]*/

 int t;//中间变量

 for(t=0;t<N;t++)

       for(j=0;j<M;j++)

              Need[t][j]=__________________________;

 /*输入第i个进程所请求的各类资源的数目：*/

 printf("请输入哪个进程请求申请资源(0,1,2,3,4):\n");

 scanf("%d",&i);

 printf("输入第%d个进程所请求的各类资源的数目:\n",i);

 for(j=0;j<M;j++)

       {scanf("%d",&Request[j]);}

 /*判断所请求的各类资源是否满足所需要的资源数不超过所宣布的资源数：*/

 __________________________;

  /*判断所请求的各类资源是否满足小于系统现有的各类资源的数目*/

 __________________________;

 /*系统把所请求的资源分配给进程i之后，将进程的各个资源进行更新，改变资源数*/

 __________________________________;

 /*系统执行安全性算法，检查资源分配后，系统是否处于安全状态。

 如果安全，将资源分配给进程；否则，本次分配资源失败；继续等待资源分配*/

 stat=_______________________________;

 if(stat==true)//若全部安全，就说明系统出于安全状态

       printf("系统处于安全状态，可将资源分配给进程%d\n",i);

 else

       printf("系统处于不安全状态，本次资源分配作废!!\n");

}