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

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

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

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

实验报　告

题　目

名称

C语言实现银行家算法

主

要

原

理

及

所

参

考

的

资

料

（

包

括

实

验

内

容

及

条

件

）

银行家算法原理:

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

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

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

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

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

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

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

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

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

主

要

算

法

流

程

图

和

具

体

实

验

步

骤

主

要

算

法

流

程

图

和

具

体

实

验

步

骤

实验步骤：

一.银行家算法

进程i发出请求资源申请，　

（１）如果Reqｕｅｓｔ[j］<＝neｅd[i，j],转向步骤

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

（2）如果：

Requesti[j]<=availaｂle[i,j],转向步骤（3）,否则表示尚无足够资源,进程i需等待。

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

Aｖａilａble[i,j]＝Available[i,ｊ]-Ｒｅqueｓt[j];

Allocatｉｏn[i]［j］=　Ａｌlocatｉon［i][ｊ]+Rｅquｅｓt　[j];

neｅd[i][ｊ]=need[i］[ｊ]-Rｅqｕest［ｊ];

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

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

（5）用dｏ｛…｝wｈｉle循环语句实现输入字符ｙ/n判断是否继续进行资源申请。

二．安全性检查算法（cｈｅck（）函数）

（１）设置两个向量：

工作向量Wｏrk,它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时,Ｗork=Aｖaiｌabｌe。

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

开始时先做Ｆｉｎish[i]=fａlse;当有足够的资源分配给进程时，再令Fｉniｓh[i]=ｔruｅ。

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

条件1:

Finisｈ［i]=false；

条件２:

ｎｅｅｄ[i]［ｊ]<=Woｒk[j]

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

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

Work［j]=Work[ｊ］+　Allocatioｎ[i］[j];

Finiｓh［i]＝truｅ；

ｇotｏstｅp　

（2）；

（４）如果所有的Ｆinｉsh［i]=true都满足，则表示系统处于安全状态，否则，处于不安全状态。

安全性算法流程图

程序源代码:

#ｉｎclude

＃include

＃inｃludｅ＜coniｏ.h>

＃ｄｅfineｍ50

intnｏ1；／/进程数

iｎｔ　nｏ2;　/／资源数

iｎt　ｒ;

intallocａtion[m]［m］,neｅd[m][m],available[m],max［m][m];　

chaｒname1[m],naｍe２[m];　　　　　　　　　/／定义全局变量

vｏｉdmain（）

｛

ﻩｖoid　ｃｈeck（）;

voidprinｔ（）;

ﻩｉntｉ，j,p＝0,q＝0;

ﻩchaｒｃ；

intrequest[m],aｌｌocation1［ｍ][m]，ｎeｅd1［m][m]，aｖaｉlable１[m];

ｐriｎtf（"**＊＊＊＊***＊＊**＊*＊**＊＊*****＊＊***＊＊**＊**＊******＊*\ｎ"）;

ﻩｐｒintf（"*　　　银行家算法的设计与实现　　　　　*\n＂）；

prinｔf（"*****************＊***＊＊＊****＊******＊*＊*＊＊**＊＊＊＼n＂）;

prinｔf（＂请输入进程总数:

\n"）;

scaｎf（＂%d＂,&no1）;

ﻩprｉntf（"请输入资源种类数:

\n"）;

scａnf（"%d"，&no２）;

　priｎｔｆ（"请输入Max矩阵：

＼n"）;

fｏr（i=０;ｉ＜ｎｏ1;i＋+）

for（j＝0;j＜no２;ｊ++）

ﻩﻩscａnf（"%d",&max[i]［ｊ]）；　／／输入已知进程最大资源需求量

ｐrintf（＂请输入Allocａｔion矩阵:

\ｎ"）;

ﻩfor（i=0;i

ﻩﻩfoｒ（j=０;j

ﻩscａｎｆ（＂%d",&allocatiｏn[i][j]）；　//输入已知的进程已分配的资源数

foｒ（ｉ=０；i

ﻩfｏｒ（j=0；j<ｎo2；ｊ++）

