计算机专业操作系统银行家算法详解Word格式文档下载.docx

计算机专业操作系统银行家算法详解Word格式文档下载.docx

《计算机专业操作系统银行家算法详解Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《计算机专业操作系统银行家算法详解Word格式文档下载.docx（9页珍藏版）》请在冰豆网上搜索。

Available:

ARRAY[1..m]ofinteger;

Max:

ARRAY[1..n,1..m]ofinteger;

Allocation:

Need:

Request:

简记符号：

Available

Max

Allocation

Need

Request

当进程pi提出资源申请时，系统执行下列

步骤：

（1）若Request≤Need,转

（2）；

否则错误返回

（2）若Request≤Available,

转（3）；

否则进程等待

（3）假设系统分配了资源，则有：

=Available-Request;

=

Allocation+Request;

=Need-Request

若系统新状态是安全的，则分配完成

若系统新状态是不安全的，则恢复原状

态，进程等待

为进行安全性检查，定义数据结构：

Work:

Finish:

ARRAY[1..n]ofBoolean;

安全性检查的步骤：

（1）Work:

=Available;

=false;

（2）寻找满足条件的i：

a.Finish=false;

b.Need≤Work;

如果不存在，则转（4）

（3）Work:

=Work+Allocation;

=true;

转

（2）

（4）若对所有i,Finish=true,则系

统处于安全状态，否则处于不安全

状态

/*银行家算法，操作系统概念（OSconceptsSixEdition）

作者：

ctu_85

*/

#include"

malloc.h"

stdio.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;

structallocation*allochead,*alloc1,*alloc2,*alloctemp;

structmax*maxhead,*maxium1,*maxium2,*maxtemp;

structavailable*avahead,*available1,*available2,*availabletemp,*workhead,*work1,*work2,*worktemp,*worktemp1;

structneed*needhead,*need1,*need2,*needtemp;

structfinish*finihead,*finish1,*finish2,*finishtemp;

structpath*pathhead,*path1,*path2,*pathtemp;

charc;

printf（"

\nPleaseenterthetypeofsourcesthesystemhas:

\n"

）;

scanf（"

%d"

&

colum）;

Pleaseenterthenumberofprocessesnowinthememory:

row）;

Pleaseentertheallocationarray:

for（i=0;

i<

row;

i++）

Theallocationforprocessp%d:

i）;

for（j=0;

j<

colum;

j++）

Thetype%csystemresourceallocated:

'

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）

next=alloc2;

alloc1=alloc2;

status=0;

Pleaseenterthemaxarray:

Themaxneededfromprocessp%d:

Thetype%cmaxiumsystemresourcemayneeded:

maxhead=maxium1=maxium2=（structmax*）malloc（maxlen）;

maxium1->

next=maxium2->

maxium2=（structmax*）malloc（maxlen）;

maxium2->

maxhead->

next=maxium2;

maxium1=maxium2;

Pleaseentertheavailablearraynowexistsinthesystem:

Thetype%cavailablesystemresourcenumber:

avahead=available1=available2=（structavailable*）malloc（avalen）;

workhead=work1=work2=（structavailable*）malloc（avalen）;

available1->

next=available2->

work1->

next=work2->

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;

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->

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->

pathhead=path1=path2=（structpath*）malloc（pathlen）;

path1->

next=path2->

value=i;

path2=（structpath*）malloc（pathlen）;

path2->

pathhead->

next=path2;

path1=path2;

finishtemp->

stat=1;

for（t=0;

t<

t++）

needtemp=needtemp->

finishtemp=finishtemp->

value==0）

\nWARNING,thesystemisinnonsafestatus!

exit（0）;

\nThesystemisinsafestatus!

\nThesafesequenceis:

\n"

do

p%d"

pathhead->

while（pathhead=pathhead->

next）;