#include <iostream>
using namespace std;
#define FALSE 0
#define TRUE 1
#define W 10 //最大进程数W=10
#define R 20 //最大资源总数R=20
int M ;
int N ;
int ALL_RESOURCE[W];
int AVAILABLE[R]; //可利用资源向量
int MAX[W][R]; //最大需求矩阵
int ALLOCATION[W][R]; //分配矩阵
int NEED[W][R]; //需求矩阵
int Request[R]; //进程请求向量
void inputdata(); //数据输入
void showdata(); //数据显示
void changdata(int k);//进程请求资源数据改变
void restoredata(int k); //数据恢复
int chksec(int s); //系统安全性的检测
int chkmax(int s); //检测最大需求
void bank(); //检测分配的资源是否合理
int main()
{
int i,j;
inputdata();//安全性算法
for(i=0;i<M;i++)
{ j=chksec(i);
if (j==0) break;
}
if (i>=M)
cout<<"错误提示：经安全性检查发现，系统的初始状态不安全！！！\n"<<endl;
else
{ cout<<"提示：经安全性检查发现，系统的初始状态安全！"<<endl;
bank();
}
return 0;
}
void inputdata()//数据输入
{
int i=0,j=0,p;
cout<<"请输入总进程数:"<<endl;
do{
cin>>M;
if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数，请重新输入:"<<endl;
}while (M>W);
cout<<endl;
cout<<"请输入资源的种类数:"<<endl;
do {cin>>N;
if (N>R)
cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数，请重新输入:"<<endl; }while (N>R);
cout<<endl;
cout<<"请依次输入各类资源的总数量，即设置向量all_resource:"<<endl;
for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];
cout<<endl;
cout<<"请依次输入各进程所需要的最大资源数量，即设置矩阵max:"<<endl;
for (i=0;i<M;i++)
{
for (j=0;j<N;j++)
{
do { cin>>MAX[i][j];
if (MAX[i][j]>ALL_RESOURCE[j])
cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);
}
}
cout<<endl;
cout<<"请依次输入各进程已经占据的各类资源数量，即设置矩阵allocation:"<<endl;
for (i=0;i<M;i++)
{
for (j=0;j<N;j++)
{
do{ cin>>ALLOCATION[i][j];
if (ALLOCATION[i][j]>MAX[i][j])
cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;
}while (ALLOCATION[i][j]>MAX[i][j]);
}
}
cout<<endl;
for (i=0;i<M;i++)
for(j=0;j<N;j++)
NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];
for (j=0;j<N;j++)
{ p=ALL_RESOURCE[j];
for (i=0;i<M;i++)
{ p=p-ALLOCATION[i][j];
AVAILABLE[j]=p;
if(AVAILABLE[j]<0)
AVAILABLE[j]=0;
}
}
}
void showdata()//银行家算法
{ int i,j;
cout<<"各种资源的总数量，即向量all_resource为:"<<endl;
cout<<" ";
for (j=0;j<N;j++)
cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];
cout<<endl<<endl;
cout<<"当前系统中各类资源的可用数量，即向量available为:"<<endl;
cout<<" ";
for (j=0;j<N;j++)
cout<<" 资源"<<j<<": "<<AVAILABLE[j];
cout<<endl<<endl;
cout<<"各进程还需要的资源数量，即矩阵need为:"<<endl<<endl;
for (i=0;i<M;i++)
{ cout<<"进程P"<<i<<": ";
for (j=0;j<N;j++)
cout<<NEED[i][j]<<" ";
cout<<endl;
}
cout<<endl;
cout<<"各进程已经得到的资源量，即矩阵allocation为: "<<endl<<endl;
for (i=0;i<M;i++)
{ cout<<"进程P"<<i<<": ";
for (j=0;j<N;j++)
cout<<ALLOCATION[i][j]<<" ";
cout<<endl;
} cout<<endl;
}
void changdata(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];//补充缺失的代码
}
}
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];//补充缺失的代码
}
}
int chksec(int s)//系统安全性的检测
{
int WORK,FINISH[W];
int i,j,k=0;
for(i=0;i<M;i++)
FINISH[i]=FALSE;
for(j=0;j<N;j++)
{
WORK=AVAILABLE[j];
i=s;
do
{ if(FINISH[i]==TRUE&&NEED[i][j]<=WORK)//补充缺失的代码
{
WORK+=ALLOCATION[i][j];//补充缺失的代码
FINISH[i]=TRUE;//补充缺失的代码
i=0;
}else
{ i++;
}
}while(i<M);
for(i=0;i<M;i++)
if(FINISH[i]==TRUE)//补充缺失的代码
{ return 1;
}
} return 0;
}
int chkmax(int s) //检测最大需求
{ int j,flag=0;
for(j=0;j<N;j++)
{
if (MAX[s][j]==ALLOCATION[s][j])
{ flag=1;
AVAILABLE[j]=s;//补充缺失的代码
MAX[s][j]=0;
}
} return flag;
}
void bank()
{
int i=0,j=0;
char flag='Y';
while(flag=='Y'||flag=='y')
{
i=-1;
while(i<0||i>=M)
{ cout<<"请输入需申请资源的进程号（从P0到P"<<M-1<<"，否则重新输入!）:";
cout<<"p";
cin>>i;
if(i<0||i>=M)
cout<<"输入的进程号不存在，重新输入!"<<endl;
}
cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;
for (j=0;j<N;j++)
{ cout<<" 资源"<<j<<": ";
cin>>Request[j];
if(Request[j]>NEED[i][j])
{ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";
cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;
flag='N';
break;
}
else
{ if(Request[j]>AVAILABLE[j])
{ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";
cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;
flag='N';
break;
}
}
}
if(flag=='Y'||flag=='y')
{ changdata(i);
if(chksec(i))
{ cout<<endl;
cout<<"该分配会导致系统不安全!!! 本次资源申请不成功，不予分配!!!"<<endl;
cout<<endl;
restoredata(i);
}
else
{ cout<<endl;
cout<<"经安全性检查，系统安全，本次分配成功，且资源分配状况如下所示："<<endl;
cout<<endl;
showdata();
if(chkmax(i))
{cout<<"在资源分配成功之后，由于该进程所需的某些资源的最大需求量已经满足，"<<endl;
cout<<"因此在进程结束后系统将回收这些资源！"<<endl;
cout<<"在资源收回之后，各进程的资源需求和分配情况如下所示："<<endl;
showdata();
}
}
}
cout<<endl;
cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";
cin>>flag; }}
测试样例
请输入总进程数:
5
请输入资源的种类数:
3
请依次输入各类资源的总数量，即设置向量all_resource:
10 5 7
请依次输入各进程所需要的最大资源数量，即设置矩阵max:
7 5 3
3 2 2
9 0 2
2 2 2
4 3 3
请依次输入各进程已经占据的各类资源数量，即设置矩阵allocation:
0 1 0
2 0 0
3 0 2
2 1 1
0 0 2
请输入需申请资源的进程号（从P0到P4，否则重新输入!）:p1
请输入进程P1申请的资源数:
资源0: 1
资源1: 0
资源2: 2
经安全性检查，系统安全，本次分配成功，且资源分配状况如下所示：
各种资源的总数量，即向量all_resource为:
资源0: 10 资源1: 5 资源2: 7
当前系统中各类资源的可用数量，即向量available为:
资源0: 2 资源1: 3 资源2: 0
各进程还需要的资源数量，即矩阵need为:
进程P0: 7 4 3
进程P1: 0 2 0
进程P2: 6 0 0
进程P3: 0 1 1
进程P4: 4 3 1
各进程已经得到的资源量，即矩阵allocation为:
进程P0: 0 1 0
进程P1: 3 0 2
进程P2: 3 0 2
进程P3: 2 1 1
进程P4: 0 0 2
在资源分配成功之后，由于该进程所需的某些资源的最大需求量已经满足，
因此在进程结束后系统将回收这些资源！
在资源收回之后，各进程的资源需求和分配情况如下所示：
各种资源的总数量，即向量all_resource为:
资源0: 10 资源1: 5 资源2: 7
当前系统中各类资源的可用数量，即向量available为:
资源0: 1 资源1: 3 资源2: 1
各进程还需要的资源数量，即矩阵need为:
进程P0: 7 4 3
进程P1: 0 2 0
进程P2: 6 0 0
进程P3: 0 1 1
进程P4: 4 3 1
各进程已经得到的资源量，即矩阵allocation为:
进程P0: 0 1 0
进程P1: 3 0 2
进程P2: 3 0 2
进程P3: 2 1 1
进程P4: 0 0 2
是否继续银行家算法演示,按’Y’或’y’键继续,按’N’或’n’键退出演示: y
请输入需申请资源的进程号（从P0到P4，否则重新输入!）:p4
请输入进程P4申请的资源数:
资源0: 3
进程P4申请的资源数大于系统可用0类资源的资源量!申请不合理，出错!请重新选择!
是否继续银行家算法演示,按’Y’或’y’键继续,按’N’或’n’键退出演示: y
请输入需申请资源的进程号（从P0到P4，否则重新输入!）:p0
请输入进程P0申请的资源数:
资源0: 0
资源1: 2
资源2: 0
经安全性检查，系统安全，本次分配成功，且资源分配状况如下所示：
各种资源的总数量，即向量all_resource为:
资源0: 10 资源1: 5 资源2: 7
当前系统中各类资源的可用数量，即向量available为:
资源0: 1 资源1: 1 资源2: 1
各进程还需要的资源数量，即矩阵need为:
进程P0: 7 2 3
进程P1: 0 2 0
进程P2: 6 0 0
进程P3: 0 1 1
进程P4: 4 3 1
各进程已经得到的资源量，即矩阵allocation为:
进程P0: 0 3 0
进程P1: 3 0 2
进程P2: 3 0 2
进程P3: 2 1 1
进程P4: 0 0 2
是否继续银行家算法演示,按’Y’或’y’键继续,按’N’或’n’键退出演示:n
2907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