ﻩﻩﻩneｅd［i]［j]=max[i][j]-allｏcation[i］[j];//根据输入的两个数组计算出need矩阵的值

pｒintf（"请输入Aｖailabｌe矩阵＼n"）;

ﻩfor（i=0;ｉ＜no2;i++）

scａnｆ（＂%d"，&availaｂｌe[ｉ]）；　　/／输入已知的可用资源数

ﻩ

ﻩprｉnt（）；　　／/输出已知条件

check（）;/／检测Ｔ0时刻已知条件的安全状态

ﻩiｆ（r＝＝1）／/如果安全则执行以下代码

ﻩ{

ﻩﻩdo{

q＝0;

　　p=０;

ｐｒintf（"\n请输入请求资源的进程号（0~4）:

＼n"）;

ﻩﻩfｏr（j＝0;j<=１０;j++）

{

ﻩﻩﻩｓcanｆ（"%d＂，&i）;

ﻩﻩｉf（i>=ｎo1）

ﻩ{

ﻩﻩﻩprintf（"输入错误，请重新输入:

＼n"）;

ﻩﻩﻩ　　cｏnｔinuｅ;　

ﻩﻩ}

ﻩﻩﻩﻩelｓebreａk；

ﻩ}

ﻩｐrｉｎtｆ（＂\n请输入该进程所请求的资源数request[j］:

\n＂）;

ﻩfoｒ（j=0;j<ｎｏ2;ｊ＋+）

ﻩﻩsｃanf（"%ｄ"，＆ｒequｅｓt[j]）；

ﻩﻩﻩfor（j＝0;j＜no2;j++）

ﻩﻩｉｆ（reqｕeｓｔ[j]>nｅｅd[i][ｊ]）　p=1；

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

ﻩﻩﻩiｆ（ｐ）

ﻩﻩﻩﻩprintf（＂请求资源超过该进程资源需求量，请求失败！

＼ｎ"）;

ﻩﻩelse

ﻩﻩﻩ｛

ﻩﻩﻩﻩｆoｒ（j＝0;j

ﻩﻩif（ｒequest［j]＞avａilable[j]）　ｑ=1;

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

ﻩﻩiｆ（ｑ）

ﻩﻩﻩprｉntf（＂没有做够的资源分配，请求失败！

\ｎ"）；

elｓｅ　　　　　／/请求满足条件

ﻩﻩ{

ﻩﻩﻩｆｏr（j=0；ｊ＜no2;j+＋）　

ﻩﻩﻩ｛

ﻩﻩaｖailable1[j］＝avaｉｌａble[j]；　

ﻩalｌocａtion1［ｉ][j]=ａllｏｃation[i][ｊ］;

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

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

ﻩﻩﻩﻩavaiｌable[j］=availabｌe[j]-requｅst［j］;　

ﻩﻩallｏcatｉon[i][ｊ]＋=reqｕest[j]；

ﻩﻩneed[i][j]=nｅed［ｉ］[j]-ｒeｑｕest[j];

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

}

ﻩﻩﻩｐriｎt（）;

ﻩﻩﻩｃheck（）;　//检测分配后的安全性

ﻩﻩﻩiｆ（r==0）　/／如果分配后系统不安全

ﻩﻩ{

ﻩﻩﻩfor（j=0;j

ﻩﻩﻩﻩﻩ{

ﻩﻩﻩﻩﻩａvaｉlabｌｅ[j]=avａilable１[j];　

ﻩﻩﻩ　　ａｌｌｏｃation［i][j］=allocaｔiｏn１[i］[j];

ﻩﻩﻩﻩﻩ　　ｎｅeｄ[i]［j]＝nｅed1[i][j];

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

ﻩﻩﻩﻩﻩﻩ}

ﻩﻩﻩﻩprinｔf（"返回分配前资源数\n"）;

ﻩﻩprinｔ（）;

ﻩﻩﻩﻩﻩ}

ﻩﻩ}

ﻩﻩ}priｎtｆ（"\n你还要继续分配吗?

Ｙ　orN?

\n"）；

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

ﻩﻩﻩﻩｃ=ｇetchｅ（）;

ﻩﻩ}while（c=＝'y'|｜c=='Y'）；

ﻩ}

}

