实验四 银行家算法Word文件下载.docx
《实验四 银行家算法Word文件下载.docx》由会员分享，可在线阅读，更多相关《实验四 银行家算法Word文件下载.docx（19页珍藏版）》请在冰豆网上搜索。
假设平安，才正式将资源分配给进程；
否那么本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
（5）用do{…}while循环语句实现输入字符y/n判断是否继续进行资源申请。
4．平安性检查算法〔safe（）函数〕
（1）设置两个向量：
工作向量Work，它表示系统可提供应进程继续运行所需的各类资源数目，在执行平安性算法开始时，Work=Available。
Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish[i]=0；
当有足够的资源分配给进程时，再令Finish[i]=1。
（2）在进程中查找符合以下条件的进程：
条件1：
Finish[i]=0；
条件2：
need[i][j]<
=Work[j]
假设找到，那么执行步骤（3）否那么，执行步骤（4）
（3）当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]=Work[j]+Allocation[i][j]；
Finish[i]=1；
gotostep2；
（4）如果所有的Finish[i]=1都满足，那么表示系统处于平安状态，否那么，处于不平安状态。
四：
源程序结构分析
1．程序结构
程序共有以下五个局部：
初始化chushihua（）：
用于程序开始进行初始化输入数据：
进程数量、资源种类、各种资源可利用数量、各进程的各种资源已分配数量、各进程对各类资源最大需求数等。
当前平安性检查safe（）：
用于判断当前状态平安性，根据不同地方的调用提示处理不同。
银行家算法bank（）：
进行银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。
显示当前状态show（）：
显示当前资源分配详细情况，包括：
各种资源的总数量（all）、系统目前各种资源可用的数量、各进程已经得到的资源数量、各进程还需要的资源量。
主程序main（）
逐个调用初始化、显示状态、平安性检查、银行家算法函数，使程序有序的进行。
2．数据结构
程序使用的全局变量：
constintx=10，y=10；
//定义常量
intAvailable[x];
//各种资源可利用的数量
intAllocation[y][y];
//各进程当前已分配的资源数量
intMax[y][y];
//各进程对各类资源的最大需求数
intNeed[y][y];
//还需求矩阵
intRequest[x];
//申请各类资源的数量
intWork[x];
//工作向量，表系统可提供应进程运行所需各类资源数量
intFinish[y];
//表系统是否有足够的资源分配给进程，0为否，1为是
intp[y];
//存储平安序列
inti,j;
//全局变量，主要用于循环语句中
intn,m;
//n为进程的数量,m为资源种类数
intl=0,counter=0;
3．函数声明
voidchushihua（）;
//系统初始化函数
voidsafe（）;
//平安性算法函数
voidbank（）;
//银行家算法函数
voidshow（）;
//输出当前资源分配情况
4．主函数main（）
intmain（）
{
cout<
<
……//显示程序开始提示信息
chushihua（）;
//初始化函数调用
endl<
endl;
showdata（）;
//输出初始化后的状态
//===判断当前状态的平安性===
safe（）;
//平安性算法函数调用
if（l<
n）{
"
\n当前状态不平安，无法申请,程序退出!
!
system（"
pause"
）;
sign（）;
//调用签名函数
return0;
//
break;
}
else{
inti;
//局部变量
l=0;
cout<
\n平安的状态!
平安序列为:
"
;
进程"
（"
p[0]<
）"
//输出平安序列，考虑显示格式，先输出第一个
for（i=1;
i<
n;
i++）{
==>
>
p[i]<
}
for（i=0;
i++）Finish[i]=0;
//所有进程置为未分配状态
}
bank（）;
//银行家算法函数调用
return0;
5．源程序代码
#include<
iostream.h>
stdio.h>
stdlib.h>
string.h>
//定义全局变量
constintx=10,y=10;
//常量，便于修改
//各资源可利用的数量
//各进程当前已分配的资源数量
//各进程对各类资源的最大需求数
//尚需多少资源
//申请多少资源
//工作向量，表示系统可提供应进程继续运行所需的各类资源数量
//表示系统是否有足够的资源分配给进程，1为是
//存储平安序列
//i表示进程，j表示资源
//n为进程i的数量,m为资源j种类数
intl=0;
//l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是平安的
intcounter=0;
//函数声明
//初始化函数
//平安性算法
voidshow（）;
//函数show,输出当前状态
//银行家算法
voidjieshu（）;
//结束函数
voidchushihua（）
输入进程的数量:
//从此开始输入有关数据
cin>
输入资源种类数:
m;
输入各种资源当前可用的数量（"
m<
种）:
for（j=0;
j<
j++）
{
cout<
输入资源"
j<
可利用的数量Available["
]:
cin>
Available[j];
//输入数字的过程...
Work[j]=Available[j];
//初始化Work[j]，它的初始值就是当前可用的资源数
输入各进程当前已分配的资源数量Allocation["
n<
]["
i++）
cout<
输入进程"
i<
当前已分配的资源"
数量:
cin>
Allocation[i][j];
Finish[i]=0;
//初始化Finish[i]
输入各进程对各类资源的最大需求Max["
对资源"
的最大需求数:
Max[i][j];
if（Max[i][j]>
=Allocation[i][j]）//假设最大需求大于已分配，那么计算需求量
Need[i][j]=Max[i][j]-Allocation[i][j];
else
Need[i][j]=0;
//Max小于已分配的时候，此类资源已足够不需再申请
初始化完成"
//平安性算法函数
voidsafe（）
i++）
{//i++
if（Finish[i]==0）
{//逐个查找Finish[i]==0的进程条件一
counter=0;
//记数器
for（j=0;
{
if（Work[j]>
=Need[i][j]）counter=counter+1;
//可用大于需求，记数
}
if（counter==m）//i进程的每类资源都符合Work[j]>
=Need[i][j]条件二
p[l]=i;
Finish[i]=1;
//i进程标志为可分配
for（j=0;
j++）
Work[j]=Work[j]+Allocation[i][j];
//释放资源
l=l+1;
//记数,现在有L个进程是平安的，当L=N时说明满足平安序列
i=-1;
//从第一个进程开始继续寻找满足条件一二的进程
}
//显示当前状态函数
voidshow（）//函数show,输出当前资源分配情况
inti,j;
intAll[y];
//各种资源的总数量
intL1;
//局部变量L1
当前的状态为：
各种资源的总数量:
资源"
:
All[j]=Available[j];
//总数量=可用的+已分配的
for（i=0;
i++）All[j]+=Allocation[i][j];
All[j]<
当前各种资源可用的量为（available）:
Available[j]<
各进程已经得到的资源量（allocation）:
for（i=0;
=m;
for（j=i;
j++）cout<
j;
for（L1=0;
L1<
L1++）
{
for（j=i;
Allocation[L1][j]<
各进程还需要的资源量（need）:
for（j=i;
for（L1=0;
Need[L1][j]<
//银行家算法函数
voidbank（）
进程申请分配资源：
intk=0;
//用于输入进程编号
boolr=false;
//初值为假，输入Y继续申请那么置为真
do{//输入请求
输入申请资源的进程（0-"
n-1<
）:
k;
while（k>
n-1）//输入错误处理
输入错误，重新输入：
输入申请资源的进程（0--"
输入该进程申请各类资源的数量:
for（j=0;
do{//do……while循环判断申请输入的情况
cout<
进程"
k<
申请资源["
]的数量:
cin>
Request[j];
if（Request[j]>
Need[k][j]）{//申请大于需求量时出错，提示重新输入〔贷款数目不允许超过需求数目〕
cout<
申请大于需要量!
申请的资源"
的数量为"
Request[j]<
大于进程"
对该资源需求量"
Need[k][j]<
。
重新输入!
}
else//先判断是否申请大于需求量，再判断是否申请大于可利用量
if（Request[j]>
Available[j]）{//申请大于可利用量，应该阻塞等待？
……？
？
cout<
\n没有那么多资源，目前可利用资源"
数量为"
本次申请不成功，进程等待!
Finish[k]=0;
//该进程等待
gotoppp;
//goto语句跳转，结束本次申请
}
}while（Request[j]>
Need[k][j]）;
//Request[j]>
Available[j]||
//改变Avilable、Allocation、Need的值
j++）{
Available[j]=Available[j]-Request[j];
Allocation[k][j]=Allocation[k][j]+Request[j];
Need[k][j]=Need[k][j]-Request[j];
Work[j]=Available[j];
//判断当前状态的平安性
safe（）;
//调用平安性算法函数
if（l<
n）
l=0;
\n试分配后，状态不平安,所以不予分配!
恢复原状态"
//恢复数据
Available[j]=Available[j]+Request[j];
Allocation[k][j]=Allocation[k][j]-Request[j];
Need[k][j]=Need[k][j]+Request[j];
Work[j]=Available[j];
for（i=0;
Finish[i]=0;
//进程置为未分配状态
else
\n申请资源成功!
for（j=0;
if（Need[k][j]==0）;
else{//有一种资源还没全部申请到，那么该进程不可执行，不能释放拥有的资源
l=1;
//置l为1，作为判断标志
break;
if（l!
=1）{//进程可以执行，那么释放该进程的所有资源
j++）{
Available[j]=Available[j]+Allocation[k][j];
Allocation[k][j]=0;
该进程已得到所有需求资源，执行后将释放其所有拥有资源！
//归零
Finish[0]=0;
for（i=1;
Finish[i]=0;
show（）;
//显示当前状态
ppp:
//申请大于可利用量，应该阻塞等待,结束本次资源申请，GOTO语句跳转至此
是否继续申请资源（y/n）?
char*b=newchar;
//输入y/n，判断是否继续申请<
endl
b;
-------------------------------------------"
if（*b=='
y'
||*b=='
Y'
）
r=true;
else{
r=false;
//输入非Y那么令R=false
jieshu（）;
//调用结束函数
}while（r==true）;
//结束函数
voidjieshu（）
\t\t演示计算完毕"
//主函数
\t\t\t\t模拟银行家算法"
show（）;
//输出当前状态
//判断当前状态的平安性
n）//l在safe中是用来记录平安的进程的个数的
\n当前状态不平安，拒绝申请！
else
\n当前的状态是平安的!
//输出平安序列
for（i=1;
i++）cout<
->
//调用银行家算法函数
}
五：
程序运行结果
1．例如数据〔课本例题〕
进程数量：
5
资源种类3〔三种资源以abc表示〕
例如数据
资源
Max
Allocation
Need
Available
进程
abc
753
010
743
332
1
322
200
122
2
902
302
600
3
222
升级会员 