银行家算法.docx

银行家算法.docx

《银行家算法.docx》由会员分享，可在线阅读，更多相关《银行家算法.docx（15页珍藏版）》请在冰豆网上搜索。

银行家算法

衡阳师范学院

《计算机操作系统》

课程设计

题目：

银行家算法

班级：

1001班

学号：

10190103

作者姓名：

付强

指导教师:

王玉奇

2012年11月16日

目录

1、课程设计目的及要求1

2、概要设计1

2．1银行家算法中的数据结构1

2．2银行家算法2

2．3安全性算法2

2．4程序模块3

3、程序流程图4

3．1安全性算法流程图4

3．2银行家算法流程图4

4、代码6

5、用户手册12

5．1运行环境12

5．2执行文件12

6、运行结果12

6.1运行程序后，显示的界面如下：

12

6．2输入多组测试数据后得到的后续运行结果13

7、总结体会15

8、参考文献16

1、课程设计目的及要求

银行家算法：

目的：

了解多道程序系统中，多个进程并发执行的资源分配。

设计要求：

管理员可以把一定数量的作业供多个用户周转使用，为保证作业的安全管理员规定：

当一个用户对作业的最大需求量不超过管理员现有的资金就要接纳该用户；用户可以分期贷款,但贷款的总数不能超过最大需求量；当管理员现有的作业不能满足用户的所需数时,对用户的请求可推迟支付,但总能使用户在有限的时间里得到请求；当用户得到所需的全部作业后,一定能在有限的时间里归还所有的作业。

2、概要设计

2．1银行家算法中的数据结构

（1）可利用资源向量available

这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。

available[j]=k,表示系统中现有Rj类资源k个。

（2）最大需求矩阵max[n][m]

这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。

max[i][j]=k,表示进程i需要Rj类资源的最大数目为k。

（3）分配矩阵allocation[n][m]

这也是一个n×m的矩阵，它定义了系统中每一类资源当前分配给每一进程的资源数，如果allocatioon[i][j]=k，则表示进程i当前已分得Rj类资源的数目为k。

（4）需求矩阵need[n][m]

　　这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。

如果need[i][j]=K，则表示进程i还需要Rj类资源k个，方能完成其任务。

（5）上述三个矩阵间存在下述关系

need[i][j]=max[i][j]-allocation[i][j]

2．2银行家算法

设requesti的进程Pi的请求向量，如果requesti[j]=k；表示进程Pi需要k个Rj类型的资源。

当Pi发出资源请求后，系统按下步骤进行检查：

（1）如果requesti[j]<=need[i][j],便转向步骤

（2）；否则认为出

错，因为它所需的资源数已超过它所宣布的最大值。

（2）如果requesti[j]<=available[j],便转向步骤（3）；否则表示尚无足够资源，Pi需等待

（3）系统试探着把资源分配给进程Pi，并修改下面的数据结构中的数值：

available[j]=available[j]-requesti[j];

allocation[i][j]=allocation[i][j]+requesti[j];

need[i][j]=need[i][j]-requesti[j];

（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。

若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

2．3安全性算法

系统所执行的安全性算法描述如下：

（1）设置两个向量:

工作向量work[m],它表示系统可提供给进程的进行运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，work[i]=available[i];

finish,它表示系统是否有足够的资源分配给进程，使之运行完成。

开始时先做finish[i]=false;当有足够的资源非配给进程时，在令finish[i]=true.

（2）从进程集合中找到一个能满足下述条件的进程：

finish[i]=false；

need[i][j]<=work[j];若找到，执行步骤（3），否则，执行步骤（4）。

（3）当进程Pi获得资源后，可顺序执行，直至完成，并释放出分配给它的资源，故应执行：

work[j]=work[j]+allocation[i][j];

finish[i]=true;

gotostep2;

（4）如果所有的进程的finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

2．4程序模块

如图所示：

main（）主函数包含了四个子函数，分别为screen（）,inputshow（）,safe（）.bank（）。