void　cｈeck（）　//安全算法函数

{

inｔ　k,f,v=0,i,j;

ﻩinｔwｏrk［ｍ］，a[m］;

ﻩboｏlfinish[m］;

ﻩr=1;

fｏr（i＝０;i＜ｎo1;i++）

ﻩｆinisｈ[i］=faｌse;/／初始化进程均没得到足够资源数并完成

for（i＝0;i<ｎo2;i＋＋）

ｗork[i]＝ａｖaｉｌabｌｅ[i];//wｏrk[i］表示可提供进程继续运行的各类资源数

ﻩｋ＝no1;

ﻩdｏ{

ﻩfor（i=0；i

{

ﻩif（finish[ｉ]＝=false）

ﻩ{

ﻩﻩf=1；

ﻩﻩﻩﻩfｏr（j=0;ｊ

ﻩﻩﻩif（nｅed[i][ｊ］>work[j]）

ﻩﻩﻩf=0;

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

ﻩ{

ﻩﻩﻩfinish[i]＝true;

ﻩﻩａ[ｖ++］=i；　　//记录安全序列号

ﻩﻩﻩﻩﻩfｏr（j=０;ｊ＜ｎｏ２;j＋+）

ﻩﻩﻩﻩwｏrk[j］＋=allocation[i][j];　／／释放该进程已分配的资源

ﻩﻩ}

ﻩﻩ}

ﻩ}

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

ﻩ}ｗhiｌe（k>０）;

ﻩf=1;

foｒ（ｉ=0;i<ｎo1；ｉ＋＋）　//判断是否所有的进程都完成

ﻩ{

if（finiｓh［i］==falsｅ）

ﻩ{

f=0;

ﻩbreak;

ﻩ}

}

if（ｆ=＝0）　/／若有进程没完成，则为不安全状态

ﻩ{

ﻩprintf（"系统处在不安全状态!

＂）;

ﻩr＝0;

ﻩ}

ﻩelsｅ

ﻩ｛

ﻩprintf（＂＼n系统当前为安全状态,安全序列为:

\n"）;

ﻩﻩfor（i＝０;i

ﻩprｉntf（"p%d　",ａ[i]）;　／/输出安全序列

ﻩ｝

}

voiｄprint（）/／输出函数

{

intｉ,j;

pｒinｔf（"\n"）;

priｎtf（＂**＊**********此时刻资源分配情况＊*****＊＊＊************\n"）;

ﻩprintf（＂进程名／号|　Max　　|Ａlｌocation　｜　　　Need　｜\n"）；

foｒ　（i=０;i　<ｎo1;　ｉ+＋）

{

ﻩｐrintf（"　　p%ｄ／%d　"，i，ｉ）；

　　　ﻩｆｏr（ｊ=0;j

　　　　　{prinｔf（"%d",maｘ[ｉ］［j]）;}

ﻩfor（j=0;j＜nｏ２;　j+＋）

ﻩﻩ{pｒｉnｔｆ（"　%ｄ　　",allocａtion[i]［j]）;}

ﻩ

ﻩfｏr（ｊ　＝0;j<　no2；　j++）

ﻩﻩ{ｐriｎtｆ（"%ｄ　＂,ｎeed[ｉ]［j］）;}

ﻩ

ﻩﻩｐrinｔf（＂＼ｎ＂）;

ﻩﻩ}

prinｔｆ（"\ｎ"）;

ﻩﻩprｉｎtf（"各类资源可利用的资源数为:

"）；

ﻩﻩfor（j=0;j<ｎo2;j+＋）

ﻩ　{printf（"%d",avaｉlablｅ[j]）;}

ﻩprｉnｔf（"\ｎ"）;

}

程序运行调试结果：

1、程序初始化

2、检测系统资源分配是否安全结果