操作系统 课程设计报告 专业 计算机科学与技术 学生姓名 班级 学号 指导教师 完成日期 信息工程学院 题目：
银行家算法的模拟实现 一、设计目的 本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。

二、设计内容 1）概述 用C或C++语言编制银行家算法通用程序，并检测所给状态的系统安全性。

1. 算法介绍：数据结构：
1） 可利用资源向量 Available；

2） 最大需求矩阵Max；

3） 分配矩阵Allocation；

4） 需求矩阵Need 2. 功能介绍 模拟实现Dijkstra的银行家算法以避免死锁的出现，分两部分组成：
第一部分：银行家算法（扫描）；

第二部分：安全性算法。

2）设计原理 一．银行家算法的基本概念 1、死锁概念。

在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险━━死锁。所谓死锁(Deadlock),是指多个进程在运行中因争夺资源而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。

2、关于死锁的一些结论：
Ø 参与死锁的进程最少是两个 Ø （两个以上进程才会出现死锁） Ø 参与死锁的进程至少有两个已经占有资源 Ø 参与死锁的所有进程都在等待资源 Ø 参与死锁的进程是当前系统中所有进程的子集 注：如果死锁发生，会浪费大量系统资源，甚至导致系统崩溃。

3、资源分类。

永久性资源：
可以被多个进程多次使用（可再用资源） l 可抢占资源 l 不可抢占资源 临时性资源：只可使用一次的资源；
如信号量,中断信号，同步信号等（可消耗性资源） 　　　　　　“申请--分配--使用--释放”模式 4、产生死锁的四个必要条件：互斥使用（资源独占）、不可强占（不可剥夺）、请求和保持（部分分配，占有申请）、循环等待。

1) 互斥使用（资源独占） 一个资源每次只能给一个进程使用。

2) 不可强占（不可剥夺） 资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放。

3) 请求和保持（部分分配，占有申请） 一个进程在申请新的资源的同时保持对原有资源的占有（只有这样才是动态申请，动态分配）。

4) 循环等待 存在一个进程等待队列 {P1 , P2 , … , Pn}, 其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路。

5、死锁预防: 定义:在系统设计时确定资源分配算法，保证不发生死锁。具体的做法是破坏产生死锁的四个必要条件之一。

①破坏“不可剥夺”条件 在允许进程动态申请资源前提下规定，一个进程在申请新的资源不能立即得到满足而变为等待状态之前，必须释放已占有的全部资源，若需要再重新申请 ②破坏“请求和保持”条件。

要求每个进程在运行前必须一次性申请它所要求的所有资源，且仅当该进程所要资源均可满足时才给予一次性分配。

③破坏“循环等待”条件 采用资源有序分配法：
把系统中所有资源编号，进程在申请资源时必须严格按资源编号的递增次序进行，否则操作系统不予分配。

6．安全状态与不安全状态 安全状态：
如果存在一个由系统中所有进程构成的安全序列P1，…Pn，则系统处于安全状态。一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和，系统处于安全状态 (安全状态一定是没有死锁发生的) 不安全状态:不存在一个安全序列，不安全状态一定导致死锁。

二．银行家算法 1、银行家算法中的数据结构 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] 2、银行家算法 设Requesti是进程Pi的请求向量。如果Requesti[j]＝k，表示进程只需要k个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：
1）如果 Requesti[j]<=Need[i,j]，则转向步骤2；
否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

2）如果Requesti[j]<=Available[j] ，则转向步骤3；
否则，表示系统中尚无足够的资源，Pi必须等待。

3）系统试探把要求的资源分配给进程Pi，并修改下面数据结构中的数值：
Available[j]:=Available[j]-Requesti[j]; Allocation[i,j]:=Allocation[i,j]+Requesti[j]; Need[i,j]:=Need[i,j]-Requesti[j]; 4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；
否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

3、安全性算法 系统所执行的安全性算法可描述如下：
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; goto step 2；

4）如果所有进程的Finish[i]:=true，则表示系统处于安全状态；
否则，系统处于不安全状态。

三．银行家算法之例 假定系统中有五个进程：{P0，P1，P2，P3，P4}和三种类型的资源{A，B，C}，每一种资源的数量分别为10、5、7,在T0时刻的资源分配情况如图1所示。

资源情况 进程 Max Allocation Need Available A B C A B C A B C A B C P0 7 5 3 0 1 0 7 4 3 3 3 2 (2 3 0) P1 3 2 2 2 0 0 (3 0 2) 1 2 2 (0 2 0) P2 9 0 2 3 0 2 6 0 0 P3 2 2 2 2 1 1 0 1 1 P4 4 3 3 0 0 2 4 3 1 图1 T0时刻的资源分配表 (1)T0时刻的安全性：利用安全性算法对T0时刻的资源分配情况进行分析(如图2)可知，在T0时刻存在着一个安全序列｛P1，P3，P4，P2，P0｝，故系统是安全的。

