操作系统原理银行家算法Word文件下载.docx
《操作系统原理银行家算法Word文件下载.docx》由会员分享，可在线阅读，更多相关《操作系统原理银行家算法Word文件下载.docx（13页珍藏版）》请在冰豆网上搜索。
stdio.h"
stdlib.h"
#definealloclensizeof（structallocation）
#definemaxlensizeof（structmax）
#defineavalensizeof（structavailable）
#defineneedlensizeof（structneed）
#definefinilensizeof（structfinish）
#definepathlensizeof（structpath）
structallocation//已分配资源数
{
intvalue;
structallocation*next;
};
structmax//最大需求资源数
structmax*next;
structavailable/*可用资源数*/
structavailable*next;
structneed/*需求资源数*/
structneed*next;
structpath//安全序列
structpath*next;
structfinish
intstat;
structfinish*next;
intmain（）
introw,colum,status=0,i,j,t,temp,processtest;
//row为进程数，colum为资源种类数
structallocation*allochead,*alloc1,*alloc2,*alloctemp;
//已分配资源链表
structmax*maxhead,*maxium1,*maxium2,*maxtemp;
//最大需求资源链表
structavailable*avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1;
structneed*needhead,*need1,*need2,*needtemp;
//需求资源链表
structfinish*finihead,*finish1,*finish2,*finishtemp;
structpath*pathhead,*path1,*path2;
//安全序列
printf（"
\n请输入系统资源的种类数:
"
）;
scanf（"
%d"
&
colum）;
请输入现时内存中的进程数:
row）;
请输入已分配资源矩阵:
\n"
//生成进程已分配资源链表Allocation
for（i=0;
i<
row;
i++）
{
for（j=0;
j<
colum;
j++）
请输入已分配给进程p%d的%c种系统资源:
i,'
A'
+j）;
//如果是第一次，创建头结点
if（status==0）
allochead=alloc1=alloc2=（structallocation*）malloc（alloclen）;
alloc1->
next=alloc2->
next=NULL;
allochead->
value）;
status++;
}
else
alloc2=（structallocation*）malloc（alloclen）;
%d,%d"
alloc2->
if（status==1）
allochead->
next=alloc2;
alloc1=alloc2;
alloc2->
status=0;
请输入最大需求矩阵:
//生成最大需求链表Max
请输入进程p%d种类%c系统资源最大需求:
maxhead=maxium1=maxium2=（structmax*）malloc（maxlen）;
maxium1->
next=maxium2->
maxium1->
maxium2=（structmax*）malloc（maxlen）;
maxium2->
maxhead->
next=maxium2;
maxium1=maxium2;
maxium2->
请输入现时系统剩余的资源矩阵:
//生成剩余资源链表
种类%c的系统资源剩余:
'
avahead=available1=available2=（structavailable*）malloc（avalen）;
workhead=work1=work2=（structavailable*）malloc（avalen）;
available1->
next=available2->
work1->
next=work2->
available1->
value=available1->
value;
available2=（structavailable*）malloc（avalen）;
work2=（structavailable*）malloc（avalen）;
available2->
work2->
value=available2->
avahead->
next=available2;
workhead->
next=work2;
available1=available2;
work1=work2;
available2->
alloctemp=allochead;
maxtemp=maxhead;
//生成进程需求资源数链表
needhead=need1=need2=（structneed*）malloc（needlen）;
need1->
next=need2->
value=maxtemp->
value-alloctemp->
need2=（structneed*）malloc（needlen）;
need2->
value=（maxtemp->
value）-（alloctemp->
needhead->
next=need2;
need1=need2;
maxtemp=maxtemp->
next;
alloctemp=alloctemp->
//初始化finsh默认值finsh=false
finihead=finish1=finish2=（structfinish*）malloc（finilen）;
finish1->
next=finish2->
stat=0;
finish2=（structfinish*）malloc（finilen）;
finish2->
finihead->
next=finish2;
finish1=finish2;
/*Initializationcompleated*/
processtest=0;
for（temp=0;
temp<
temp++）
needtemp=needhead;
finishtemp=finihead;
worktemp=workhead;
worktemp1=worktemp;
if（finishtemp->
stat==0）
//检测是否满足分配资源条件
for（j=0;
j++,needtemp=needtemp->
next,worktemp=worktemp->
next）
if（needtemp->
value<
=worktemp->
value）
processtest++;
if（processtest==colum）
//分配资源
worktemp1->
value+=alloctemp->
worktemp1=worktemp1->
if（status==0）//记录安全序列
pathhead=path1=path2=（structpath*）malloc（pathlen）;
path1->
next=path2->
value=i;
path2=（structpath*）malloc（pathlen）;
path2->
pathhead->
next=path2;
path1=path2;
finishtemp->
stat=1;
//恢复finish＝false状态
for（t=0;
t<
t++）
else//安全性检测失败
needtemp=needtemp->
finishtemp=finishtemp->
\n系统处于非安全状态!
exit（0）;
\n系统处于安全状态.\n"
\n安全序列为:
\n"
do{
p%d"
pathhead->
while（pathhead=pathhead->
next）;
return0;
}
实验过程与结果
使用如下表格数据进行测试:
Allocation
Max
Available
ABC
P0
003
004
140
P1
100
175
P2
135
235
P3
002
064
P4
001
065
先列出Need表
Need
075
062
过程分析：
当前系统中可用资源数为1，4，0，只能满足进程P2，所以P2获得资源，执行，释放资源，可用资源变为2，7，5；
此时可满足P1，P2，P3，P4，假定P1获得资源，执行，释放资源，可用资源变为3，7，5；
此时可满足P0，P3，P4，假定P0获得资源，执行，释放资源，可用资源变为3，7，8；
此时可满足P3，P4，假定P3获得资源，执行，释放资源，可用资源变为3，7，10；
最后P4运行。
代码运行如下:
假定可用资源Available为0，6，2.，
可满足P3的需求，执行完毕后，可用资源为0，6，4；
P4可执行，完毕后，可用资源为0，6，5；
P0可执行，完毕后，可用资源为0，6，8，无法满足其他进程要求，此时系统处于非安全状态。
重新输入参数，可得执行结果如下图：
心得体会
在实验的时候，我参考了其他银行家算法的实现，发觉他们的实现比较简单，而本实验提供的代码使用了指针，看起来比较复杂，但是灵活很多，功能也更强。
多个进程同时运行时，系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列，使得系统能快速且安全地运行进程，不至发生死锁。
银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我们来学习借鉴。
升级会员 