操作系统银行家算法.docx
《操作系统银行家算法.docx》由会员分享，可在线阅读，更多相关《操作系统银行家算法.docx（16页珍藏版）》请在冰豆网上搜索。
操作系统银行家算法
目录
1.绪论2
2.设计目的3
3.设计要求4
4.原理分析4
4.（a）银行家算法中的数据结构4
4.（b）银行家算法5
4.（c）安全性算法6
5.具体设计和程序流程图6
6.详细设计（程序代码）9
7.程序调试和程序实现15
8．设计小结18
9.参考文献20
1.绪论
通过一学期对操作系统的学习，加深了对计算机操作系统的了解，也学习到很多关于计算机的理论知识。
为了理论结合实际，以及增强实际动手能力，利用一周的时间来完成本次课程设计，课程设计主要是利用C++高级语言来完银行家算法的模拟实现。
这次课程设计要求完成一个资源管理系统，该系统必须包括资源的添加、删除和修改等功能，并且允许其它进程来申请这里的资源，任何一个进程来申请资源时，必须先登记该进程对资源的申请要求，然后由系统检查当前资源的状况，并用银行家算法和安全性算法来检查是否允许分配资源给进程。
通过课程设计，加深我们对利用银行家算法避免死锁的理解。
在设计中主要的难点是用语言编写银行家算法和安全性算法，使系统资源分配能安全进行，避免系统死锁。
2.设计目的
在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率和提高系统的吞吐量，但可能发生一种危险——死锁。
所谓死锁，是指多个进程运行中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，他们都无法再向前推进。
产生死锁的原因归纳为两点：
竞争资源，当系统中供多个进程共享的资源，但其数目不能满足诸进程的需要时，会引起诸进程对资源的竞争而产生死锁；进程间推进顺序非法，进程在运行的过程中，请求和释放资源的顺序不当，也能导致产生进程死锁。
虽然进程在运行过程中，可能发生死锁，但死锁的发生必须具备四个必要条件：
互斥条件、请求和保持条件、不剥夺条件、环路等待条件；防止死锁的机构只须确保上述四个条件之一不出现，则系统不会发生死锁。
系统的状态分为安全状态和不安全状态，只要能使系统都处于安全状态，便可避免死锁。
所谓安全状态，是指系统能按某种进程顺序（P1，P2，…，Pn），来为每个进程Pi分配其所需分配，直至满足每个进程对资源的最大需求，使每个进程都可顺利地完成。
如果系统无法找到一个这样地安全系列，则称系统处于不安全状态。
在操作系统中研究资源分配策略时也有类似的问题，系统中有限的资源要供多个进程使用，必须保证得到资源的进程能在有限的时间内归还资源，以供它进程使用资源。
如果资源分配不得当就会发生进程循环等待资源，各进程都无法继续执行下去的死锁现象。
而最有代表性的避免死锁的算法，是Dijkstra的银行家算法。
银行家算法是避免死锁的一种重要方法，在课程设计中用C++语言编写一个资源管理系统，并要用银行家算法和安全性算法检查是否允许分配资源给进程，避免死锁。
通过课程设计，加深我们对了解有关资源申请、避免死锁等概念，并加深我们对银行家算法理解。
提高了我们分析、解决问题的能力。
3.设计要求
用所学过的语言编程实现一个资源管理系统，该系统必须包括资源的添加、删除和修改等功能，并且允许其它进程来申请这里的资源，任何一个进程来申请资源时，必须先登记该进程对资源的申请要求，然后由系统检查当前资源的状况，并用银行家算法和安全性算法来检查是否允许分配资源给进程。
4.原理分析
在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。
银行家算法是避免死锁的一种重要方法，为实现银行家算法，系统必须设置若干数据结构。
4.（a）银行家算法中的数据结构
1）可利用资源向量Available
是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。
如果Available［j］=K，则表示系统中现有Rj类资源K个。
2）最大需求矩阵Max
这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max［i,j］=K，则表示进程i需要Rj类资源的最大数目为K。
3）分配矩阵Allocation
这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。
如果Allocation［i,j］=K，则表示进程i当前已分得Rj类资源的数目为K。
4）需求矩阵Need。
这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。
如果Need［i,j］=K，则表示进程i还需要Rj类资源K个，方能完成其任务。
Need［i,j］=Max［i,j］-Allocation［i,j］
4.（b）银行家算法
设Requesti是进程Pi的请求向量，如果Requesti［j］=K，表示进程Pi需要K个Rj类型的资源。
当Pi发出资源请求后，系统按下述步骤进行检查：
如果Requesti［j］≤Need［i,j］，便转向步骤2；否则认为出错，因为它所需要的资源数已超过它所宣布最大值。
1）如果Requesti［j］≤Available［j］，便转向步骤（3）；否则，表示尚无足够资源，Pi须等待。
2）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available［j］∶=Available［j］-Requesti［j］;
Allocation［i,j］∶=Allocation［i,j］+Requesti［j］;
Need［i,j］∶=Need［i,j］-Requesti［j］;
3）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
4.（c）安全性算法
1）设置两个向量：
工作向量Work:
它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available;
工作向量Finish:
它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish［i］∶=false;当有足够资源分配给进程时，再令Finish［i］∶=true。
2）从进程集合中找到一个能满足下述条件的进程：
Finish［i］=false;
Need［i,j］≤Work［j］；若找到，执行（3），否则，执行（4）
3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work［j］∶=Work［i］+Allocation［i,j］;
Finish［i］∶=true;
gotostep2;
4）如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。
5.具体设计和程序流程图
在程序中设计五个进程，分别为0,1，2,3,4。
共享三类资源。
在这个资源管理系统中对进程的所需最大资源（Max）、已分配给当前进程资源（Allocation）和系统可用资源（Available）分别进行了初始化了值。
进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。
要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列，若分配不安全，则释放分配的资源，防止使系统进入不安全状态。
显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据。
程序还可以实现对系统的修改。
如果修改系统可用资源（Available），和进程分配资源。
程序具体的设计是：
（1）函数voidshowdata（）用来显示资源矩阵，包括系统可用资源数目，进程对资源最大需求数，系统已分配给进程的资源数，进程还需求资源。
通过以上显示，很直观的观察到资源分配和修改的过程。
函数share（）用来利用银行家算法对某个进程申请资源对进行判定。
（2）函数intchangdata（inti）用来实现试探分配。
主要执行的步骤是：
Avaliable[j]=Avaliable[j]-Request[j]，Allocation[i][j]=Allocation[i][j]+Request[j],
Need[i][j]=Need[i][j]-Request[j]。
（3）函数safe（）用来实现安全性算法，对分配后的资源进行计算，若分配资源后，系统是安全的，则资源完成本次分配。
若不安全将本次的试探分配作废，调用shifang（）函数恢复原来的资源分配状态。
（4）资源修改功能用Revision（）来实现。
（5）银行家算法程序设计流程图如下：
银行家算法流程图
6.详细设计（程序代码）
#include
#include
#include
#defineM5//定义进程数
#defineN3//定义资源数
#defineFalse0
#defineTrue1
intMax[][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//各进程所需各类资源的最大需求
intAvaliable[]={5,3,2};//系统可用资源
intAllocation[][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//系统已分配资源
intNeed[][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//还需要资源
intRequest[3];//请求资源向量
voidshowdata（）//显示资源矩阵
{
inti,j;
cout<<"系统目前可用的资源[Avaliable]:
"<cout<<"Resouce:
"<for（j=0;jcout<cout<<"各进程的最大资源需求[Max]:
"<for（i=0;icout<for（j=0;jcout<}
cout<}
cout<<"各进程已经得到的资源[Allocation]:
"<for（i=0;icout<for（j=0;jcout<}//输出已分配资源数
cout<}
cout<<"各进程还需求资源[Need]:
"<for（i=0;icout<for（j=0;jcout<}//输出还需要资源数
cout<}
}
intchangdata（inti）//进行资源分配
{
intj;
for（j=0;jAvaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return1;
}
intsafe（）//安全性算法
{
intWork[3],Finish[M]={0},temp[M];
inti,k=0,m,apply;
intj;
Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];
for（i=0;iapply=0;
for（j=0;j<3;j++）{
if（Finish[i]==False&&Need[i][j]<=Work[j]）{
apply++;
if（apply==3）{
for（m=0;m<3;m++）
Work[m]=Work[m]+Allocation[i][m];//变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
}
}
else
if（Finish[i]==False）{
cout<<"系统不安全"<return-1;
}
break;
}
}
}
cout<<"系统资源分配成功!
"<cout<<"分配的序列:
";
for（i=0;i{
cout<";
}
cout<return0;
}
voidshare（）//利用银行家算法对申请资源对进行判定
{
charch;
inti=0,j=0;
ch='y';
cout<<"请输入要求分配的资源进程号从（0to4）:
";
cin>>i;//输入须申请的资源号
cout<<"请输入进程"<"<for（j=0;j<3;j++）
{
cout<<"第"<";
cin>>Request[j];//输入需要申请的资源
}
for（j=0;jif（Request[j]>Need[i][j]）//判断申请是否大于需求，若大于则出错
{
cout<<"进程"<cout<<"分配不合理，不予分配！
"<ch='n';
break;
}
else{
if（Request[j]>Avaliable[j]）//判断申请是否大于当前资源，若大于则
{//出错
cout<<"进程"<cout<<"分配出错，不予分配!
"<ch='n';
break;
}
}
}
if（ch=='y'）{
changdata（i）;//根据进程需求量变换资源
showdata（）;//根据进程需求量显示变换后的资源
safe（）;//根据进程需求量进行银行家算法判断
}
}
voidchangeresources（）{//修改资源函数
cout<<"请选择:
1：
修改进程还需要的资源2：
修改进程可用资源"<intchoice1;
cin>>choice1;
if（choice1==1）{
cout<<"输入要修改的进程号（0~4）"<intp;
cin>>p;
cout<<"输入修改后进程还需要的资源（0,0,0）"<cin>>Need[p][0]>>Need[p][1]>>Need[p][2];
cout<<"经修改后各进程还需求资源:
"<for（inta=0;acout<for（intb=0;bcout<}
cout<}
}
if（choice1==2）
{
cout<<"输入系统可用资源[Avaliable]（0,0,0）"<cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];
cout<<"经修改后的系统可用资源为"<for（intk=0;kcout<}
cout<}
}
intmain（）//主函数
{
cout<<"**************银行家算法演示***************"<intchoice;
showdata（）;//显示各种资源
safe（）;//用银行家算法判定系统是否安全
do{
cout<<"输入要进行的操作1:
分配资源2:
修改资源3:
离开"<cin>>choice;
if（choice==1）
{
share（）;
}
if（choice==2）
{
changeresources（）;
}
if（choice==3）
break;
}while（（choice==1）||（choice==2））;
return1;
}
7.程序调试和程序实现
为了便于检验程序的正确性，这里用了课本上的数据进行了初始化。
程序
VC++的运行环境中运行，调试。
在调试的过程中出现如下界面：
在程序中初始化如情况：
在各进程的最大资源需求，个进程已经得到的资源；个进程还需求的资源中；第一列所显示的是进程编号，后边三列为各个进程分别对三种资源的最大需求，占有，还需求情况。
在系统的目前可用三种资源分别设计为：
3，3，2。
数值按照课本输入后显示结果如下图。
最后得到正确的分配序列。
程序运行时选择1,输入进程pr1的请求向量（1,0,2）经过程序计算，资源分配成功资
资源具体分配过程如下图所示。
由结果可知，系统安全。
则系统分配资源成功。
。
运行程序时选择1，然后让进程4发出请求资源（3，3，0），按银行家算法进行检查
由于检查出错，原因如下：
Request4（3,3,0）<=Need4（4,3,1）;
Request4（3,3,0）不小于等于（2,3,0）；
所以分配不成功，不予分配回收资源。
程序运行后选择2，对可利用资源进行修改，选择修改资源为（4，2，3）
其修改后的结果如下图：
程序运行后选择2，还可以对每个进程的需求资源进行修改例如修改2进程的需求资源为（3，2，1）
其修改后的结果如下图：
由于时间及一些设计的因素在这里就不再一一调试，检查了。
从设计的角度本人认为该程序的设计原理是正确的，通过部分调试实验的结果也是符合要求的。
故不再举例说明了。
8．设计小结
通过一周来的查阅，分析，设计，实验，调试，最终算是完成了本次课程设计。
在设计的过程中，通过查阅大量的书籍和网络资源，对产生死锁的原因，必要条件，以及银行家算法有了更加深入的了解，有了更深的认识。
虽然在做本次课程设计的过程中花费了大量时间，但是真正学到的远超过了对这们课程的理解。
由于计算机操作系统的课程讲述计算机的理论性较强，抽象性较大，故通过本次课程设计能够理论联系实际，结合所学的有关其他课程知识，让我更加完整的了解了操作系统的基本原理。
但是也发现了许多以前自己对某些方面的误解，同时自己还有好多方面有欠缺，在今后的其他课程学习的过程中努力增加有关的专业知识，增强自己的动手能力。
现在粗劣的分析一下自己的设计思想：
设计主要由两部分组成。
第一部分:
银行家算法（扫描）
1.如果Request<=Need,则转向2;否则,出错
2.如果Request<=Available,则转向3,否则等待
3.系统试探分配请求的资源给进程
4.系统执行安全性算法
安全性算法
1.设置两个向量
（1）.工作向量:
Work=Available（表示系统可提供给进程继续运行所需要的各类资源数目）
（2）.Finish:
表示系统是否有足够资源分配给进程（True:
有;False:
没有）.初始化为False
2.若Finish[i]=False&&Need<=Work,则执行3;否则执行4（I为资源类别）
3.进程P获得第i类资源,则顺利执行直至完成!
并释放资源:
Work=Work+Allocation;Finish[i]=true;转2
4.若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!
第二部分主要是进行资源的修改。
在这里可以修改资源的可用资源和资源还需求资源。
由于时间有限，还不是很完善，系统还有许多不尽人意的地方。
这些都有待进一步改善。
本程序的运行环境为VC++环境，编写语言为C++语言。
在这次设计中有好多不懂，不太熟悉的地方，后经过老师，同学帮忙，网络求助等途径得已解决，在这里给予我帮助的辅导老师，同学表示感谢。
9.参考文献
[1]汤子赢，哲凤屏，汤小丹.计算机操作系统［M］.西安：
西安电子科技大学出版社，2001.
[2]任满杰，刘树刚，李军红.操作系统原理实用教程［M］.北京：
电子工业出版社，2006.
[3]潭浩强.C++程序设计［M］.北京：
清华大学出版社，1999.
[4]孙鑫鸽孙小玲李进球何大宏计算机应用技术与程序设计。
清华大学出版社
[5]张铭刘晓丹.数据结构与算法分析.电子工业出版社
[6]郁红英冯庚豹.计算机操作系统.人民邮电出版社
升级会员 