问题补充说明：实验目的，实验环境，实验内容，结果分析与讨论都要有
银行家算法
银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全来自状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安艺富图题系乎距亲阻怕化全状态:不存在一个安全序列。杀首劳被某差我异不安全状态不一定导致死锁。
那么什么是安全布入常练参序列呢？
安全序列：一个进360问答程序列是安全的，如果对于每一前阳答个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj(j<i)当前占有资源量之和。
银行家算法：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向目爱银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大给价十需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没改有超过则再测试系统现存的资源能规院委盐须话护志轴否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
算法：
n：系统中进程的总数
m：资源类总数
Available:ARRAY[1..m]ofinteger;
Max:ARRAY[1..n,1..m]ofintege致酒句错药甚财从r;
Allocation:ARRAY[1..n,1财评坏跑术列..m]ofinteger;
Need:ARRAY[1..n,1..m]ofinteger;
Request:ARRAY[1..n,1..m]ofinteger;
符号说明：
Available可用剩余资源
Max最大需求
All空混术通王出办题含破ocation已分配资源
Need需求资源
R季米草却血左已传京equest请求资源
当进程pi提出资源申请时，系统执行下列
步骤：(“=”为赋值符号，“==”为等号)
step（1）若Request<=Need,gotostep（2）；否则错误返回
step（练厂友2）若Request<=Available,got虽不子排胡制原思耐娘根ostep（3）；否则进程等待
step（3）假设系统分配了资源，则有：
Available=言及部Available-Request;
Allocation=Allocatio亚怎南袁跟线n+Request火场连;
Need=Need-Re微千似十场汽利重古市派quest
若系统新状态是安全的，则分配完成
若系统新状态是不安全的，则恢复原状态，进程等待
为进行安全性检查，定义数据结构：
Work:ARRAY[1..m]ofinteger;
Finish:ARRAY[1..n]ofBoolean;
安全性检查的步骤：
step(1):
Work=Available;
Finish=false;
step(2)寻找满足条件的i：
a.Finish==false;
b.Need<=Work;
如果不存在，gotostep(4)
step(3)
Work=Work+Allocation;
Finish=true;
gotostep(2)
step(4)若对所有i,Finish=true,则系统处于安全状态，否则处于不安全状态
/*银行家算法，操作系统概念(OSconceptsSixEdition)
reeditbyJohnnyhagen，SCAU，runatvc6.0
*/
#include"malloc.h"
#include"stdio.h"
#include"stdlib.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,*workhead,*work1,*work2,*worktemp,*worktemp1;
structneed*needhead,*need1,*need2,*needtemp;
structfinish*finihead,*finish1,*finish2,*finishtemp;
structpath*pathhead,*path1,*path2;
printf("\n请输入系统资源的种类数:");
scanf("%d",&colum);
printf("请输入现时内存中的进程数:");
scanf("%d",&row);
printf("请输入已分配资源矩阵:\n");
for(i=0;i<row;i++)
{
for(j=0;j<colum;j++)
{
printf("请输入已分配给进程p%d的%c种系统资源:",i,'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("请输入最大需求矩阵:\n");
for(i=0;i<row;i++)
{
for(j=0;j<colum;j++)
{
printf("请输入进程p%d种类%c系统资源最大需求:",i,'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("请输入现时系统剩余的资源矩阵:\n");
for(j=0;j<colum;j++)
{
printf("种类%c的系统资源剩余:",'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;i<row;i++)
for(j=0;j<colum;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<row;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<row;temp++)
{
alloctemp=allochead;
needtemp=needhead;
finishtemp=finihead;
worktemp=workhead;
for(i=0;i<row;i++)
{
worktemp1=worktemp;
if(finishtemp->stat==0)
{
for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next)
if(needtemp->value<=worktemp->value)
processtest++;
if(processtest==colum)
{
for(j=0;j<colum;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;t<colum;t++)
alloctemp=alloctemp->next;
finishtemp->stat=0;
}
}
else
for(t=0;t<colum;t++)
{
needtemp=needtemp->next;
alloctemp=alloctemp->next;
}
processtest=0;
worktemp=workhead;
finishtemp=finishtemp->next;
}
}
path2->next=NULL;
finishtemp=finihead;
for(temp=0;temp<row;temp++)
{
if(finishtemp->stat==0)
{
printf("\n系统处于非安全状态!\n");
exit(0);
}
finishtemp=finishtemp->next;
}
printf("\n系统处于安全状态.\n");
printf("\n安全序列为:\n");
do
{
printf("p%d",pathhead->value);
}
while(pathhead=pathhead->next);
printf("\n");
return0;
}
标签：C语言,实验报告,算法
