死锁避免算法模拟实验银行家算法.docx

死锁避免算法模拟实验银行家算法.docx

《死锁避免算法模拟实验银行家算法.docx》由会员分享，可在线阅读，更多相关《死锁避免算法模拟实验银行家算法.docx（9页珍藏版）》请在冰豆网上搜索。

死锁避免算法模拟实验银行家算法

操作系统实验报告

死锁避免算法的模拟实验

——银行家算法

班级：

2013级软件工程1班

学号：

XXX

姓名：

萧氏一郎

数据结构说明 ：

①可利用资源向量available,n个元素的数组,每个元素代表一类可用资源的数目,available[i]=k，表示系统中有Rj类资源k个。

②最大需求矩阵MAX,n3m矩阵定义n个进程时,m类资源的最大

需求max（i,j）=k表示进程需要Rj类资源最大数目为k。

③分配矩阵allocation,n3m矩阵,表示n个进程的每个进程已分配资源情况,alloction（i,j）=k表示进程i已分配Rj类资源k个。

④需求矩阵need,n3m矩阵,表示各进程仍需要各类资源,need

（i,j）=k表示进程i仍需要资源Rj的数目为k.由上述分析可知needi=maxi-allocationi。

Yes

Yes

Yes

No

NO

流程图：

源代码：

#include

intIsprocessallover（）;//判断系统中的进程是否全部运行完毕

voidSystemstatus（）;//显示当前系统中的资源及进程情况

voidAllow（int,int*）;//若进程申请不导致死锁，用此函数分配资源

voidForbidenseason（int）;//若发生死锁，则显示原因

intBanker（int,int*）;//银行家算法

intAvailiable[5]={5,6,6,5,4};//初始状态，系统可用资源量

intMax[5][5]={{1,2,3,2,3},{3,2,2,3,3},{7,0,2,3,3},{2,2,2,2,3},{4,3,3,1,3}};//各进程对各资源的最大需求量

intAllocation[5][5]={{0,1,0,0,1},{2,0,0,1,1},{3,0,2,0,1},{2,1,1,0,1},{0,0,2,0,1},};//初始状态，各进程占有资源量

intNeed[5][5]={{1,1,3,2,2},{1,2,2,2,2},{4,0,0,3,2},{0,1,1,2,2},{4,3,1,1,2},};//初始状态时，各进程运行完毕，还需要的资源量

intover[5]={0,0,0,0,0};//标记对应进程是否得到所有资源并运行完毕

intmain（）

{

inti,j,k;

intprocess=0;//发出请求的进程

intdecide=0;//银行家算法的返回值

intRequest[5]={0,0,0,0,0};//申请的资源量数组

intsourcenum=0;//申请的各资源量

/*判断系统中进程是否全部运行完毕*/

step1:

if（Isprocessallover（）==1）

{

puts（"系统中全部进程运行完毕！

"）;

return0;

}

/*显示系统当前状态*/

Systemstatus（）;

/*人机交互界面*/

step2:

printf（"输入发出请求的进程（输入“0”退出系统）:

"）;

scanf（"%d",&process）;

if（process==0）

{

printf（"放弃申请，退出系统！

"）;

return0;

}

if（process<1||process>5||over[process-1]==1）

{

puts（"系统无此进程!

"）;

gotostep2;

}

puts（"此进程申请各资源（A,B,C,D,E）数目：

"）;

for（i=0;i<5;i++）

{

printf（"%c资源:

",65+i）;

scanf（"%d",&sourcenum）;

Request[i]=sourcenum;

}

/*用银行家算法判断是否能够进行分配*/

decide=Banker（process,Request）;

if（decide==0）

{

/*将此进程申请资源分配给它*/

Allow（process,Request）;

gotostep1;

}

else

{

/*不能分配，显示原因*/

Forbidenseason（decide）;

gotostep2;

}

return0;

}

intIsprocessallover（）

{

inti,j;

intprocessnum=0;

for（i=0;i<6;i++）

{

//判断每个进程是否运行完毕

if（over[i]==1）processnum++;

}

if（processnum==5）return1;//系统中全部进程运行完毕

return0;

}

voidSystemstatus（）