其中：

screen（）:

显示；

inputshow（）:

输入数据，并排版显示这些数据；

safe（）:

安全性算法，检测系统的安全性。

bank（）:

银行家算法。

3、程序流程图

3．1安全性算法流程图

3．2银行家算法流程图

4、代码

#include

#include

#include

usingnamespacestd;

#defineM3//资源类数

#defineN5//进程数

intavailable[M];//可利用资源向量

intmax[N][M];//各进程所需的最大资源数

intallocation[N][M];//各进程当前分配到得资源数

intneed[N][M];//各进程尚需的各类资源数

intwork[M];//系统可提供给进程继续运行所需的各类资源数目

boolfinish[N];//系统是否有足够的资源分配给进程

intflag[N]={-1};//用于标记安全序列

voidscreen（）;

voidinputshow（）;

intsafe（）;//安全性算法

voidbank（）;//银行家算法

/********************************主函数**************************************/

intmain（）

{

screen（）;

inputshow（）;

safe（）;

bank（）;

return0;

}

/*******************************屏幕显示*************************************/

voidscreen（）

{

printf（"*\t*\n"）;

printf（"*\t*****************银行家算法********************\n"）;

printf（"*\t*\n\n"）;

}

/******************************输入并显示************************************/

voidinputshow（）

{

inti,j;//表示单个的进程或资源

ifstreamin;//文件

in.open（"a.txt"）;

printf（"\t**********从a.txt文档中读取数据*********\n"）;

for（i=0;i>available[i];

in.get（）;

printf（"&系统可利用的各类资源总数\n"）;

printf（"\tA\tB\tC\n"）;

printf（"\t%d\t%d\t%d\n",available[0],available[1],available[2]）;

/*从文档中读入max[N][M]，allocation[N][M]的数据，并计算出need[N][M]*/

for（i=0;i

{

for（j=0;j>max[i][j];

in.get（）;//获得数据

for（j=0;j>allocation[i][j];

in.get（）;

for（j=0;j

{

need[i][j]=max[i][j]-allocation[i][j];

available[j]-=allocation[i][j];

}

}

printf（"\n&资源分配图\n"）;

printf（"\t%-9s\t%-9s\t%-9s\n","MAX","Allocation","Need"）;

printf（"\tABC\tABC\tABC\n"）;

/*输出显示各大数据*/

for（i=0;i

{

printf（"p%d\t%d%4d%4d\t",i,max[i][0],max[i][1],max[i][2]）;

printf（"%d%4d%4d\t",allocation[i][0],allocation[i][1],allocation[i][2]）;

printf（"%d%4d%4d\n",need[i][0],need[i][1],need[i][2]）;

}

printf（"\n&系统可利用资源数:

\n"）;

printf（"\tA\tB\tC\n"）;

printf（"\t%d\t%d\t%d\n\n",available[0],available[1],available[2]）;

}

/******************************银行家算法************************************/

voidbank（）

{

intrequest[M];//进程的请求向量

intpn;//processnumber:

进程号

printf（"\n输入请求资源的进程号（0->4）:

"）;

scanf（"%d",&pn）;

while（pn<0||pn>4）//如果输入错误，则从新输入

{

printf（"输入的号码不对，请重新输入进程号：

"）;

scanf（"%d",&pn）;

}

printf（"输入该进程的请求向量（ABC）:

"）;

for（inti=0;i

if（request[0]>need[pn][0]||request[1]>need[pn][1]||request[2]>need[pn][2]）

printf（"进程p%d申请的资源大于它所需要的资源\n分配不合理，不予分配\n",pn）;

if（request[0]>available[0]||request[1]>available[1]||request[2]>available[2]）

printf（"进程p%d申请的资源大于系统现在可利用的资源\n分配不合理，不予分配\n",pn）;

for（intj=0;j

{

available[j]-=request[j];

allocation[pn][j]+=request[j];

need[pn][j]-=request[j];

}

intbb=safe（）;//调用安全性算法，判断此次资源分配后，系统是否处安全状态

if（1==bb）printf（"已成功分配资源\n\n"）;

else

{

printf（"未成功分配资源并收回预分配资源\n\n"）;

for（i=0;i

{

available[i]=available[i]+request[i];

allocation[pn][i]=allocation[pn][i]-request[i];

need[pn][i]=need[pn][i]+request[i];

}

}

printf（"&系统可利用资源数:

\n"）;

printf（"\tA\tB\tC\n"）;

printf（"\t%d\t%d\t%d\n",available[0],available[1],available[2]）;

printf（"是否请求再次分配?

是请按y,结束请按任意键:

"）;

charenter;

cin>>enter;

if（enter=='y'）bank（）;

}

