操作系统 实验四

实验四银行家算法
（一）教学要求
掌握处理死锁的方法，掌握银行家算法的实现
（二）知识点提示
死锁的概念，死锁产生的原因和条件，处理死锁的方法，银行家算法，安全状态和不安全状态，安全性算法
（三）教学内容
银行家算法的模拟实现
实验步骤:
（1）定义数据结构:
allocation[][]; //分配矩阵
available[]; //可用资源向量
need[][]; //需求矩阵
request[]; //资源请求向量
（2）定义函数：void bank_arithmetic(int i, int request[]) //银行家算法
void isSafe( ); //安全性算法
主函数中对可用资源向量，分配矩阵和需求矩阵进行初始化（输入数据参照课本P113的例题），输入请求资源的进程编号以及请求的资源向量，通过调用银行家算法判断是否可以把资源分配给请求资源的进程。

（3）银行家算法的执行步骤：
设Request i是进程P i的请求向量。

若Request i[j]=k，表示进程P i需要k个j类资源。

当P i 发出资源请求后，系统按下述步骤进行检查：
①若Request i≤Need i，则转②；否则，认为出错。

因为它所需要的资源数已超过它所宣布的最大值。

②若Request i≤Available，则转③；否则，表示系统中尚无足够的资源，P i必须等待。

③系统试探把要求的资源分配给进程P i，并修改下面数据结构中的数值。

Available=Available – Request i
Allocation i = Allocation i + Request i
Need i = Need i– Request i
④系统执行安全性算法，检测此次资源分配后，系统是否处于安全状态。

若安全，才正式将资源分给进程P i；否则，将试探分配作废，恢复资源状态，让P i等待。

（4）安全性算法的执行步骤：
①设置两个向量work和finish
工作向量work，它表示系统可提供给进程继续运行的各类资源数，含有m个元素，其初始值为：work[j]=available[j]。

完成向量finish，它表示系统是否有足够资源使进程推进完成，开始执行安全性算法时，
Finish[i]=false;当有足够资源分配给进程Pi，Pi推进完成时，令Finish[i]=true。

②从进程集合中找到一个进程，其满足：
Finish[i]=false
Need[i,j] ≤Work[j]
如找到则执行步骤③，找不到则执行步骤④。

③当进程Pi获得资源后，便可以向前推进，直至完成，并释放出分配给它的全部资源，故应执行：
Work[j]=Work[j]+Allocation[i,j];
Finish[i]=true;
执行步骤②。

④若所有进程的Finish都为true，则系统为安全状态；否则，系统为不安全状态。

实验程序：
#include <stdio.h>
#define M 3
#define N 5
int available[]={3,3,2};
int allocation[N][M]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
int need[N][M]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};
void banker_arithmetic(int i,int request[]){
int isSafe();
int j,k,l;
printf("进程P%d请求资源，资源请求向量为: \n",i);
for(j=0;j<M;j++)
printf("%d ",request[j]);
printf("\n");
j=0;
while(j < M){
if(request[j]<=need[i][j])
j++;
else
break;
}
if(j==M){
k=0;
while(k < M)
if(request[k]<=need[i][k])
k++;
else
break;
if(k==M){
for(l=0;l<M;l++){
available[l]=available[l]-request[l];
allocation[i][l]=allocation[i][l]+request[l];
need[i][l]=need[i][l]-request[l];
}
if(isSafe())
printf("分配是安全的，可以把资源分配给p%d\n",i);
else{
printf("分配是不安全的，不能把资源分配给P%d\n",i);
for(l=0;l<M;l++){
available[l]=available[l]+request[l];
allocation[i][l]=allocation[i][l]-request[l];
need[i][l]=need[i][l]+request[l];
}
}
}
}
printf("Allocation:");
for(j=0;j<N;j++){
for(k=0;k<M;k++)
printf("%d ",allocation[j][k]);
printf("\n");
}
printf("Need:");
for(j=0;j<N;j++){
for(k=0;k<M;k++)
printf("%d ",need[j][k]);
printf("\n");
}
printf("Available:\n");
for(j=0;j<M;j++)
printf("%d ",available[j]);
printf("\n");
i++;
}
int isSafe(){
int work[M];
int i,j,k,l=0,a=0;
int finish[]={0,0,0,0,0};
for(i=0;i<M;i++){
work[i]=available[i];
}
while(l<N||a < N){
i=0;
while(i<N){
if(finish[i]==0){
j=0;
while(j<M)
if(need[i][j]<=work[j])
j++;
else
break;
if(j==M){
printf("P%d ",i);
for(k=0;k<M;k++)
{
work[k]=work[k]+allocation[i][k];
}
printf("\n");
finish[i]=1;
l++;
}
}
i++;
}
a++;
}
for(i=0;i<N;i++)
if(finish[i]==0)
return 0;
return 1;
}
int main()
{
int i=1;
int request[]={1,0,2};
banker_arithmetic(i,request);
return 0;
}
实验结果：
进程p1请求资源，资源请求向量为：1 0 2
p1
p3
p4
p0
p2
分配是安全的，可以把资源分配给p1 Allocation:0 1 0
3 0 2
3 0 2
2 1 1
0 0 2
Need:7 4 3
0 2 0
6 0 0
0 1 1
4 3 1
Available:
2 3 0
Press any key to continue.
（四）思考题
1、死锁产生的原因是什么？
死锁产生的原因有竞争不可抢占型资源引起死锁竞争可消耗资源引起死锁进程推进顺序不当引发死锁
2、处理死锁的方法有哪些？
预防死锁：通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或几个。

避免死锁：在系统的资源分配过程中，用某种方法去防止系统进入不安全状态（可能会导致思索的状态），从而避免发生死锁。

检测和解除死锁：当进程申请资源时，不进行任何限制，即允许死锁发生。

但要求系统定期或不定期检测是否有死锁发生。

当检测到系统中已发生死锁时，将进程从死锁状态中解脱出来。