{

inti,j;

puts（"此刻系统中存在的进程:

"）;

for（i=0;i<5;i++）

if（over[i]!

=1）printf（"P%d",i+1）;

puts（""）;

puts（"此刻系统可利用资源（单位：

个）:

"）;

puts（"ABCDE"）;

for（i=0;i<5;i++）printf（"%d",Availiable[i]）;

puts（""）;

puts（"此刻各进程已占有资源如下（单位：

个）:

"）;

puts（"ABCDE"）;

for（i=0;i<5;i++）

{

if（over[i]==1）continue;

printf（"P%d",i+1）;

for（j=0;j<5;j++）printf（"%d",Allocation[i][j]）;

puts（""）;

}

puts（"各进程运行完毕还需各资源如下（单位：

个）:

"）;

puts（"ABCDE"）;

for（i=0;i<6;i++）

{

if（over[i]==1）continue;

printf（"P%d",i+1）;

for（j=0;j<5;j++）printf（"%d",Need[i][j]）;

puts（""）;

}

}

intBanker（intp,int*R）

{

inti,j,m,n;

intnum=0;

intFinish[5]={0,0,0,0,0};

intwork[5]={0,0,0,0,0};

intAvailiableTest[5];

intAllocationTest[5][5];

intNeedTest[5][5];

/*判断申请的资源是否大于系统可提供的资源总量*/

for（i=0;i<5;i++）

{

if（*（R+i）>Availiable[i]）return1;

}

/*判断该进程申请资源量是否大于初始时其申明的需求量*/

for（i=0;i<5;i++）

{

if（*（R+i）>Need[p-1][i]）return2;

}

/*为检查分配的各数据结构赋初值*/

for（i=0;i<5;i++）

AvailiableTest[i]=Availiable[i];

for（i=0;i<6;i++）

for（j=0;j<5;j++）

AllocationTest[i][j]=Allocation[j][i];

for（i=0;i<6;i++）

for（j=0;j<5;j++）

NeedTest[i][j]=Need[j][i];

/*进行试分配*/

for（i=0;i<5;i++）

{

AvailiableTest[i]-=*（R+i）;

AllocationTest[p-1][i]+=*（R+i）;

NeedTest[p-1][i]-=*（R+i）;

}

/*检测进程申请得到满足后，系统是否处于安全状态*/

for（i=0;i<5;i++）

work[i]=AvailiableTest[i];

for（m=1;m<=6;m++）

{

for（n=0;n<6;n++）

{

num=0;

/*寻找用此刻系统中没有运行完的进程*/

if（Finish[n]==0&&over[n]!

=1）

{

for（i=0;i<4;i++）

if（NeedTest[n][i]<=work[i]）

num++;

if（num==4）

{

for（i=0;i<4;i++）

work[i]=work[i]+AllocationTest[n][i];

Finish[n]=1;

}

}

}

}

for（i=0;i<6;i++）

if（Finish[i]==0&&over[i]!

=1）

return3;

return0;

}

voidAllow（intp,int*R）

{

inti,j;

puts（"可以满足申请！

"）;//可以满足申请！

staticintovernum;

/*对进程所需的资源进行分配*/

for（i=0;i<5;i++）

{

Availiable[i]=Availiable[i]-*（R+i）;

Allocation[p-1][i]=Allocation[p-1][i]+*（R+i）;

Need[p-1][i]=Need[p-1][i]-*（R+i）;

}

/*分配后判断其是否运行完毕*/

overnum=0;

for（i=0;i<5;i++）

if（Need[p-1][i]==0）overnum++;

if（overnum==5）

{

/*此进程运行完毕，释放其占有的全部资源*/

for（i=0;i<5;i++）

Availiable[i]=Availiable[i]+Allocation[p-1][i];

/*标记该进程运行完毕*/

over[p-1]=1;

printf（"进程P%d所需资源全部满足，此进程运行完毕！

\n"）;

}

}

voidForbidenseason（intd）

{

puts（"不能满足申请，此进程挂起，原因为:

"）;

switch（d）

{

case1:

puts（"申请的资源量大于系统可提供的资源量!

"）;break;

case2:

puts（"申请的资源中有某种资源大于其声明的需求量!

"）;break;

case3:

puts（"若满足申请，系统将进入不安全状态，可能导致死锁!

"）;

}

}