资源情况 进程 Work Need Allocation Work+Allocation Finish A B C A B C A B C A B C P1 3 3 2 1 2 2 2 0 0 5 3 2 true true true true true P3 5 3 2 0 1 1 2 1 1 7 4 3 P4 7 4 3 4 3 1 0 0 2 7 4 5 P2 7 4 5 6 0 0 3 0 2 10 4 7 P0 10 4 7 7 4 3 0 1 0 10 5 7 图2 T0时刻的安全序列 (2)P1请求资源：P1发出请求向量Request1(1,0,2),系统按银行家算法进行检查：
①Request1(1,0,2)<=Need1(1,2,2) ②Request1(1,0,2)<=Available1(3,3,2) ③系统先假定可为P1分配资源，并修改Available,Allocation1和Need1向量，由此形成资源变化情况如图1中的圆括号所示。

④再利用安全性算法检查此时系统是否安全。如图3所示。

资源情况 进程 Work Need Allocation Work+Allocation Finish A B C A B C A B C A B C P1 2 3 0 0 2 0 3 0 2 5 3 2 true true true true true P3 5 3 2 0 1 1 2 1 1 7 4 3 P4 7 4 3 4 3 1 0 0 2 7 4 5 P0 7 4 5 7 4 3 0 1 0 7 5 5 P2 7 5 5 6 0 0 3 0 2 10 5 7 图3 P1申请资源时的安全性检查 由所进行的安全性检查得知，可以找到一个安全序列｛P1,P3,P4,P2,P0｝。因此系统是安全的，可以立即将P1所申请的资源分配给它。

(3)P4请求资源：P4发出请求向量Request4(3,3,0),系统按银行家算法进行检查：
①Request4(3,3,0)≤Need4(4,3,1); ②Request4(3,3,0)不小于等于Available(2,3,0),让P4等待。

(4)P0请求资源：P0发出请求向量Request0(0,2,0),系统按银行家算法进行检查。

①Request0(0,2,0) ≤Need0(7,4,3); ②Request0(0,2,0) ≤Available(2,3,0); ③系统暂时先假定可为P0分配资源，并修改有关数据，如图4所示。

资源情况 进程 Allocation Need Available A B C A B C A B C P0 0 3 0 7 3 2 2 1 0 P1 3 0 2 0 2 0 P2 3 0 2 6 0 0 P3 2 1 1 0 1 1 P4 0 0 2 4 3 2 图4 为P0分配资源后的有关资源数据 (5)进行安全性检查：可用资源Available(2,1,0)已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。

