操作系统实验报告C语言实现银行家算法.docx

操作系统实验报告C语言实现银行家算法.docx

《操作系统实验报告C语言实现银行家算法.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告C语言实现银行家算法.docx（14页珍藏版）》请在冰豆网上搜索。

操作系统实验报告C语言实现银行家算法

实验　报告

题　目

名称

C语言实现银行家算法

主

要

原

理

及

所

参

考

的

资

料

（

包

括

实

验

内

容

及

条

件

）

银行家算法原理：

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

　为保证资金的安全，银行家规定:

（1）　当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;　

（2）顾客可以分期贷款,但贷款的总数不能超过最大需求量;　

　（3）当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;

　　（4）当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.　

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

当进程在执行中继续申请资源时,先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。

若超过则拒绝分配资源,若能满足则按当前的申请量分配资源，否则也要推迟分配。

主

要

算

法

流

程

图

和

具

体

实

验

步

骤

主

要

算

法

流

程

图

和

具

体

实

验

步

骤

实验步骤:

一.银行家算法

进程ｉ发出请求资源申请,

（1）如果Reｑuｅst　[j］＜=need［i，j],转向步骤

（2）,否则认为出错,因为他所需要的资源数已经超过它所宣布的最大值。

（２）如果：

Reｑuesti[j]＜=available[ｉ,ｊ],转向步骤（３）,否则表示尚无足够资源，进程i需等待。

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

Availablｅ[i,ｊ]＝Availablｅ［i,j]-Ｒeqｕest[ｊ];

Ａllocaｔion[i］［j］＝Ａｌlocatｉｏｎ[ｉ][j]+Request[j]；

neｅd[i]［j]=ｎeed[i][j]-Rｅquest[j];

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

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

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

二．安全性检查算法（ｃheck（）函数）

（1）设置两个向量:

工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Worｋ=Avａiｌaｂｌe。

工作向量Ｆｉnish，它表示系统是否有足够的资源分配给进程,使之运行完成。

开始时先做Ｆｉnish[i]=fａlse；当有足够的资源分配给进程时,再令Finish[ｉ]=ｔrue。

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

条件１:

Finisｈ［i]=faｌse;

条件２：

need[ｉ］[j］<=Work［j］

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

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

Work[j]=Wｏrk[ｊ］+Aｌｌoｃatｉon[i][j]；

Finisｈ[i]=ｔruｅ;

goｔｏｓtep

（2）;

（４）如果所有的Finisｈ[i]＝true都满足,则表示系统处于安全状态，否则,处于不安全状态。

安全性算法流程图

程序源代码：

#ｉｎcluｄｅ　

#inclｕdｅ<ｓtdｌib.ｈ>

＃include＜ｃonio.h>

#dｅfinｅm　５０

intno１；//进程数

iｎtｎo2;　／/资源数

intr；

ｉntaｌlocatiｏn[m］[m],need［ｍ][ｍ]，available［ｍ],maｘ[m］[m];

ｃharname1[m],nａme2[m];　　　　　　／／定义全局变量

voidmain（）

｛

voidｃheck（）;

ﻩｖｏｉdｐｒinｔ（）；

ﻩinｔi,ｊ,ｐ＝0,ｑ＝０;

chaｒc;

ﻩintrｅquesｔ［m],ａllocation1[m］[ｍ],nｅｅd１[m][ｍ］,availaｂle1[ｍ］；

pｒintf（"*********＊*＊＊**＊***＊*****＊*****＊****＊****＊＊***\n"）;

ﻩｐrintf（"*　　　银行家算法的设计与实现　　　　*＼n＂）;

printf（"***＊*****＊＊**************＊*＊****＊*＊*＊****＊**＊＊\n"）；

ﻩｐrintf（"请输入进程总数:

\n＂）;

ｓcａnf（＂％d＂,&ｎo１）;

ﻩprintf（＂请输入资源种类数:

\n"）;

scanf（"%d",&ｎo2）;

　prinｔf（＂请输入Ｍａx矩阵：

\n"）;

for（i=0;i

ﻩｆoｒ（j=０;ｊ<ｎo2;ｊ＋＋）

ﻩﻩscanｆ（"%d",&ｍax［i][ｊ]）;　//输入已知进程最大资源需求量

ｐｒiｎtf（＂请输入Allocatｉon矩阵：

\n"）;

ﻩfor（i＝0；i＜no1;i+＋）

ｆor（j＝0;j＜ｎo２;j++）

sｃａnf（"%ｄ",&allｏcａtion[i][ｊ]）;//输入已知的进程已分配的资源数

fｏr（i＝0;i

ﻩﻩfor（j＝0;j

ﻩｎeed［i][j]=ｍax［i]［j]-allocatiｏｎ[i][ｊ］；//根据输入的两个数组计算出ｎeed矩阵的值

prｉntf（"请输入Ａvａｉlable矩阵\n"）;

ﻩfor（ｉ=0;ｉ

ﻩﻩｓcａnf（＂％d"，＆ａｖailaｂｌｅ[i]）;　　　//输入已知的可用资源数

ﻩprint（）;　/／输出已知条件

cheｃｋ（）;/／检测T０时刻已知条件的安全状态

ﻩｉf（r==１）//如果安全则执行以下代码

｛

ﻩﻩdo{　

q=0;

　p=0;

ｐrｉntf（"＼n请输入请求资源的进程号（０～4）:

＼n＂）；

ﻩﻩﻩｆor（j=0；ｊ＜＝1０；j＋+）

ﻩ{

ﻩｓｃanf（＂%d＂，＆i）;

ﻩﻩﻩif（i＞=no1）

ﻩﻩﻩ{

ﻩﻩprintf（＂输入错误，请重新输入：

\n"）；

　cｏnｔinue;　　　

}

ﻩﻩeｌseｂreak；

ﻩﻩ}

ﻩﻩｐriｎtｆ（"\n请输入该进程所请求的资源数requesｔ[ｊ］:

\n＂）;

ﻩﻩfoｒ（j=0;ｊ<ｎo2;ｊ++）

ﻩﻩscanf（"%d＂，＆ｒeqｕesｔ[ｊ］）；

ﻩﻩfor（j=0;j＜ｎo２;j＋+）

ﻩﻩｉｆ（ｒequｅsｔ［ｊ]>nｅｅｄ［i][ｊ]）p=１;　

ﻩﻩ／/判断请求是否超过该进程所需要的资源数

ﻩﻩﻩif（p）

ﻩﻩﻩprｉｎｔf（"请求资源超过该进程资源需求量，请求失败!

\n"）;

ﻩﻩｅｌse

ﻩﻩﻩﻩ{

ﻩﻩﻩﻩﻩfor（j=0;j

ﻩﻩif（requeｓt[j]＞avaｉｌaｂｌe[j]）q=1；

//判断请求是否超过可用资源数

ﻩiｆ（q）

ﻩﻩｐrｉnｔf（"没有做够的资源分配,请求失败!

\ｎ"）；

ﻩﻩelse　　　　　　　　//请求满足条件

ﻩﻩﻩﻩ{

ﻩﻩfｏr（j＝0;j＜no2;j＋＋）

ﻩﻩﻩ{

ﻩﻩﻩﻩａvａｉlable1[ｊ]=avａｉlable[ｊ]；

ﻩﻩﻩﻩﻩallocatiｏn1[i][j]=alｌocatioｎ[i]［ｊ]；

ﻩﻩﻩﻩｎeed1［i][j］=ｎeed[i][ｊ]；　　

ﻩﻩﻩ/／保存原已分配的资源数,仍需要的资源数和可用的资源数

ﻩavaiｌaｂｌe[j]=ａvailable［j]-rｅquｅst［j];　

ﻩﻩaｌlocaｔiｏn[i］[j]+=reqｕesｔ[j];

ﻩﻩﻩneed［i][ｊ]=nｅed[ｉ][ｊ]-request［ｊ]；

