银行家算法模拟程序设计Word文件下载.docx

银行家算法模拟程序设计Word文件下载.docx

《银行家算法模拟程序设计Word文件下载.docx》由会员分享，可在线阅读，更多相关《银行家算法模拟程序设计Word文件下载.docx（17页珍藏版）》请在冰豆网上搜索。

不存在一个安全序列。

不安全状态不一定导致死锁。

　　安全序列：

一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi（1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj（j<

i）当前占有资源量之和。

　　银行家算法：

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。

操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。

当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。

若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

四、算法流程图

1、银行家算法流程图

否

是

否

不安全

安全

2、安全性检查算法流程图

未找到

是不是

找到

五、课程设计之银行家算法原理

1．银行家算法的思路

先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。

若请求合法，则进行试分配。

最后对试分配后的状态调用安全性检查算法进行安全性检查。

若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。

2．银行家算法

进程mi发出请求申请k个j资源，Request[mi][j]=k

（1）Request[mi][j]<

=need[mi][j],检查申请量是否不大于需求量,若条件不符重新输入，不允许申请大于需求量。

（2）Request[mi][j]<

=available[mi][j]，检查申请量是否小于系统中的可利用资源数量,若条件不符就申请失败，阻塞该进程，重新申请资源。

（3）若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：

Available[i]-=Request[mi][i];

Allocation[mi][i]+=Request[mi][i];

Need[mi][i]-=Request[mi][i]

（4）试分配后，执行安全性检查，调用IsSafe（）函数检查此次资源分配后系统是否处于安全状态。

若安全，才正式将资源分配给进程；

否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。

（5）用while循环语句实现输入字符y/n判断是否继续进行资源申请。

3．安全性检查算法（IsSafe（）函数）

（1）设置两个向量：

工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work=Available。

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

开始时先做Finish[i]=0；

当有足够的资源分配给进程时，再令Finish[i]=1。

（2）在进程中查找符合以下条件的进程：

条件1：

Finish[i]=0；

条件2：

need[i][j]<

=Work[j]

若找到，则执行步骤（3）否则，执行步骤（4）

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

Work[j]=Work[j]+Allocation[i][j]；

Finish[i]=1；

（4）如果所有的Finish[i]=1都满足，则表示系统处于安全状态，否则，处于不安全状态

六、源程序结构分析及代码实现

1．程序结构

程序共有以下七个部分：

（1）安全性检查IsSafe（）：

用于判断当前状态安全性，根据不同地方的调用提示处理不同。

（2）初始化算法1Read（）：

用于程序开始进行初始化数据，从文件中读入数据：

进程数量、资源种类、各种资源可利用数量、各进程的各种资源已分配数量、各进程对各类资源最大需求数等。

（3）初始化算法2Input（）：

用于程序开始进行初始化数据，从键盘上输入数据：

（4）Init（）:

进行银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。

（5）Menu（）:

显示菜单。

（6）Design（）：

主界面设计模块。

（7）主函数main（）：

逐个调用初始化、显示状态、安全性检查、银行家算法函数，使程序有序的进行

2．数据结构

银行家算法中用到的主要数据结构：

intAvailable[100]//各种资源可利用的数量

intAllocation[50][100]//各进程当前已分配的资源数量

intMax[50][100]//各进程对各类资源的最大需求数

intNeed[50][100]//需求矩阵

intRequest[50][100]//申请各类资源的数量

intWork[100]//工作向量，表系统可提供给进程运行所需各类资源数量

intFinish[50]//表系统是否有足够的资源分配给进程，0为否，1为是

intp[50];

//存储安全序列

intm，n;

//m为进程的数量,n为资源种类数

3．函数声明

intIsSafe（）;

//安全性检测

voidRead（）;

//从文件读入数据

voidInput（）;

//从键盘输入数据

voidInit（）;

//银行家算法

voidMenu（）;

//菜单

voidDesign（）;

//主界面设计

4.源代码

#include<

iostream.h>

stdio.h>

stdlib.h>

#include<

conio.h>

voidmain（）

{

Design（）;

printf（"

┃请按任意键进行初始化操作...┃\n"

）;

┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n"

>

>

"

getch（）;

system（"

cls"

cout<

<

请输入进程的数目:

"

;

cin>

m;

cout<

请输入资源种类:

n;

Menu（）;

}

intIsSafe（）

{

inti,j,k;

intlen=-1;

///记录安全序列的进程个数，如果len==m，即表示处于安全状态

intWork[100];

for（i=0;

i<

i++）

{

Work[i]=Available[i];

}

Finish[i]=0;

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

else

{

for（j=0;

j<

j++）

{

Need[i][j]=Max[i][j]-Allocation[i][j];

if（Need[i][j]>

Work[j]）break;

if（Need[i][j]<

0）return0;

}

if（j==n）

for（k=0;

k<

k++）Work[k]+=Allocation[i][k];

Finish[i]=1;

len++;

p[len]=i;

i=-1;

elsecontinue;

}

}

