银行家算法：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
算法：
n：
系统中进程的总数
m：
资源类总数
Available:
ARRAY[1..m]ofinteger;
Max:
ARRAY[1..n,1..m]ofinteger;
Allocation:
ARRAY[1..n,1..m]ofinteger;
Need:
ARRAY[1..n,1..m]ofinteger;
Request:
ARRAY[1..n,1..m]ofinteger;
简记符号：
Available
Max
Allocation
Need
Request
当进程pi提出资源申请时，系统执行下列
步骤：
（1）若Request≤Need,转
（2）；
否则错误返回
（2）若Request≤Available,
转（3）；否则进程等待
（3）假设系统分配了资源，则有：
Available:
=Available-Request;
Allocation:
=
Allocation+Request;
Need:
=Need-Request
若系统新状态是安全的，则分配完成
若系统新状态是不安全的，则恢复原状
态，进程等待
为进行安全性检查，定义数据结构：
Work:
ARRAY[1..m]ofinteger;
Finish:
ARRAY[1..n]ofBoolean;
安全性检查的步骤：
（1）Work:
=Available;
Finish:
=false;
（2）寻找满足条件的i：
a.Finish=false;
b.Need≤Work;
如果不存在，则转（4）
（3）Work:
=Work+Allocation;
Finish:
=true;
转
（2）
（4）若对所有i,Finish=true,则系
统处于安全状态，否则处于不安全
状态
/*银行家算法，操作系统概念（OSconceptsSixEdition）
作者：
ctu_85
*/
#include"malloc.h"
#include"stdio.h"
#definealloclensizeof（structallocation）
#definemaxlensizeof（structmax）
#defineavalensizeof（structavailable）
#defineneedlensizeof（structneed）
#definefinilensizeof（structfinish）
#definepathlensizeof（structpath）
structallocation
{
intvalue;
structallocation*next;
};
structmax
{
intvalue;
structmax*next;
};
structavailable
{
intvalue;
structavailable*next;
};
structneed
{
intvalue;
structneed*next;
};
structpath
{
intvalue;
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）;
printf（"Pleaseenterthenumberofprocessesnowinthememory:
\n"）;
scanf（"%d",&row）;
printf（"Pleaseentertheallocationarray:
\n"）;
for（i=0;i{
printf（"Theallocationforprocessp%d:
\n",i）;
for（j=0;j{
printf（"Thetype%csystemresourceallocated:
\n",'A'+j）;
if（status==0）
{
allochead=alloc1=alloc2=（structallocation*）malloc（alloclen）;
alloc1->next=alloc2->next=NULL;
scanf（"%d",&allochead->value）;
status++;
}
else
{
alloc2=（structallocation*）malloc（alloclen）;
scanf（"%d,%d",&alloc2->value）;
if（status==1）
{
allochead->next=alloc2;
status++;
}
alloc1->next=alloc2;
alloc1=alloc2;
}
}
}
alloc2->next=NULL;
status=0;
printf（"Pleaseenterthemaxarray:
\n"）;
for（i=0;i{
printf（"Themaxneededfromprocessp%d:
\n",i）;
for（j=0;j{
printf（"Thetype%cmaxiumsystemresourcemayneeded:
\n",'A'+j）;
if（status==0）
{
maxhead=maxium1=maxium2=（structmax*）malloc（maxlen）;
maxium1->next=maxium2->next=NULL;
scanf（"%d",&maxium1->value）;
status++;
}
else
{
maxium2=（structmax*）malloc（maxlen）;
scanf（"%d,%d",&maxium2->value）;
if（status==1）
{
maxhead->next=maxium2;
status++;
}
maxium1->next=maxium2;
maxium1=maxium2;
}
}
}
maxium2->next=NULL;
status=0;
printf（"Pleaseentertheavailablearraynowexistsinthesystem:
\n"）;
for（j=0;j{
printf（"Thetype%cavailablesystemresourcenumber:
\n",'A'+j）;
if（status==0）
{
avahead=available1=available2=（structavailable*）malloc（avalen）;
workhead=work1=work2=（structavailable*）malloc（avalen）;
available1->next=available2->next=NULL;
work1->next=work2->next=NULL;
scanf（"%d",&available1->value）;
work1->value=available1->value;
status++;
}
else
{
available2=（structavailable*）malloc（avalen）;
work2=（structavailable*）malloc（avalen）;
scanf（"%d,%d",&available2->value）;
work2->value=available2->value;
if（status==1）
{
avahead->next=available2;
workhead->next=work2;
status++;
}
available1->next=available2;
available1=available2;
work1->next=work2;
work1=work2;
}
}
available2->next=NULL;
work2->next=NULL;
status=0;
alloctemp=allochead;
maxtemp=maxhead;
for（i=0;ifor（j=0;j{
if（status==0）
{
needhead=need1=need2=（structneed*）malloc（needlen）;
need1->next=need2->next=NULL;
need1->value=maxtemp->value-alloctemp->value;
status++;
}
else
{
need2=（structneed*）malloc（needlen）;
need2->value=（maxtemp->value）-（alloctemp->value）;
if（status==1）
{
needhead->next=need2;
status++;
}
need1->next=need2;
need1=need2;
}
maxtemp=maxtemp->next;
alloctemp=alloctemp->next;
}
need2->next=NULL;
status=0;
for（i=0;i{
if（status==0）
{
finihead=finish1=finish2=（structfinish*）malloc（finilen）;
finish1->next=finish2->next=NULL;
finish1->stat=0;
status++;
}
else
{
finish2=（structfinish*）malloc（finilen）;
finish2->stat=0;
if（status==1）
{
finihead->next=finish2;
status++;
}
finish1->next=finish2;
finish1=finish2;
}
}
finish2->next=NULL;/*Initializationcompleated*/
status=0;
processtest=0;
for（temp=0;temp{
alloctemp=allochead;
needtemp=needhead;
finishtemp=finihead;
worktemp=workhead;
for（i=0;i{
worktemp1=worktemp;
if（finishtemp->stat==0）
{
for（j=0;jnext,worktemp=worktemp->next）
if（needtemp->value<=worktemp->value）
processtest++;
if（processtest==colum）
{
for（j=0;j{
worktemp1->value+=alloctemp->value;
worktemp1=worktemp1->next;
alloctemp=alloctemp->next;
}
if（status==0）
{
pathhead=path1=path2=（structpath*）malloc（pathlen）;
path1->next=path2->next=NULL;
path1->value=i;
status++;
}
else
{
path2=（structpath*）malloc（pathlen）;
path2->value=i;
if（status==1）
{
pathhead->next=path2;
status++;
}
path1->next=path2;
path1=path2;
}
finishtemp->stat=1;
}
else
{
for（t=0;talloctemp=alloctemp->next;
finishtemp->stat=0;
}
}
else
for（t=0;t{
needtemp=needtemp->next;
alloctemp=alloctemp->next;
}
processtest=0;
worktemp=workhead;
finishtemp=finishtemp->next;
}
}
path2->next=NULL;
finishtemp=finihead;
for（temp=0;temp{
if（finishtemp->value==0）
{
printf（"\nWARNING,thesystemisinnonsafestatus!
\n"）;
exit（0）;
}
finishtemp=finishtemp->next;
}
printf（"\nThesystemisinsafestatus!
\n"）;
printf（"\nThesafesequenceis:
\n"）;
do
{
printf（"p%d",pathhead->value）;
}
while（pathhead=pathhead->next）;
}
升级会员 