银行家算法实现Word格式.docx
《银行家算法实现Word格式.docx》由会员分享，可在线阅读，更多相关《银行家算法实现Word格式.docx（20页珍藏版）》请在冰豆网上搜索。
2.安全性检查算法
1）.设置两个工作向量Work=AVAILABLE;
FINISH
2）.从进程集合中找到一个满足下述条件的进程，
FINISH==false;
NEED<
=Work;
如找到，执行（3）；
否则，执行（4）
3）.设进程获得资源，可顺利执行，直至完成，从而释放资源。
Work+=ALLOCATION;
Finish=true;
4）.如所有的进程Finish=true，则表示安全；
否则系统不安全。
3.银行家算法
在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。
在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。
银行家算法的基本思想是分配资源之前,判断系统是否是安全的;
若是,才分配。
它是最具有代表性的避免死锁的算法。
设进程cusneed提出请求REQUEST[i]，则银行家算法按如下规则进行判断。
1）.如果REQUEST[cusneed][i]<
=NEED[cusneed][i]，则转
（2）；
否则，出错。
2）.如果REQUEST[cusneed][i]<
=AVAILABLE[cusneed][i]，则转（3）；
3）.系统试探分配资源，修改相关数据：
AVAILABLE[i]-=REQUEST[cusneed][i];
ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];
NEED[cusneed][i]-=REQUEST[cusneed][i];
4）.系统执行安全性检查:
如安全，则分配成立；
否则试探险性分配作废，系统恢复原状，进程等待
用到的数据结构：
实现银行家算法要有若干数据结构，它们用来表示资源分配系统的状态。
令n表示系统中进程的数目，m表示资源的分类数。
还需要以下数据结构：
1）.Available是一个长度为m的向量，它表示每类资源可用的数量。
Available[j]=k，表示j类资源可用的数量为k。
2）.Max是一个n×
m矩阵，它表示每个进程对资源的最大需求。
Max[i，j]=k，表示进程pi至多可以申请k个j类资源单位。
3）.Allocation是一个n×
m矩阵，它表示当前分给每个进程的资源数目。
Allocation[i，j]=k，表示进程i当前分到k个j类资源。
4）.Need是一个n×
m矩阵，它表示每个进程还缺少多少资源。
Need[i，j]=k，表示进程pi尚需k个j类资源才能完成其任务。
显然Need[i，j]=Max[i，j]-Allocation[i，j]。
功能模块层次结构图：
图1
3.程序设计流程图
N
4.详细设计
调试过程中的问题：
1.初始化时没有提示输入范围，易造成数据越界。
2.输出资源情况时出现16进制数字
解决方法：
1.初始化时提示正确的输出范围，并检查错误输入数据。
2.Max，Need，Request为二位数组，但由于疏忽，输出时打为一维数组，改为Max[i][j]等时，问题解决
图4.1
图4.2
图4.3
5.设计总结
两周的操作系统课程设计，我学到了很多课本上没有的知识。
想要完成模拟银行家算法的C++程序，首先就是要彻底熟悉算法，了解算法的基本原理，才能开始着手程序设计。
在程序设计设计过程中，遇到了一些困难，通过向同学询问，翻阅资料等，问题被一一解决了，在此感谢那些提供给我帮助的同学。
课程设计中，我取得了很多收获。
首先就是在知识层面上了解了银行家算法这种进程调度和避免死锁的算法，并用C++程序真正模拟出安全性检查和银行家算法过程，复习了之前所学C++语言和数据结构的知识；
在编程过程中虽然遇到很多困难，解决问题的过程中，同时也锻炼了我不怕困难，勇于迎接挑战的精神，为以后的工作打下了坚实的基础。
6.参考文献
[1]汤子赢等.《计算机操作系统》（第二版）.西安电子科技大学出版社,2006.8
[2]汤子赢等.《计算机操作系统》（第二版）.西安电子科技大学出版社,2006.8
[3]张尧学等.《计算机操作系统教程》（第2版）.清华大学出版社,2001.4
源程序代码
#include<
iostream.h>
stdio.h>
stdlib.h>
conio.h>
string.h>
//===定义全局变量===
constintx=50,y=100;
//定义常量，便于修改
intAvailable[x];
//各种资源可利用的数量
intAllocation[y][y];
//各进程当前已分配的资源数量
intMax[y][y];
//各进程对各类资源的最大需求数
intNeed[y][y];
//还需求矩阵
intRequest[x];
//申请各类资源的数量
intWork[x];
//工作向量，表示系统可提供给进程继续运行所需的各类资源数量
intFinish[y];
//表示系统是否有足够的资源分配给进程，0为否，非0为是
intp[y];
//存储安全序列
inti,j;
intn,m;
//n为进程的数量,m为资源种类数
intl=0,counter=0;
voidchushihua（）{
//===系统初始化输入===
cout<
<
"
%%程序开始，系统初始化输入%%"
endl;
//<
endl
==============================================================="
endl<
请输入进程的数量:
（最大100）"
;
//从此开始输入有关数据
cin>
>
n;
while（n>
100||n<
=0）
{
cout<
输入进程数不合法，请重新输入!
cin>
}
请输入资源种类数:
（最大50）"
m;
while（m>
50||m<
输入资源数不合法，请重新输入!
请输入资源的数量:
请输入各种资源可利用的数量（"
m<
种）:
"
for（j=0;
j<
j++）{
输入资源"
j<
可利用的数量Available["
]:
Available[j];
Work[j]=Available[j];
//初始化Work[j]
请输入各进程当前已分配的资源数量Allocation["
n<
]["
for（i=0;
i<
i++）{
for（j=0;
cout<
请输入进程"
i<
当前已分配的资源"
数量:
cin>
Allocation[i][j];
Finish[i]=0;
//初始化Finish[i]
请输入各进程对各类资源的最大需求数Max["
j++）{
对资源"
的最大需求数:
Max[i][j];
if（Max[i][j]>
=Allocation[i][j]）
Need[i][j]=Max[i][j]-Allocation[i][j];
//计算还需求量
else
Need[i][j]=0;
//最大需求量小于已分配量时还需求量为0,即此类资源已足够不需再申请
}
%%初始化完成!
%%"
}
voidanquan（）{
l=0;
）{//i++
//cout<
当前finish["
]="
Finish[i]<
if（Finish[i]==0）{//寻找Finish[i]==0的进程条件一
counter=0;
//有一个资源不符合条件，counter=1
//cout<
Work["
Work[j]<
Need["
Need[i][j]<
if（Work[j]<
Need[i][j]）{//可用小于需求，无法为进程分配资源
counter=1;
//cout<
进程"
不符合条件"
break;
}
}
if（counter!
=1）{//进程的每类资源量都符合条件Work[j]>
=Need[i][j]条件二
符合条件"
p[l]=i;
Finish[i]=1;
//标志为可分配
j++）{
Work[j]=Work[j]+Allocation[i][j];
//释放资源
l=l+1;
//记数,当L=N时说明满足安全序列,即都符合条件Work[j]>
=Need[i][j]
i=-1;
//从第一个进程开始继续寻找满足条件一二的进程
i++;
//for循环继续寻找
intanquan1（）
{
if（l<
n）{
\n当前状态不安全，无法申请,程序退出!
!
system（"
pause"
）;
return0;
else{
inti;
//局部变量
l=0;
\n安全的状态!
安全序列为:
（"
p[0]<
）"
//输出安全序列，考虑显示格式，先输出第一个
for（i=1;
==>
p[i]<
for（i=0;
i++）Finish[i]=0;
//所有进程置为未分配状态
//===显示分配情况函数===
voidshow（）//输出当前资源分配情况
{
inti,j;
intAll[y];
//各种资源的总数量
intl2;
//局部变量l1,
%%系统当前状态如下：
%%"
%%各种资源的总数量（all）:
j++）{
资源"
:
All[j]=Available[j];
//初始化先赋值加上可利用量
i++）{
All[j]+=Allocation[i][j];
//再加上每个进程已分配量计算J类资源总量
All[j]<
if（（j+1）%5==0）cout<
//每行显示五个&
&
j!
=0
%%系统目前各种资源可用的数为（available）:
Available[j]<
if（（j+1）%5==0）cout<
//每行最多显示五个&
%%各进程已经得到的资源量（allocation）:
for（i=0;
=m/5;
i++）{//设计每行最多显示五种资源
for（j=i*5;
i*5+5&
j++）
j;
for（l2=0;
l2<
l2++）{
for（j=i*5;
j++）cout<
Allocation[l2][j]<
%%各进程还需要的资源量（need）:
//l1=0;
i++）{//设计每行显示五种资源
for（j=i*5;
for（l2=0;
l2++）{
for（j=i*5;
Need[l2][j]<
system（"
//暂停
//===银行家算法函数===
voidbank（）{
%%以下开始为进程进行资源分配申请%%"
//===申请资源===
intk=0;
//用于输入进程编号
boolr=false;
//初值为假，输入Y继续申请则置为真
do{
//输入请求
请输入申请资源的进程编号（输入0--"
n-1<
之间）:
k;
while（k>
n-1）{//输入异常处理
您输入了错误的进程号，请重新输入!
请输入该进程申请各类资源的数量:
do{//do……while循环判断申请输入的情况
进程"
k<
申请资源["
]的数量:
Request[j];
if（Request[j]>
Need[k][j]）{//申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目）
cout<
申请大于需要量!
您申请资源"
的数量为"
Request[j]<
大于进程"
对该资源需求量"
Need[k][j]<
。
请重新输入!
else//先判断是否申请大于需求量，再判断是否申请大于可利用量
if（Request[j]>
Available[j]）{//申请大于可利用量，应该阻塞等待
cout<
\n没有那么多资源，目前可利用资源"
数量为"
本次申请不成功，进程等待!
Finish[k]=0;
//该进程等待
gotoppp;
//goto语句跳转，结束本次申请
}while（Request[j]>
Need[k][j]）;
//Request[j]>
Available[j]||
//改变Avilable、Allocation、Need的值
Available[j]=Available[j]-Request[j];
Allocation[k][j]=Allocation[k][j]+Request[j];
Need[k][j]=Need[k][j]-Request[j];
Work[j]=Available[j];
//判断当前状态的安全性
anquan（）;
//调用安全性算法函数
n）
\n当前状态不安全,不予分配!
//恢复数据
Available[j]=Available[j]+Request[j];
Allocation[k][j]=Allocation[k][j]-Request[j];
Need[k][j]=Need[k][j]+Request[j];
Work[j]=Available[j];
i++）
Finish[i]=0;
//进程置为未分配状态
\n申请资源成功!
//===========================================
for（j=0;
if（Need[k][j]==0）;
else{//有一种资源还没全部申请到，则该进程不可执行，不能释放拥有的资源
l=1;
//置l为1，作为判断标志
break;
if（l!
=1）{//进程可以执行，则释放该进程的所有资源
Available[j]=Available[j]+Allocation[k][j];
Allocation[k][j]=0;
该进程已得到所有需求资源，执行后将释放其所有拥有资源！
//归零
Finish[0]=0;
for（i=1;
show（）;
//显示当前状态
ppp:
//申请大于可利用量，应该阻塞等待,结束本次资源申请，GOTO语句跳转至此
是否继续申请资源（y/n）?
char*b=newchar;
//输入y/n，判断是否继续申请<
b;
升级会员 