银行家算法实验报告文档格式.docx
《银行家算法实验报告文档格式.docx》由会员分享，可在线阅读，更多相关《银行家算法实验报告文档格式.docx（16页珍藏版）》请在冰点文库上搜索。
（2）如果Request＜or=Available,则转向步骤（3）；
否则，表示系统中尚无足够的资源，进程必须等待。
（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：
Available=Available-Request[i];
Allocation=Allocation+Request;
Need=Need-Request;
（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
3、安全性算法步骤：
（1）设置两个向量
①工作向量Work。
它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;
②布尔向量Finish。
它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。
（2）从进程集合中找到一个能满足下述条件的进程：
①Finish[i]=false
②Need<
or=Work
如找到，执行步骤（3）；
否则，执行步骤（4）。
（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work=Work+Allocation;
Finish[i]=true;
转向步骤
（2）。
（4）如果所有进程的Finish[i]=true,则表示系统处于安全状态；
否则，系统处于不安全状态。
4、流程图：
系统主要过程流程图
银行家算法流程图
安全性算法流程图
四、实验代码：
#include<
iostream.h>
string.h>
stdio.h>
#defineFalse0
#defineTrue1
intMax[100][100]={0};
//各进程所需各类资源的最大需求
intAvaliable[100]={0};
//系统可用资源
charname[100]={0};
//资源的名称
intAllocation[100][100]={0};
//系统已分配资源
intNeed[100][100]={0};
//还需要资源
intRequest[100]={0};
//请求资源向量
inttemp[100]={0};
//存放安全序列
intWork[100]={0};
//存放系统可提供资源
intp[100]={0};
intq[100][100]={0};
intz[100][100]={0};
intM=100;
//作业的最大数为100
intN=100;
//资源的最大数为100
intgg=1;
voidshowdata（）//显示资源矩阵
{
inti,j;
cout<
<
endl<
"
此时刻的资源分配情况为：
endl;
MaxAllocationNeedAvaliable"
进程名"
;
for（j=0;
j<
4;
j++）{
for（i=0;
i<
N;
i++）
name[i]<
"
}
M;
i++）{
j++）
Max[i][j]<
Allocation[i][j]<
Need[i][j]<
if（i==0）{
for（j=0;
Avaliable[j]<
//输出分配资源
}
intchangdata（inti）//进行资源分配
{
intj;
for（j=0;
j++）{//p[j]=Avaliable[j];
Avaliable[j]=Avaliable[j]-Request[j];
//q[i][j]=Allocation[i][j];
Allocation[i][j]=Allocation[i][j]+Request[j];
//z[i][j]=Need[i][j];
Need[i][j]=Need[i][j]-Request[j];
return1;
intsafe（）//安全性算法
inti,d,k=0,m,h,s,apply,Finish[100]={0};
intflag=0;
for（i=0;
Work[i]=Avaliable[i];
cout<
安全性检查"
WorkNeedAllocationWork+AllocationFinish"
for（h=0;
h<
h++）{
for（s=0;
s<
s++）
name[s]<
i++）{
apply=0;
if（Finish[i]==False&
&
=Work[j]）
{
apply++;
if（apply==N）
{cout<
for（d=0;
d<
d++）
cout<
Work[d]<
for（d=0;
Need[i][d]<
Allocation[i][d]<
for（m=0;
m<
m++）
Work[m]=Work[m]+Allocation[i][m];
Work[m]<
}//变分配数
Finish[i]=True;
temp[k]=i;
true"
i=-1;
k++;
flag++;
if（Finish[i]==False）{
Avaliable[j]=Avaliable[j]+Request[j];
Allocation[i][j]=Allocation[i][j]-Request[j];
Need[i][j]=Need[i][j]+Request[j];
系统进入不安全状态！
此时系统不分配资源！
//不成功系统不安全
return0;
此时系统是安全的!
//如果安全，输出成功
安全序列为:
i++）{//输出运行进程数组
temp[i];
if（i<
M-1）cout<
->
voidshare（）//利用银行家算法对申请资源对进行判定
charch;
inti=0,j=0;
ch='
y'
请输入要求分配的资源进程号（0-"
M-1<
）:
cin>
>
i;
//输入须申请的资源号
请输入进程"
申请的资源:
for（j=0;
name[j]<
:
Request[j];
//输入需要申请的资源
if（Request[j]>
Need[i][j]）//判断申请是否大于需求，若大于则出错
进程"
申请的资源大于它需要的资源"
分配不合理，不予分配！
ch='
n'
break;
else{
Avaliable[j]）//判断申请是否大于当前资源，若大于则
{//出错
进程"
申请的资源大于系统现在可利用的资源"
分配出错，不予分配!
if（ch=='
）{
changdata（i）;
//根据进程需求量变换资源
showdata（）;
//根据进程需求量显示变换后的资源
safe（）;
//根据进程需求量进行银行家算法判断
intmain（）//主函数
intt=1,i,j,number,choice,m,n,flag;
charming;
*****************银行家算法的设计与实现*****************"
请首先输入系统可供资源种类的数量:
cin>
n;
N=n;
资源"
i+1<
的名称:
ming;
name[i]=ming;
资源的数量:
number;
Avaliable[i]=number;
请输入作业的数量:
m;
M=m;
请输入各进程的最大需求量（"
*"
n<
矩阵）[Max]:
Max[i][j];
do{
flag=0;
请输入各进程已经申请的资源量（"
矩阵）[Allocation]:
Allocation[i][j];
if（Allocation[i][j]>
Max[i][j]）
flag=1;
Need[i][j]=Max[i][j]-Allocation[i][j];
if（flag）
申请的资源大于最大需求量，请重新输入!
\n"
while（flag）;
//显示各种资源
//用银行家算法判定系统是否安全
while
（1）{
if（t==1）{
利用银行家算法预分配资源"
share（）;
t=0;
elsebreak;
是否继续银行家算法？
（按1键继续,按其它任意键退出）:
cin>
t;
return1;
五、程序执行结果：
六、实验总结
多个进程同时运行时，系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列，使得系统能快速且安全地运行进程，不至发生死锁。
银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我们来学习借鉴。
升级会员 