银行家算法1文档格式.docx

银行家算法1文档格式.docx

《银行家算法1文档格式.docx》由会员分享，可在线阅读，更多相关《银行家算法1文档格式.docx（14页珍藏版）》请在冰点文库上搜索。

　　Request

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

　　步骤：

（1）若Request≤Need,转

（2）；

　　否则错误返回

（2）若Request≤Available,

　　转（3）；

否则进程等待

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

=Available-Request;

=

　　Allocation+Request;

=Need-Request

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

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

　　态，进程等待

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

　　Work:

ARRAY【1..m】ofinteger;

　　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）

　　allochead->

next=alloc2;

　　alloc1=alloc2;

　　alloc2->

　　status=0;

Pleaseenterthemaxarray:

Themaxneededfromprocessp%d:

Thetype%cmaxiumsystemresourcemayneeded:

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

　　maxium1->

next=maxium2->

maxium1->

　　maxium2=（structmax*）malloc（maxlen）;

maxium2->

　　maxhead->

next=maxium2;

　　maxium1=maxium2;

　　maxium2->

Pleaseentertheavailablearraynowexistsinthesystem:

Thetype%cavailablesystemresourcenumber:

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

　　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:

　　do

p%d"

pathhead->

　　while（pathhead=pathhead->

next）;