/******************************安全性算法************************************/

intsafe（）

{

intt=0;//数组标记

for（intj=0;j

for（inti=0;i

for（i=0;i

{

for（j=0;j

{

inttp=（（work[0]>=need[j][0]）&&（work[1]>=need[j][1]）&&（work[2]>=need[j][2]））;

if（!

finish[j]&&tp）

{

finish[j]=true;

for（intk=0;k

flag[t++]=j;//将符合的进程号赋给数组存储

}

}

}

for（i=0;i

{

if（finish[i]==false）

{

printf（"系统处于不安全状态,不存在安全序列\n"）;

return-1;

}

}

printf（"系统处于安全状态\n存在安全序列:

"）;

for（i=0;i

{

printf（"p%d",flag[i]）;

if（i!

=N-1）printf（"-->"）;

}

printf（"\n"）;

return1;

}

5、用户手册

5．1运行环境

（1）　本程序的运行环境为MicrosoftVisualＣ＋＋　６.０　

（2）　进入程序后即显示用户界面。

（3）　用户按程序提示语言操作即可。

（4）　接受输入的数据后，程序自动回输出相应结果。

5．2执行文件

文件夹中.cpp文件或.dsw

6、运行结果

6.1运行程序后，显示的界面如下：

6．2输入多组测试数据后得到的后续运行结果

7、总结体会

银行家算法是由Dijkstra所提出，该算法是避免死锁的一个重要的方法。

通过编写这一个简单的银行家算法程序，加深了解有关资源申请、避免“死锁”等概念，以及更加熟悉了银行家算法，并体会和了解“死锁”和避免“死锁”的具体实施方法。

操作系统的基本特征是并发与共享。

系统允许多个进程并发执行，并且共享系统的软、硬件资源。

为了最大限度的利用计算机系统的资源，操作系统应采用动态分配的策略，但是这样就容易因资源不足，分配不当而引起“死锁”。

而银行家算法能有效的避免“死锁”。

银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁。

此算法的中心思想是：

按该法分配资源时，每次分配后总存在着一个进程，如果让它单独运行下去，必然可以获得它所需要的全部资源，也就是说，它能结束，而它结束后可以释放这类资源以满足其他申请者的需要。

本次程序基本上是按照以上的顺序展开，先是实现输入输出，然后实现safe（）,接着实现bank（）,最后进行排版，修改细节。

程序代码主要c，也有c++。

汲取两种语言的长处。

C语言输入字符串，排版等比c++方便得多，而c++输入数据时也方便的多。

由于本人能力有限，程序也不尽完美，但是有些信息还是能一目了然。

本人再次程序上规定了进程和资源数，动态的也是可以的，只要循环输入输出行了，但可能在排版上有问题。

总之，此次的课程设计让我巩固了语言知识，并学习到了新的算法，学到了很多。

8、参考文献

（1）汤晓丹梁红兵《计算机操作系统》（第三版）西安电子科技大学出版社2007

（2）郑莉董渊《c++语言程序设计》（第四版）清华大学出版社2010

（3）陈向群向勇《Windows操作系统原理》（第二版）机械工业出版社2004