if（len==m-1）

系统是安全的\n"

安全序列是:

for（i=0;

=len;

cout<

p[i];

if（i!

=len）cout<

-->

endl;

return1;

elsereturn0;

voidRead（）

inti,j;

FILE*fp;

fp=fopen（"

Max.txt"

"

r+"

从Max.txt文件中读入数据，则每个进程最多需要的各类资源数为:

for（i=0;

i<

i++）

for（j=0;

j<

j++）

fscanf（fp,"

%d"

&

Max[i][j]）;

Max[i][j]<

fclose（fp）;

Allocation.txt"

从Allocation.txt文件中读入数据，则每个进程已分配的各类资源数为:

i++）

Allocation[i][j]）;

Allocation[i][j]<

Need[i][j]=Max[i][j]-Allocation[i][j];

Available.txt"

从Available.txt文件中读入数据，则现有空闲各类资源数为:

fscanf（fp,"

Available[i]）;

Available[i]<

voidInput（）

输入每个进程最多所需的各类资源数，按照"

m<

*"

n<

矩阵输入"

for（j=0;

cin>

Max[i][j];

输入每个进程已分配的各类资源数，按照"

Allocation[i][j];

Need[i][j]=Max[i][j]-Allocation[i][j];

if（Need[i][j]<

0）

{

cout<

你输入的第"

i+1<

个进程的第"

j+1<

个资源数错误，请重新输入"

j--;

continue;

请输入现有未分配的各类资源数目：

cin>

Available[i];

voidInit（）

inti,mi;

charok;

IsSafe（）;

while

（1）//死循环，只要括号里为非零，就一直循环这条句子。

请输入要申请资源的进程号（第一个进程号为0，以此类推）"

mi;

请输入该进程所请求的各类资源的数目:

i++）cin>

Request[mi][i];

while（Request[mi][i]>

Need[mi][i]）

你输入的请求数超过进程的需求数，错误！

break;

while（Request[mi][i]>

Available[i]）

你输入的请求数超过系统的资源数，系统无法满足！

break;

break;

Available[i]-=Request[mi][i];

Allocation[mi][i]+=Request[mi][i];

Need[mi][i]-=Request[mi][i];

if（IsSafe（））cout<

系统成功分配资源！

系统未能成分配资源,收回预分配资源！

for（i=0;

Available[i]+=Request[mi][i];

Allocation[mi][i]-=Request[mi][i];

Need[mi][i]+=Request[mi][i];

i++）Finish[i]=0;

你还想再次请求分配吗？

是请按y/Y,否请按n/N:

while

（1）

ok;

if（ok=='

y'

||ok=='

Y'

n'

N'

）break;

if（ok=='

）continue;

else

system（"

Menu（）;

voidMenu（）

intcode;

***********************\n"

*请选择：

*\n"

*-----------------------------------------*\n"

*1.从文件中读入数据*\n"

*2.从键盘输入数据*\n"

*3.退出*\n"

请选择操作：

\b\b"

scanf（"

&

code）;

do

switch（code）

case1:

Read（）;

Init（）;

case2:

Input（）;

case3:

Design（）;

printf（"

┃谢谢使用银行家算法!

┃\n"

printf（"

exit（0）;

default:

cout<

选择错误！

请重新选择：

code;

getch（）;

}while（code!

=3）;

voidDesign（）

┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n"

┃课题四：

银行家算法┃\n"

┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"

6.运行界面

七、课程设计的总结

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

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

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

而我本次课程设计就是得用银行家算法来避免“死锁”。

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

此算法的中心思想是：

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

本次程序就是按照上面的思路展开的。

但是因为时间上的仓促，本课程设计的存在着以下不足：

一、不能实现并发操作，即当总资源同时满足几个进程所需要的资源数时，这些进程不能同时进行，只能一一按进程顺序执行。

二、扫描进程顺序单一，只能按进程到来的顺序（即编号）来扫描，从而产生的安全顺序只能是在这个顺序的基础上产生的，而其实安全顺序是有多个的。

三、对进程数和资源数进行的数量进行了限制。

四、运行程序后，界面较差，进程数，所需要资源数，已分配资源数，能用资源数，不能一目了然。

这次课程设计时间上虽说仓促点，但是我依然学到了很多的实用性知识。

除了更深的了解这个算法，而且对C语言进行了复习，而且其过程中有很多的知识点都不记得了，所以在此感谢在此过程中帮助过我的老师和同学。

最后的感悟就是：

只要你亲自动手，你就能学到知识。