最详细的操作系统课程设计用银行家算法.docx

最详细的操作系统课程设计用银行家算法.docx

《最详细的操作系统课程设计用银行家算法.docx》由会员分享，可在线阅读，更多相关《最详细的操作系统课程设计用银行家算法.docx（13页珍藏版）》请在冰豆网上搜索。

最详细的操作系统课程设计用银行家算法

实验报告

六、总结

通过本次实验，实现了避免死锁的银行家算法。

银行家算法是通过动态地检测系统中资源分配情况和进程对资源的需求情况，保证至少有一个进程能得到所需要的全部资源，从而能确保系统处于安全状态，才把资源分配给申请者，避免了进程共享资源时系统发生死锁。

银行家算法确实能保证系统时时刻刻都处于安全状态，但它要不断检测每个进程对各类资源的占用和申请情况，需花费较多的时间。

一、实验目的

模拟银行家算法，用银行家算法实现资源分配

二、实验内容

已知进程{P0,P1,P2,P3,P4}，有三类系统资源A、B、C的数量分别为10、5、7，在T0时刻的资源分配情况如下图所示：

（1）若进程P1请求资源，发出请求向量Request1（1，0，2），编写程序用银行家算法判断系统能否将资源分配给它；

（2）若进程P3提出请求Request（1，1，2），用银行家算法程序验证系统能否将资源分配给它。

三、实验环境

软件环境：

VC＋＋

硬件环境：

微机

四、实验步骤

数据结构:

1.可利用资源向量Available

2.最大需求矩阵Max

3.分配矩阵Allocation

4.需求矩阵Need

功能介绍:

模拟实现Dijkstra的银行家算法以避免死锁的出现.分两部分组成:

第一部分:

银行家算法（扫描）

1．如果Request<=Need,则转向2;否则,出错

2．如果Request<=Available,则转向3,否则等待

3．系统试探分配请求的资源给进程

4．系统执行安全性算法

第二部分:

安全性算法

1.设置两个向量

（1）.工作向量:

Work=Available（表示系统可提供给进程继续运行所需要的各类资源数目）

（2）.Finish:

表示系统是否有足够资源分配给进程（True:

有;False:

没有）.初始化为False

2.若Finish[i]=False&&Need<=Work,则执行3;否则执行4（I为资源类别）

3.进程P获得第i类资源,则顺利执行直至完成!

并释放资源:

Work=Work+Allocation;

Finish[i]=true;

转2

4. 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!

五、实验结果

编写代码如下：

#include

#include

#defineM5/*M个进程,N个资源*/

#defineN3

intAVAILABLE[N];/*可用资源数组*/

intMAX[M][N];/*最大需求矩阵*/

intALLOCATION[M][N];/*分配矩阵*/

intNEED[M][N];/*需求矩阵*/

intREQUEST[M][N];/*进程需要资源数*/

boolFINISH[M];/*系统是否有足够的资源分配*/

intp[M];/*记录序列*/

voidInit（）;

boolSafe（）;

voidBanker（）;

voidOutput（）;

voidmain（）

{

Init（）;

Safe（）;

Banker（）;

}

voidInit（）/*初始化算法*/

{

inti,j;

cout<<"请输入每个进程最多所需的各资源数,按照"<

"<

for（i=0;i

for（j=0;j

cin>>MAX[i][j];

cout<<"请输入每个进程已分配的各资源数,按照"<

"<

for（i=0;i

{

for（j=0;j

{

cin>>ALLOCATION[i][j];

NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];

if（NEED[i][j]<0）

{

cout<<"您输入的第"<

"<

j--;

continue;

}

}

}

cout<<"请输入各个资源现有的数目:

"<

for（i=0;i

{

cin>>AVAILABLE[i];

}

}

voidBanker（）/*银行家算法*/

{

inti,pneed;

charflag;

while

（1）

{

cout<<"请输入要申请资源的进程号（注:

第1个进程号为0,依次类推）"<

cin>>pneed;

cout<<"请输入进程所请求的各资源的数量"<

for（i=0;i

{

cin>>REQUEST[pneed][i];

}

for（i=0;i

{

if（REQUEST[pneed][i]>NEED[pneed][i]）

{

cout<<"您输入的对"<

请重新输入!

"<

continue;

}

if（REQUEST[pneed][i]>AVAILABLE[i]）

{

cout<<"您输入的对"<

请重新输入!

"<

continue;

}

}

for（i=0;i

{

AVAILABLE[i]-=REQUEST[pneed][i];

ALLOCATION[pneed][i]+=REQUEST[pneed][i];

NEED[pneed][i]-=REQUEST[pneed][i];

}

if（Safe（））

{

cout<<"同意分配请求!

"<

}

else

{

cout<<"您的请求被拒绝!

"<

for（i=0;i

{

AVAILABLE[i]+=REQUEST[pneed][i];

ALLOCATION[pneed][i]-=REQUEST[pneed][i];

NEED[pneed][i]+=REQUEST[pneed][i];

}

}

for（i=0;i

{

FINISH[i]=false;

}

cout<<"您还想再次请求分配吗?

是请按y/Y,否请按其它键"<

cin>>flag;

if（flag=='y'||flag=='Y'）

{

continue;

}

break;

}

}

voidOutput（）/*输出*/

{

inti,j;

cout<<"资源分配表：

"<

for（i=0;i

{

cout<<"P"<

";

for（j=0;j

cout<

（2）<

cout<<"";

for（j=0;j

cout<

（2）<

cout<<"";

for（j=0;j

cout<

（2）<

cout<<"";

if（i==0）

for（j=0;j

cout<

（2）<

cout<

}

}

boolSafe（）/*安全性算法*/

{

inti,j,k,l=0;

intWork[N];/*工作数组*/

for（i=0;i

Work[i]=AVAILABLE[i];

for（i=0;i

{

FINISH[i]=false;

}

cout<<"安全性：

"<

for（i=0;i

{

if（FINISH[i]==true）

{

continue;

}

else

{

for（j=0;j

{

if（NEED[i][j]>Work[j]）

{

break;

}

}

if（j==N）

{

FINISH[i]=true;

cout<<"P"<

";

for（intz=0;z

cout<

（2）<

cout<<"";

for（z=0;z

cout<

（2）<

cout<<"";

for（z=0;z

cout<

（2）<

cout<<"";

for（k=0;k

{

Work[k]+=ALLOCATION[i][k];

}

for（z=0;z

cout<

（2）<

cout<<"true"<

p[l++]=i;

i=-1;

}

else

{

continue;

}

}

if（l==M）

{

cout<<"系统是安全的!

"<

cout<<"安全序列:

"<

for（i=0;i

{

cout<

if（i!

=l-1）

{

cout<<"->";

}

}

cout<<""<

Output（）;

returntrue;

}

}

cout<<"系统是不安全的!

"<

Output（）;

returnfalse;

}

程序执行结果：