　　　　　　　　　//系统尝试把资源分配给请求的进程

ﻩﻩﻩ}

ﻩﻩﻩﻩprint（）;

ﻩﻩcｈeck（）；　/／检测分配后的安全性

ﻩﻩﻩif（r==０）　//如果分配后系统不安全

ﻩ{

ﻩﻩﻩﻩfｏr（j＝0;j

ﻩﻩﻩﻩﻩ{

ﻩﻩﻩﻩﻩavailablｅ[j]＝availabｌe1[j]；　

ﻩ　ａlｌocatioｎ[i][j]=ａllocation1[i］［j];

ﻩﻩﻩﻩﻩneed[i］[j]=nｅｅｄ１[i]［ｊ];

　　／/还原已分配的资源数，仍需要的资源数和可用的资源数

ﻩﻩﻩﻩﻩ｝

ﻩﻩﻩprintｆ（"返回分配前资源数\n"）;

ﻩprｉnt（）;

ﻩﻩ｝

ﻩ}

ﻩﻩ}prinｔf（"＼n你还要继续分配吗?

YorN?

\ｎ＂）；　

ﻩﻩﻩ//判断是否继续进行资源分配

ﻩﻩﻩｃ＝gｅtchｅ（）;

ﻩﻩ}wｈiｌｅ（ｃ=＝'y'||c==＇Y＇）;

}

｝

void　cheｃk（）　//安全算法函数

{

iｎtk,f,v＝0，i,j;

intwork［m]，a[ｍ］;

ｂoｏlｆinｉsh[m];

r＝1;

ﻩfor（i=０;i

ﻩfｉnｉsh[i]=falｓe;　//初始化进程均没得到足够资源数并完成

ﻩｆor（ｉ=０;ｉ＜no２;ｉ+＋）

ﻩｗorｋ［ｉ]=avaiｌable[i］；／/woｒk[i]表示可提供进程继续运行的各类资源数

ﻩk=no1;

dｏ{

ﻩfｏr（ｉ=0；i＜nｏ1;i++）

ﻩﻩ{

ﻩif（ｆinish[i]==false）

ﻩﻩ{

f=１;

ﻩfｏｒ（j=0;j＜no2;j＋+）

ﻩﻩif（ｎeed［i]［j]>wｏｒk［j］）

ﻩﻩf=０;

ﻩif（f=＝１）　　/／找到还没有完成且需求数小于可提供进程继续运行的资源数的进程

ﻩﻩﻩﻩ{

ﻩﻩﻩfinｉｓh[i]=ｔrｕe;

ﻩﻩﻩａ[v++]=i;//记录安全序列号

ﻩﻩﻩﻩｆor（ｊ＝0;ｊ

ﻩﻩwork[j]＋=alｌocation［ｉ]［j];　//释放该进程已分配的资源

ﻩﻩﻩ}

ﻩﻩ}

ﻩ}

ﻩﻩk－-;　/／每完成一个进程分配,未完成的进程数就减1

ﻩ}while（k>0）；

f＝1；

ｆｏｒ（i=０；ｉ

ﻩ{

ﻩif（finiｓh[i]＝=falｓｅ）

ﻩ{

ﻩﻩf=0;

breaｋ;

ﻩﻩ}

ﻩ}

ﻩｉf（f==０）　　//若有进程没完成，则为不安全状态