实验3 银行家算法

实验三 银行家算法
一、实验目的
模拟银行家算法，用银行家算法实现资源分配
二、实验内容
已知进程{P0,P1,P2,P3,P4}，有三类系统资源A、B、C的数量分别为
10、5、7，在T0时刻的资源分配情况如下图所示：

资源情况
进程
Max Allocation Need Available

A B C A B C A B C A B C

P0 7 5 3 0 1 0 7 4 3 3 3 2
P1 3 2 2 2 0 0 1 2 2
P2 9 0 2 3 0 2 6 0 0
P3 2 2 2 2 1 1 0 1 1
P4 4 3 3 0 0 2 4 3 1

（1）若进程P1请求资源，发出请求向量Request1（1，0，2），编
写程序用银行家算法判断系统能否将资源分配给它；
（2）若进程P2提出请求Request(0，1，0)，用银行家算法程序验
证系统能否将资源分配给它。

#include
#include
#define RESOURCE 3
#define PRO 5
class Process
{
public :
int max[RESOURCE];
int allocation[RESOURCE];
int need[RESOURCE];
int request[RESOURCE];
public:
//对资源第一次分配
void Inital(int index,int allo,int n)
{
allocation[index] = allo;
need[index] = n;
}
//某个进程需要资源
void Request(int index,int req)
{
request[index] = req;
}

};

//检测安全性
bool Safe(int work[],Process pro[])
{
bool finish[PRO];
for(int i=0;i{
finish[i] =false;
}

int j=0; //用来表示资源下标
int k=0;
int index[PRO];
for(i=0;i{
for(int m=0;m{
if(work[j] >= pro[m].need[j] && work[j+1] >= pro[m].need[j+1]
&& work[j+2] >= pro[m].need[j+2] && finish[m] == false)
{
finish[m] = true;
index[k++] = m;
for(int j=0;j{
work[j] = work[j] + pro[m].allocation[j];
}

}
}
}
for(i=0;i{
if(finish[i] ==false)
{
printf("该申请资源数量不合法，不存在安全序列~\n");
return false;
}
}

printf("该进程申请的资源数量合法，其安全序列为：\n{");
for(i=0;i{
{
printf(" p%d;",index[i]);
}
}
printf("}\n");
return true;
}

//用来比较所申请的资源是否满足要求
bool Compare(int index,int avaliable[],Process pro[])
{
for(int i=0;i{
if(pro[index].need[i] < pro[index].request[i] || avaliable[i] <
pro[index].request[i])
return false;
}
return true;

}
//
void Require(int index, bool check,int avaliable[], Process pro[])
{
if(check == false)
{
printf("第一次分配资源造成死锁，不合理。请重新分配资源！");
}
else
{
//某个进程请求分配的资源
//print("请输入哪个进程需要多少");
int a,b,c;
printf("请分别输入A、B、C类资源对应的数量：");
scanf("%d%d%d",&a,&b,&c);
pro[index].Request(0,a); //102
pro[index].Request(1,b);
pro[index].Request(2,c);

//申请资源后，对其检验所申请的数量是否符合相应的要求
int m=0;
if(Compare(index,avaliable,pro)) //注意这里，在这里如果request[0]第一个满足条件就
进行修改
{

for(int i=0;i{
pro[index].allocation[i] += pro[index].request[i];
pro[index].need[i] -= pro[index].request[i] ;
avaliable[i] -= pro[index].request[i] ;
}
}
else
{
printf("该类资源申请数量不合法！\n");
return;
}

int ava[RESOURCE];
for(int i=0;i{
ava[i] = avaliable[i];
}
Safe(ava,pro);
}
}
void main()
{
//定义进程
Process p[5];

//将进程初始化
int avaliable[RESOURCE] = {3,3,2};
p[0].Inital(0,0,7); //（第一个数字第几表示第几类资源，第二个表示allocation,第三个表示need）
p[0].Inital(1,1,4);
p[0].Inital(2,0,3);

p[1].Inital(0,2,1);
p[1].Inital(1,0,2);
p[1].Inital(2,0,2);

p[2].Inital(0,3,6);
p[2].Inital(1,0,0);
p[2].Inital(2,2,0);

p[3].Inital(0,2,0);
p[3].Inital(1,1,1);
p[3].Inital(2,1,1);

p[4].Inital(0,0,4);
p[4].Inital(1,0,3);
p[4].Inital(2,2,1);

//先对第一次分配实行安全检查
char y='y';
int a[RESOURCE];
int index; //用于标注进程的下标

for(int i=0;i{
a[i] = avaliable[i];
}

bool check = Safe(a,p); //在这里a数组里面的值被改变了
while(y=='y')
{
printf("\n请输入哪个进程要申请资源:");
scanf("%d",&index);
Require(index,check,avaliable,p);
printf("是否继续申请资源？（y|n）");
getchar();
scanf("%c",&y);
}
}
实验结果：