操作系统课程设计银行家算法.docx
《操作系统课程设计银行家算法.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计银行家算法.docx（15页珍藏版）》请在冰豆网上搜索。
操作系统课程设计银行家算法
实验报告
题目
名称
银行家算法设计与实现
院系
信息科学与工程学院
班级
完成时间
2012-04-24
指导老师
本次实验成绩
组长
联系电话
邮件地址
组员（姓名，
学号）
主要任务
程序的编译、调试、修改与检测，算法的组织，综合调度，程序运行界面的实现
组员（姓名，
学号）
主要任务
算法的分析、实现与说明，
画流程图,测试，实验报告的完成
主
要
原
理
及
所
参
考
的
资
料
（
包
括
实
验
内
容
及
条
件
）
实验原理：
银行家算法设计与实现
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全,银行家规定:
（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
（2）顾客可以分期贷款,但贷款的总数不能超过最大需求量;
（3）当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
（4）当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金。
主要参考书：
计算机操作系统（第三版）西安大学出版社汤子瀛主编
主
要
算
法
流
程
图
（
包
括
实
验
步
骤
）
算法流程图：
附录1--银行家算法流程图
附录2—安全性算法流程图
实验步骤：
一、银行家算法
设Request是进程i的请求向量，如果Request[j]=K,表示进程需要个此类型资源。
当进程发出资源请求后，系统按下述步骤进行检查：
（1）如果Request[j]<=Need[i][j],便转向步骤
（2）；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
（2）如果Request[j]<=Available[j]，便转向步骤（3）；否则，表示尚无足够资源，进程须等待。
（3）系统试探着把资源分配给进程，并修改下面数据结构中的数值：
Available[j]=Available[j]-Request[j]；
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
（4）系统执行安全算法，检查此次资源分配后是否处于安全状态。
若安全，才正式将资源分配给进程，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配，让进程等待。
二、安全性算法
系统所执行的安全性算法可描述如下：
（1）设置两个向量：
①工作向量Work；它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行时，Work[j]=Available[j]。
②Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时，先做Finish[i]=false；当有足够资源分配该进程时，再令Finish[i]=true。
（2）从进程集合中找到一个能够满足下述条件的进程：
①Finish[i]=false；
②Need[i][j]<=Work[j]；若找到，执行步骤（3）,否则，执行步骤（4）。
（3）当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]=Work[j]+Allocation[i][j];
Finish[i]=TRUE;
gotostep2；
（4）如果所有进程的Finish[i]=TRUE;都满足，则表示系统处于安全状态；否则，系统处于不安全状态。
本
实
验
涉
及
的
主
要
算
法
细
节
说
明
（
包
括
数
据
结
构
）
算法说明：
1．可利用资源向量Available，他是一个含有N个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available[j]=k，标是系统中现有Rj类资源k个。
2．最大需求矩阵Max，这是一个M*N的矩阵，它定义了系统中M个进程中每一个进程对N类资源的最大需求。
如果Max[i][j]=k,表示进程i需要Rj类资源的最大数目为k。
3．分配矩阵Allocation，这是一个M*N的矩阵，它定义了系统中的每类资源当前已分配到每一个进程的资源数。
如果Allocation[i][j]=k，表示进程i当前已经分到Rj类资源的数目为k。
Allocationi表示进程i的分配向量，有矩阵Allocation的第i行构成。
4．需求矩阵Need，这是一个M*N的矩阵，用以表示每个进程还需要的各类资源数目。
如果Need[i][j]=k，表示进程i还需要Rj类资源k个，才能完成其任务。
Needi表示进程i的需求向量，由矩阵Need的第i行构成。
5.Need[i][j]=Max[i][j]-Allocation[i][j]
本次实践计划、进度安排及完成情况
4月9号商讨如何实现本次实验以及同学之间的分工；
4月10号~4月19号基本完成程序；
4月20号~4月22号修改完善程序、代码测试；
4月23号~4月24号完成实验报告及检查修改。
主要测试方法及测试数据，包括测试结果及测试人
程序运行结果：
本次实验的心得体会（每位同学一段）
通过本次实验了解到用银行家算法来预防死锁是可靠的，但也是非常保守的，因为它限制了进程对资源的存取，从而降低了进程的并发运行程度。
死锁检测并不限制进程对资源的申请，只要有，就分配，但这也可能造成死锁。
但由于死锁并不是经常发生的，故大大提高了系统运行的效率。
在本次编程的过程中，遇到过不少问题，最典型的问题还是算法的实现，比如如何实现安全性算法、银行家算法。
而解决这些问题，就需要自己对各种算法的理解。
如安全性算法，根据安全性算法的理解，编写算法过程中，只要出现一安全序列，就断定该状态是安全的，而编写的过程中，只要有这思想，编写过程就简单得多了。
通过本次实验，加深了对银行家算法的理解，对于系统出现的死锁问题也有了更深刻的理解。
银行家算法是一种最有代表性的避免死锁的算法。
在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。
为实现银行家算法，系统必须设置若干数据结构。
在安全性算法中，用一个临时变量是为防止在该时刻不安全的情况下破坏数据的原值。
附录2安全性算法流程图
附录3银行家算法设计与实现源程序
#include
#include
#include
#defineFALSE0
#defineTRUE1
#defineS100
intM,N;//M和N分别为进程总数和资源种类数
intr;
charch;
intMax[S][S],Allocation[S][S],Available[S],Need[S][S];
voidmain（）
{
voidcheck（）;
voidprint（）;//函数申明
intAllocation1[S][S],Need1[S][S],Request[S],Available1[S];
inti,j,x,p=0,q=0;
printf（"*********************************\n"）;
printf（"*银行家算法设计与实现*\n"）;
printf（"*********************************\n"）;
printf（"请输入进程总数：
\n"）;
scanf（"%d",&M）;
printf（"请输入资源种类数：
\n"）;
scanf（"%d",&N）;
printf（"请输入Max矩阵：
\n"）;
for（i=0;ifor（j=0;jscanf（"%d",&Max[i][j]）;//最大需求矩阵
printf（"请输入Allocation矩阵：
\n"）;
for（i=0;ifor（j=0;jscanf（"%d",&Allocation[i][j]）;//已分配矩阵
printf（"请输入Available矩阵：
\n"）;
for（j=0;jscanf（"%d",&Available[j]）;//可利用资源矩阵
for（i=0;ifor（j=0;jNeed[i][j]=Max[i][j]-Allocation[i][j];//需求矩阵
print（）;
check（）;//检测T0时刻进程的安全状态
if（r==1）
{
do
{
p=0;
q=0;
printf（"请输入请求资源的进程号<0~%d>：
\n",M-1）;
for（j=0;j<10;j++）
{
scanf（"%d",&x）;//x为请求资源的进程号
if（x<0||x>M-1）
{
printf（"输入出错，请重新输入：
\n"）;
continue;
}
else
break;
}
printf（"\n请输入该进程所请求的资源数Request[j]:
\n"）;
for（j=0;jscanf（"%d",&Request[j]）;//输入该资源申请的资源量
for（j=0;jif（Request[j]>Need[x][j]）
p=1;
if（p）
printf（"请求资源数超过该进程资源最大值需求量，请求失败！
"）;
else
{
for（j=0;jif（Request[j]>Available[j]）
q=1;
if（q）
printf（"没有足够资源分配，请求失败！
"）;
else
{
for（j=0;j{
Available1[j]=Available[j];
Allocation1[x][j]=Allocation[x][j];
Need1[x][j]=Need[x][j];
Available[j]=Available[j]-Request[j];
Allocation[x][j]=Allocation[x][j]+Request[j];
Need[x][j]=Need[x][j]-Request[j];
}
print（）;
check（）;
if（r==0）
{
for（j=0;j{
Available[j]=Available1[j];
Allocation[x][j]=Allocation1[x][j];
Need[x][j]=Need1[x][j];
}
printf（"\n返回资源分配前资源数\n"）;
print（）;
}
}
}
printf（"\n你还要继续分配吗？
YorN?
\n"）;
getchar（）;
ch=getchar（）;
}while（ch=='y'||ch=='Y'）;
}
}
voidprint（）
{
inti,j;
printf（"*****************此时刻资源分配情况*******************\n"）;
printf（"进程名/号|Max|Allocation|Need|\n"）;
for（i=0;i{
printf（"p%d/%d",i,i）;
for（j=0;jprintf（"%d",Max[i][j]）;
for（j=0;jprintf（"%d",Allocation[i][j]）;
printf（""）;
for（j=0;jprintf（"%d",Need[i][j]）;
printf（"\n"）;
}
printf（"\n"）;
printf（"各类资源可利用的资源数为:
\n"）;
for（j=0;jprintf（"%d",Available[j]）;
printf（"\n"）;
}
voidcheck（）
{
inti,j,k,flag;
intt=0;
intWork[S],Finish[S];
intA[S];//用于存放安全序列
r=1;
for（j=0;jWork[j]=Available[j];
for（i=0;iFinish[i]=FALSE;
k=M;
do
{
for（i=0;i{
if（Finish[i]==FALSE）
{
flag=1;
for（j=0;jif（Need[i][j]>Work[j]）
flag=0;
if（flag==1）
{
Finish[i]=TRUE;
A[t++]=i;//记录安全系列号
for（j=0;jWork[j]=Work[j]+Allocation[i][j];
}
}
}
k--;
}while（k>0）;
flag=1;
for（i=0;i{
if（Finish[i]==FALSE）
{
flag=0;
break;
}
}
if（flag==0）
{
printf（"系统处于不安全状态！
\n"）;
r=0;
}
else
{
printf（"\n系统当前处于安全状态，安全序列为：
\n"）;
for（i=0;i{
if（i>=M-1）
printf（"p%d",A[i]）;
else
printf（"p%d->",A[i]）;//输出安全序列
}
printf（"\n"）;
}
}
升级会员 