实验22银行家算法Word格式.docx
《实验22银行家算法Word格式.docx》由会员分享，可在线阅读，更多相关《实验22银行家算法Word格式.docx（10页珍藏版）》请在冰豆网上搜索。
否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。
2．如果Requesti≤Available，则转向步骤3；
否则，表示系统中尚无足够的资源满足Pi的申请，Pi必须等待。
3．系统试探性地把资源分配给进程Pi，并修改下面数据结构中的数值：
Available=Available-Requesti
Allocationi=Allocationi+Requesti
Needi=Needi-Requesti
4．系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
如果安全才正式将资源分配给进程Pi，以完成本次分配；
否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
假定系统有5个进程（p0,p1,p2,p3,p4）和三类资源（A，B，C），各种资源的数量分别为10，5，7，在T0时刻的资源分配情况如下图：
MaxAllocationNeedAvailable
ABCABCABCABC
P0753010743332
（230）
P1322200122
（302）（020）
P2902302600
P3222211011
P4433002431
五、安全性算法
1．设置两个向量。
Work：
它表示系统可提供给进程继续运行的各类资源数目，它包含m个元素，开始执行安全性算法时，Work=Available。
Finish：
它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish（I）=false；
当有足够资源分配给进程Pi时，令Finish（i）=true；
2．从进程集合中找到一个能满足下述条件的进程。
Finish（i）==false；
Needi≤work；
如找到则执行步骤3；
否则，执行步骤4；
3．当进程Pi获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行
Work=work+Allocationi
Finish（i）=true；
转向步骤2；
4．若所有进程的Finish（i）都为true，则表示系统处于安全状态；
否则，系统处于不安全状态。
六、系统流程图
开始
输入资源数m,及各类资源总数，初始化Available向量
输入进程数n，i=1
输入进程i的最大需求向量max。
i≤n
max≤资源总数
提示错误重新输入
i加1
任选一个进程作为当前进程
输入该进程的资源请求量Request
调用银行家算法，及安全性算法，完成分配，或并给出提示
该进程的Need向量为0
该进程已运行结束
Need矩阵为0
所有进程运行都结束
结束
N
Y
初始化need矩阵
七．银行家算法程序代码
#include<
stdio.h>
conio.h>
iostream>
usingnamespacestd;
typedefstructMax1//资源的最大需求量
{
intm_a;
intm_b;
intm_c;
}Max;
typedefstructAllocation1//已分配的资源数
inta_a;
inta_b;
inta_c;
}Allocation;
typedefstructNeed1//还需要的资源数
intn_a;
intn_b;
intn_c;
}Need;
structAvailable1//可利用的资源量
intav_a;
intav_b;
intav_c;
}q;
structpr//定义一个结构
charname;
Maxmax;
Allocationallocation;
Needneed;
intfinishflag;
}p[5];
charna[5];
//********************************************
voidinit（）//读入文件"
1.txt"
cout<
<
"
各进程还需要的资源数NEED：
endl;
FILE*fp;
fp=fopen（"
"
r+"
）;
//打开文件"
for（inti=0;
i<
5;
i++）
{
fscanf（fp,"
%c,%d,%d,%d,%d,%d,%d\n"
&
p[i].name,&
p[i].max.m_a,&
p[i].max.m_b,
&
p[i].max.m_c,&
p[i].allocation.a_a,&
p[i].allocation.a_b,&
p[i].allocation.a_c）;
p[i].need.n_a=p[i].max.m_a-p[i].allocation.a_a;
p[i].need.n_b=p[i].max.m_b-p[i].allocation.a_b;
p[i].need.n_c=p[i].max.m_c-p[i].allocation.a_c;
cout<
p[i].name<
:
"
p[i].need.n_a<
p[i].need.n_b<
p[i].need.n_c<
}
fclose（fp）;
//关闭文件
}
//***********************************************
intfenpei（）//分配资源
Available:
;
q.av_a<
q.av_b<
q.av_c<
intfinishcnt=0,k=0,count=0;
for（intj=0;
j<
j++）
p[j].finishflag=0;
while（finishcnt<
5）
for（inti=0;
{
if（p[i].finishflag==0&
&
q.av_a>
=p[i].need.n_a&
q.av_b>
=p[i].need.n_b&
q.av_c>
=p[i].need.n_c）
{
q.av_a+=p[i].allocation.a_a;
q.av_b+=p[i].allocation.a_b;
q.av_c+=p[i].allocation.a_c;
p[i].finishflag=1;
finishcnt++;
na[k++]=p[i].name;
break;
}
}
count++;
//禁止循环过多
if（count>
5）return0;
return1;
//****************************************************
intshq（）//申请资源
intm=0,i=0,j=0,k=0;
//m为进程号;
i,j,k为申请的三类资源数
请输入进程号和请求资源的数目!
如：
进程号资源ABC"
0202"
cin>
>
m>
i>
j>
k;
if（i<
=p[m].need.n_a&
=p[m].need.n_b&
k<
=p[m].need.n_c）
if（i<
=q.av_a&
=q.av_b&
=q.av_c）
p[m].allocation.a_a+=i;
p[m].allocation.a_b+=j;
p[m].allocation.a_c+=k;
p[m].need.n_a=p[m].max.m_a-p[m].allocation.a_a;
p[m].need.n_b=p[m].max.m_b-p[m].allocation.a_b;
p[m].need.n_c=p[m].max.m_c-p[m].allocation.a_c;
cout<
各进程还需要的资源数NEED:
'
\n'
for（intw=0;
w<
w++）
p[w].name<
p[w].need.n_a<
p[w].need.n_b
<
p[w].need.n_c<
return1;
else
Request>
Available让进程"
m<
等待......"
else
Need,让进程"
return0;
voidmain（）
intflag;
charc;
/********银行家算法********/"
确认已经在\"
1.txt\"
文档中正确输入各进程的有关信息后按回车键"
getch（）;
init（）;
q.av_a=10;
//各种资源的数量
q.av_b=5;
q.av_c=7;
while（flag）
q.av_a-=p[i].allocation.a_a;
q.av_b-=p[i].allocation.a_b;
q.av_c-=p[i].allocation.a_c;
if（fenpei（））
这样配置资源是安全的!
其安全序列是：
for（intk=0;
k++）
-->
na[k];
有进程发出Request请求向量吗?
（EnteryorY）"
c=getch（）;
if（c=='
y'
||c=='
Y'
）
if（shq（））continue;
elsebreak;
}
elseflag=0;
else
{flag=0;
不安全!
!
八.测试文件1.txt内容
0,7,5,3,0,1,0
1,3,2,2,2,0,0
2,9,0,2,3,0,2
3,2,2,2,2,1,1
4,4,3,3,0,0,2
九．运行结果
升级会员 