3）详细设计及编码 1）银行家算法流程图 2）程序源代码 #include <iostream.h> #include <stdio.h> #include <stdlib.h> #include <string.h> //定义全局变量 const int x=20,y=20; //常量，便于修改 int Available[x]; //各资源可利用的数量 int Allocation[y][y]; //各进程当前已分配的资源数量 int Max[y][y]; //各进程对各类资源的最大需求数 int Need[y][y]; //尚需多少资源 int Request[x]; //申请多少资源 int Work[x]; //工作向量，表示系统可提供给进程继续运行所需的各类资源数量 int Finish[y]; //表示系统是否有足够的资源分配给进程，1为是 int p[y]; //存储安全序列 int i,j; //i表示进程，j表示资源 int n,m; //n为进程i的数量,m为资源j种类数 int l=0; //l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是安全的 int counter=0; //函数声明 void chushihua(); //初始化函数 void safe(); //安全性算法 void show(); //函数show,输出当前状态 void bank(); //银行家算法 //void jieshu(); //结束函数 void chushihua() { cout<<“输入进程的数量: “;//从此开始输入有关数据 cin>>n; cout<<“输入资源种类数: “; cin>>m; cout<<endl<<“输入各种资源当前可用的数量( “<<m<<“ 种): “<<endl; for (j=0; j<m; j++) { cout<<“输入资源 “<<j<<“ 可利用的数量Available[“<<j<<“]: “; cin>>Available[j]; //输入数字的过程... Work[j]=Available[j]; //初始化Work[j]，它的初始值就是当前可用的资源数 } cout<<endl<<“输入各进程当前已分配的资源数量Allocation[“<<n<<“][“<<m<<“]: “<<endl; for (i=0; i<n; i++) { for (j=0; j<m; j++) { cout<<“ 输入进程 “<<i<<“ 当前已分配的资源 “<<j<<“ 数量: “; cin>>Allocation[i][j]; } cout<<endl; Finish[i]=0;//初始化Finish[i] } cout<<endl<<“输入各进程对各类资源的最大需求Max[“<<n<<“][“<<m<<“]: “<<endl; for (i=0; i<n; i++) { for (j=0; j<m; j++) { cout<<“ 输入进程 “<<i<<“ 对资源 “<<j<<“ 的最大需求数: “; cin>>Max[i][j]; if(Max[i][j]>=Allocation[i][j]) //若最大需求大于已分配，则计算需求量 Need[i][j] = Max[i][j]-Allocation[i][j]; else Need[i][j]=0;//Max小于已分配的时候，此类资源已足够不需再申请 } cout<<endl; } cout<<endl<<“初始化完成“<<endl; } //安全性算法函数 void safe() { l=0; for (i=0; i<n;i++) { //i++ if (Finish[i]==0) { //逐个查找Finish[i]==0的进程 条件一 counter=0; //记数器 for (j=0; j<m; j++) { if (Work[j]>=Need[i][j]) counter=counter+1;//可用大于需求，记数 } if(counter==m) //i进程的每类资源都符合Work[j]>=Need[i][j] 条件二 { p[l]=i; //存储安全序列 Finish[i]=1; //i进程标志为可分配 for (j=0; j<m;j++) Work[j]=Work[j]+Allocation[i][j]; //释放资源 l=l+1; //记数,现在有L个进程是安全的，当L=N时说明满足安全序列 i= -1; //从第一个进程开始继续寻找满足条件一二的进程 } } } } //显示当前状态函数 void show() //函数show,输出当前资源分配情况 { int i,j; //局部变量 int All[y]; //各种资源的总数量 cout<<“当前的状态为：“<<endl; cout<<“各种资源的总数量:“<<endl; for (j=0;j<m;j++) { cout<<“ 资源“<<j<<“: “; All[j]=Available[j]; //总数量=可用的+已分配的 for (i=0;i<n;i++) All[j]+=Allocation[i][j]; cout<<All[j]<<“ “; } cout<<endl<<“当前各种资源可用的量为(available):“<<endl; for (j=0;j<m;j++) cout<<“ 资源“<<j<<“: “<<Available[j]<<“ “; cout<<endl<<“各进程已经得到的资源量(allocation): “<<endl; for (j=0;j<m;j++) cout<<＇＼t＇<<“资源“<<j; cout<<endl; for(i=0;i<n;i++) { cout<<“进程“<<i<<“:“; for (j=0;j<m;j++) cout<<＇＼t＇<<“ “<<Allocation[i][j]; cout<<endl; } cout<<endl<<“各进程还需要的资源量(need):“<<endl; for (j=0;j<m;j++) cout<<＇＼t＇<<“资源“<<j; cout<<endl; for(i=0;i<n;i++) { cout<<“进程“<<i<<“:“; for (j=0;j<m;j++) cout<<＇＼t＇<<“ “<<Need[i][j]; cout<<endl; } } //银行家算法函数 void bank() { cout<<endl<<“进程申请分配资源：“<<endl; int k=0; //用于输入进程编号 bool r=false; // 初值为假，输入Y继续申请则置为真 do{//输入请求 cout<<“输入申请资源的进程(0-“<<n-1<<“): “; cin>>k; cout<<endl; while(k>n-1) //输入错误处理 { cout<<endl<<“输入错误，重新输入：“<<endl; cout<<endl<<“输入申请资源的进程(0--“<<n-1<<“): “; cin>>k; cout<<endl; } cout<<endl<<“输入该进程申请各类资源的数量: “<<endl; for (j=0; j<m; j++) { do{ //do……while 循环判断申请输入的情况 cout<<“进程 “<<k<<“ 申请资源[“<<j<<“]的数量:“; cin>>Request[j]; cout<<endl; if(Request[j]>Need[k][j]) { //申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目） cout<<“申请大于需要量!“<<endl; cout<<“申请的资源“<<j<<“的数量为“<<Request[j]<<“,大于 进程“<<k<<“对该资源需求量“<<Need[k][j]<<“。“<<endl; cout<<“重新输入!“<<endl; } else //先判断是否申请大于需求量，再判断是否申请大于可利用量 if(Request[j]>Available[j]) { //申请大于可利用量， 应该阻塞等待？…… ？？？ cout<<“＼n没有那么多资源，目前可利用资源“<<j<<“数量为“<<Available[j]<<“,本次申请不成功，进程等待!“<<endl; Finish[k]=0; //该进程等待 goto ppp; //goto语句 跳转，结束本次申请 } }while(Request[j]>Need[k][j]); //Request[j]>Available[j]|| } //改变Avilable、Allocation、Need的值 for (j=0; j<m; j++) { 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]; } //判断当前状态的安全性 safe(); //调用安全性算法函数 if (l<n) { l=0; cout<<“＼n试分配后，状态不安全,所以不予分配!恢复原状态“<<endl; //恢复数据 for (j=0; j<m; j++) { 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]; } for (i=0; i<n; i++) Finish[i]=0; //进程置为未分配状态 } else { l=0; cout<<“＼n申请资源成功!!!“<<endl; for(j=0;j<m;j++) { if(Need[k][j]==0); else { //有一种资源还没全部申请到，则该进程不可执行，不能释放拥有的资源 l=1; //置l为1，作为判断标志 break; } } if(l!=1) { //进程可以执行，则释放该进程的所有资源 for (j=0;j<m;j++) { Available[j]=Available[j]+Allocation[k][j]; Allocation[k][j]=0; } cout<<“该进程已得到所有需求资源，执行后将释放其所有拥有资源！“<<endl; } l=0; //归零 cout<<“＼n安全的状态!“<<endl; cout<<“安全序列为: “; cout<<endl<<“进程“<<“(“<<p[0]<<“)“; //输出安全序列，考虑显示格式，先输出第一个 Finish[0]=0; for (i=1; i<n; i++) { cout<<“==>>“<<“进程“<<“(“<<p[i]<<“)“; Finish[i]=0; //所有进程置为未分配状态 } cout<<endl<<endl; } show(); //显示当前状态 ppp: //申请大于可利用量， 应该阻塞等待,结束本次资源申请，GOTO 语句跳转至此 cout<<endl<<“是否继续申请资源(y/n) ?“; char* b=new char; //输入y/n，判断是否继续申请 <<endl cin>>b; cout<<endl; cout<<“-------------------------------------------“<<endl<<endl; cout<<endl; if(*b==＇y＇||*b==＇Y＇) r=true; else //{ r=false; //输入非 Y 则令 R =false // jieshu(); //调用结束函数 //} } while (r==true); } //结束函数 //void jieshu() //{ // cout<<endl<<endl; // cout<<“＼t＼t 演示计算完毕“<<endl; // cout<<endl<<endl; //} //主函数 int main() { cout<<endl<<endl<<“＼t＼t＼t＼t模拟银行家算法“<<endl<<endl; chushihua(); //初始化函数调用 cout<<endl; show(); //输出当前状态 safe(); //判断当前状态的安全性 if (l<n) //l在safe中是用来记录安全的进程的个数的 { cout<<“＼n当前状态不安全，拒绝申请！“<<endl; cout<<endl; return 0; } else { int i; //局部变量 l=0; cout<<endl<<“＼n当前的状态是安全的!安全序列为:“<<endl; cout<<“进程“<<“(“<<p[0]<<“)“; //输出安全序列 for (i=1; i<n; i++) cout<<“->>“<<“进程“<<“(“<<p[i]<<“)“; for (i=0; i<n; i++) Finish[i]=0; //所有进程置为未分配状态 cout<<endl; } bank(); //调用银行家算法函数 cout<<“＼t＼t 演示计算完毕“<<endl; return 0; } 4）运行结果分析 1．示例数据 进程数量：5 资源种类3 资源情况 进程 Max Allocation Need Available A B C A B C A B C A B C P0 7 5 3 0 1 0 7 4 3 3 3 2 (2 3 0) P1 3 2 2 2 0 0 (3 0 2) 1 2 2 (0 2 0) P2 9 0 2 3 0 2 6 0 0 P3 2 2 2 2 1 1 0 1 1 P4 4 3 3 0 0 2 4 3 1 2.测试结果（以上表中数据为列） 截图如下：
5）设计小结 这次我做的课题是“银行家算法的模拟实现”，通过这次的课程设计，我不仅拓宽了自己的知识面，还在实践过程中巩固和加深了自己所学的理论知识，使自己的技术素质和实践能力有了进一步的提高，同时我的专业水平也有了很大的进步。

同时，在软件开发方面也累积了不少经验，对操作系统的知识重要性的认识更深了。通过设计过程的锻炼，自己分析问题和解决问题的能力都得到了锻炼和提高，完善了自己的知识结构，加深了对所学知识的理解。

通过几天努力，这次课程设计圆满的结束了，在这个过程中，我学到了很多的知识，在以后的学习中，我会更加努力的学好专业知识，并将所学知识用于实践当中去，以便牢固掌握知识。

6）参考文献 [1]计算机操作系统(第3版)，汤小丹，西安电子科技大学出版社，2007年7月 [2]Visual C++面向对象编程教程（第二版），王育坚，清华大学出版社，2007年10月）