操作系统实验二：

银行家算法实验

淮海工学院计算机科学系

银行家算法的数据结构◆ 可用资源向量 Available ：长度为 n 的数组表示系统中 n 类资源的当

前可用数目。如果 Available[j]=k ，表示系统中现有 Rj 类资源为 k 个。◆ 最大需求矩阵 Max ： m×n 矩阵定义 m 个进程对 n 类资源的最大需

求量。如 Max[i,j]=k ，表示进程 Pi 运行期间最多需求 Rj 资源的数目为 k 个。

◆ 已分配资源矩阵 Allocation ： m×n 矩阵定义了每个进程现在已分配到的各类资源的实际数目。如果 Allocation [i,j]=k ，表示进程 Pi 当前分到 k 个 Rj 类资源。

◆ 需求矩阵 Need ： m×n 矩阵表示每个进程还需要的各类资源的数目。如果 Need [i, j]=k ，表示进程 Pi 尚需 k 个 Rj 类资源才能完成其任务。很显然， Need[i,j]=Max[i,j] - Allocation[i,j] ，因而，这些数据结构的大小和值会随着时间而改变。

淮海工学院计算机科学系

银行家算法（资源分配算法 )设 Requesti 表示进程 Pi 的资源申请向量。如 Requesti[j]= k ，表示进程 Pi 动态申请 k 个

Rj 类资源。当进程 Pi 申请资源时，就执行下列动作（试探性分配）：① 若 Requesti[j] ＞ Need[i,j] ，产生出错条件，因为进程 Pi 对资源的请求量已超过其说

明的最大数量；否则，转到步骤②。 ② 如果 Requesti[j] ＞ Available[j] ，则进程 Pi 必须等待，这是因为系统现在没有可用的

资源；否则，转到步骤③。③ 如果系统可以给进程 Pi 分配所请求的资源，则应对有关数据结构进行修改： Available[j] = Available[j]-Requesti[j]; (j=1,2,……,n)

Allocation[i,j] = Allocation[i,j] + Requesti[j]; (i=1,2,……,m)

Need[i,j] = Need[i,j] - Requesti[j];

④ 系统执行安全性检查，查看此时系统状态是否安全。如果安全，就给进程 Pi 实际分配资源；否则，即系统是不安全的，则 Pi 等待，作废本次试探性分配，并且把资源分配状态恢复成③之前的情况。

淮海工学院计算机科学系

安全检查算法① 设置两个向量：工作向量 Work ：表示系统可提供给进程继续运行所

需要的各类资源数目，长度为 n ；进程完成标志向量 Finish ：长度为 m ，表示各个进程是否能够得到足够的资源并运行完成。两个向量初始化： Work=Available ， Finish[i]=false （ i=1 ， 2 ，…m ）。

② 从进程集合中搜寻满足下列条件的进程（找安全进程序列）： Finish[i] ==false 且 Need[i ， j]≤Work[j] 。

如果找到这样的进程，执行③；否则，则转向步骤④。③ 修改数据值： Work[j]=Work[j] + Allocation[i,j] （进程 Pi 释放所占的全部资源）； Finish[i]=true ；

返回步骤②；④ 安全与不安全判定：如果所有进程的 Finish[i] ==true 都成立（找着

安全序列），则系统处于安全状态；否则，系统处于不安全状态。

银行家算法主要程序段1 、以书上用例初始化数据结构#define M 5

#define N 3

int available[N]={3,3,2};

int max[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};

int allocation[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};

int need[M][N],p[M];

银行家算法主要程序段1 、以书上用例初始化数据结构#define M 5 // 总进程数 #define N 3 // 总资源数 //M 个进程对 N 类资源最大资源需求量 int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; // 系统可用资源数 int AVAILABLE[N]={10,5,7}; //M 个进程已经得到 N 类资源的资源量 int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};

//M 个进程还需要 N 类资源的资源量 int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};

int Request[N]={0,0,0};

银行家算法主要程序段2 、现实资源分配情况void displaydata() { int i,j; cout<<" 系统可用的资源数为 :"<<endl<<endl; for (j=0;j<N;j++) cout<<" 资源 "<<j<<": "<<AVAILABLE[j]; cout<<endl; cout<<" 各进程还需要的资源量 :"<<endl<<endl; for (i=0;i<M;i++) { cout<<" 进程 "<<i<<":"; for (j=0;j<N;j++)cout<<" 资源 "<<j<<": "<<NEED[i][j]; cout<<endl; } cout<<endl; cout<<" 各进程已经得到的资源量 : "<<endl<<endl; for (i=0;i<M;i++) { cout<<" 进程 "<<i<<":"; for (j=0;j<N;j++)cout<<" 资源 "<<j<<": "<<ALLOCATION[i][j]; cout<<endl; } };

银行家算法主要程序段3 、进程分配资源的数据更新void changedata(int k) // 为进程 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];

}

};

银行家算法主要程序段4 、进程分配资源的数据更新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];

}

};

银行家算法主要程序段5 、安全检查过程中判断进程需求资源是否大于现有资源int compare(int need[ ],int work[ ]) {

 int j;

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

   if(need[j]>work[j]) {

    return FALSE;

   }

  }

 return TRUE;

 }

6 、安全检查程序段int isSecurity(int available[],int need[][N],int allocation[][N]){

 int i,j,k=0,flag,finish[M],work[N]; for(i=0;i<M;i++) {  finish[i]=FALSE; } for(j=0;j<N;j++) {  work[j]=available[j]; } while(TRUE) { // 寻找安全进程序列

  flag=FALSE;  for(i=0;i<M;i++) { // 每一趟循环将找到当前可分配资源的进程，并回收其已分配资源

   if(finish[i]==FALSE&&compare(need[i],work)==TRUE) {     for(j=0;j<N;j++)  work[j]+=allocation[i][j];     finish[i]=TRUE;     p[k++]=i;     flag=TRUE;     break; // 结束 FOR循环，表示 WORK 中资源满足某一进程的资源需求，并执行 while    }  }  if(flag==FALSE) { //只要有一个进程全部资源得到满足，则继续 while(TRUE)循环 for(i=0;i<M;i++) {       if(finish[i]==FALSE) return FALSE; //遇到某一进程的 finish[i] 不成立，则不安全 }     return TRUE; // 对所有进程检查后， finish[i]均为 TRUE ，则有安全序列 }  } //while(TRUE) }