华工2016春操作系统大作业银行家死锁避免算法模拟(含源文件)

华南理工

“计算机操作系统”课程设计大作业

一、实验题目: 银行家死锁避免算法模拟

二、实验目的：通过本次实验掌握银行家死锁避免算法的基本思想。当进程提出资源申请时，能够用该算法判断是否拒绝进程请求。

三、实验内容

认真阅读教材（计算机操作系统（第三版），汤小丹，西安电子科技大学出版社）P108-P111页3.6.3节银行家算法的实现思想，理解该算法是如何能够实现死锁避免的。编写一个银行家算法模拟程序用于处理进程的资源申请。

1。假设系统共有5类资源，分别以A、B、C、D、E来标识，每类资源的初始数量全部为50。

2。进程可以通过程序界面随时提交新的资源申请，提交的信息包括进程名称、对5类资源的最大需求数量。

3。每次当有资源申请时，先输出系统当前状态（5类资源当前可用数量，每个进程已分配的每类资源数量），再利用银行家算法判断是否该满足进程请求。如果可以分配，输出给该进程分配资源后的系统状态，再输出至少一个“安全序列”。

四、实验要求：

每人完成一份大作业实验报告。报告分设计思想、数据定义、处理流程、源程序、运行结果截图、设计体会等部分。

1）给出数据定义和详细说明；

2）给出实现思想和设计流程；

3）调试完成源程序；

4）屏幕观察运行结果；

5）总结自己的设计体会；

编程语言及操作系统平台不限。

五、提交内容

本大作业每个人必须单独完成。最后需提交的内容包括：源程序（关键代码需要注释说明）、可运行程序、算法思路及流程图、心得体会。将以上内容刻入光盘，光盘上写明班级、学号、姓名信息，再将大作业要求、源程序及注释、算法思路及流程图、心得体会等打印出来。最后将打印稿及光盘统一交给网络学院教务员。

银行家算法实现

一．课程设计目的

1. 加深对死锁概念的理解。

2. 能够利用银行家算法，有效避免死锁的发生，或检测死锁的存在。

二．课程设计摘要

银行家算法：

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

三．开发环境

系统软件硬件环境

软件：Windows 7; VC++ 6.0

硬件：CPU 2.40GHz;2G内存

四．课程设计原理分析

在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险——死锁。所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵局状态时，若无外力作用，它们都将无法再向前推进。为保证系统中诸进程的正常运行，应事先采取必要的措施，来预防死锁。最有代表性的避免死锁的方法，是Dijkstra 的银行家算法。

死锁：

死锁的产生，必须同时满足四个条件，第一个为互斥条件，即一个资源每次只能由一个进程占用；第二个为请求和保持条件，指进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源又被其他进程占有，此时请求进程阻塞，但又对自己已获得的其他资源保持不放；第三个为非剥夺条件，即在出现死锁的系统中一定有不可剥夺使用的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一个进程所持有的资源。防止死锁的机构只能确保上述四个条件之一不出现，则系统就不会发生死锁。

银行家算法原理：

银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。通过这个算法可以用来解决生活中的实际问题，如银行贷款等。

银行家算法，顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行家资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。把一个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。显然，，每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以

避免死锁.

算法思想：

将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。

用银行家算法分配资源时，测试进程对资源的最大需求量，若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。

五.算法实现

1.程序流程图：

2.

2.算法描述：

银行家算法的设计思想是：当用户申请一组资源时，系统必须做出判断；如果把这些资源分出去，系统是否还处于安全装他。若是，就可以分出这些资源；否则，该申请暂不能满足。

3.数据结构描述：（n表示系统中进程的数目，m表示资源的分类数。）

3.1. Available是一个长度为m的向量，它表示每类资源可用的数量。Available [j]=k，表示rj类资源可用的数量为k。

3.2.Max是一个n×m矩阵，它表示每个进程对资源的最大需求。Max [i，j]=k，表示进程pi至多可以申请k个rj类资源单位。

3.3. Allocation是一个n×m矩阵，它表示当前分给每个进程的资源数目。Allocation [i，j]=k，表示进程pi当前分到k个rj类资源。

3.4. Need是一个n×m矩阵，它表示每个进程还缺少多少资源。Need[i，j]=k，表示进程pi尚需k个rj类资源才能完成其任务。显然Need[i，j]= Max [i，j]- Allocation [i，j]。

这些数据结构的大小和数值随时间推移而改变。

4.系统所执行的安全性算法描述如下：

4.1.设置2个向量：工作向量Work：它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work = Available。

Finish[i] ：它表示系统是否有足够的资源分配给进程，使之完成运行。开始时先做Finish[i]=true。

4.2.从进程集合中找到一个满足下述条件的进程：Finish[i]=flase；Need[i,j]≤Work[j]；若找到，则执行步骤3，否则，执行步骤4。

4.3.当进程pi获得资源后，可顺利执行，直至完成，并释放分配给它的资源。

4.4.如果所有进程的Finish[i]=true都满足。则表示系统处于安全状态；否则，系统处于不安全状态。

六.程序源代码

#include

#include

#include

using namespace std;

#define False 0

#define True 1

int Max[100][100]={0};//各进程所需各类资源的最大需求

int Avaliable[100]={0};//系统可用资源

char name[100]={0};//资源的名称

int Allocation[100][100]={0};//系统已分配资源

int Need[100][100]={0};//还需要资源

int Request[100]={0};//请求资源向量

int temp[100]={0};//存放安全序列

int Work[100]={0};//存放系统可提供资源

int M=100;//作业的最大数为100

int N=100;//资源的最大数为100

void showdata()//显示资源矩阵

{

int i,j;

cout<<"系统目前可用的资源[Avaliable]:"<

for(i=0;i

cout<

cout<

for (j=0;j

cout<

cout<

cout<<" Max Allocation Need"<

for(j=0;j<3;j++){

for(i=0;i

cout<

cout<<" ";

}

cout<

for(i=0;i

cout<<" "<

for(j=0;j

cout<

cout<<" ";

for(j=0;j

cout<

cout<<" ";

for(j=0;j

cout<

cout<

}

}

int changdata(int i)//进行资源分配

{

int j;

for (j=0;j

Avaliable[j]=Avaliable[j]-Request[j];

Allocation[i][j]=Allocation[i][j]+Request[j]; Need[i][j]=Need[i][j]-Request[j];

}

return 1;

}

int safe()//安全性算法

{

int i,k=0,m,apply,Finish[100]={0};

int j;

int flag=0;

Work[0]=Avaliable[0];

Work[1]=Avaliable[1];

Work[2]=Avaliable[2];

for(i=0;i

apply=0;

for(j=0;j

if (Finish[i]==False&&Need[i][j]<=Work[j]){ apply++;

if(apply==N){

for(m=0;m

Work[m]=Work[m]+Allocation[i][m];//变分配数 Finish[i]=True;

temp[k]=i;

i=-1;

k++;

flag++;

}

}

}

}

for(i=0;i

if(Finish[i]==False){

cout<<"系统不安全"<

return -1;

}

}

cout<<"系统是安全的!"<

for(i=0;i

cout<

if(i";

}

cout<

return 0;

}

void share()//利用银行家算法对申请资源对进行判定

{

char ch;

int i=0,j=0;

ch='y';

cout<<"请输入要求分配的资源进程号(0-"<

cin>>i;//输入须申请的资源号

cout<<"请输入进程 "<

for(j=0;j

{

cout<

cin>>Request[j];//输入需要申请的资源

}

for (j=0;j

if(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();//根据进程需求量进行银行家算法判断

}

}

void addresources(){//添加资源

int n,flag;

cout<<"请输入需要添加资源种类的数量:";

cin>>n;

N=N+n;

for(int i=0;i

cout<<"名称:";

cin>>name[flag];

cout<<"数量:";

cin>>Avaliable[flag++];

}

showdata();

safe();

}

void changeresources(){//修改资源函数

cout<<"系统目前可用的资源[Avaliable]:"<

cout<>Avaliable[0]>>Avaliable[1]>>Avaliable[2]; cout<<"经修改后的系统可用资源为"<

for (int k=0;k

cout<

safe();

}

void delresources(){//删除资源

char ming;

int i,flag=1;

cout<<"请输入需要删除的资源名称：";

do{

cin>>ming;

for(i=0;i

if(ming==name[i]){

flag=0;

break;

}

if(i==N)

cout<<"该资源名称不存在，请重新输入：";

}

while(flag);

for(int j=i;j

{

name[j]=name[j+1];

Avaliable[j]=Avaliable[j+1];

}

showdata();

safe();

}

void addprocess(){//添加作业

int flag=M;

M=M+1;

cout<<"请输入该作业的最大需求量[Max]"<

for(int i=0;i

cout<

cin>>Max[flag][i];

Need[flag][i]=Max[flag][i]-Allocation[flag][i];

}

showdata();

safe();

}

int main()//主函数

{

for(i=0;i

for(j=0;j

cin>>Max[i][j];

do{

flag=0;

cout<<"请输入各进程已经申请的资源量("<

阵)[Allocation]:"<

for(i=0;i

for(j=0;j

cin>>Allocation[i][j];

if(Allocation[i][j]>Max[i][j])

flag=1;

Need[i][j]=Max[i][j]-Allocation[i][j];

}

if(flag)

cout<<"申请的资源大于最大需求量，请重新输入!\n";

}

while(flag);

showdata();//显示各种资源

safe();//用银行家算法判定系统是否安全

while(choice)

{

cout<<"**************银行家算法演示***************"<

cout<<" 1:增加资源 "<

cout<<" 2:删除资源 "<

cout<<" 3:修改资源 "<

cout<<" 4:分配资源 "<

cout<<" 5:增加作业 "<

cout<<" 0:离开 "<

cout<<"*******************************************"<

cout<<"请选择功能号：";

cin>>choice;

switch(choice)

{

case 1: addresources();break;

case 2: delresources();break;

case 3: changeresources();break;

case 4: share();break;

case 5: addprocess();break;

case 0: choice=0;break;

default: cout<<"请正确选择功能号(0-5)!"<

}

}

return 1;

}

调试及运行结果：

检测结果如下：

1.假设系统只有一种资源a,剩余数量为2，分配情况如下：

2.假设系统只有一种资源a,剩余数量为2，分配情况如下：

注：“系统不安全”表示此种情况是银行家算法也解不了的死锁。

3.假设系统有2种资源a,b,a的剩余数量为4，b的剩余数量为3，分

配情况如下：

七.实验总结

通过本次试验，加深了自己对于死锁问题和银行家算法的理解。对于银行家算法的思想有了更加深刻的认识，并且意识到银行家算法并不是能避免所有的死锁，可以称这种情况为潜在的死锁。

八.参考文献

《C语言程序设计》清华大学出版社

《C++语言程序设计》（第四版）清华大学出版社

《数据结构及应用C语言描述》机械工业出版社

《数据结构及应用算法教程》（修订版）清华大学出版社《操作系统原理》（第四版）华中科技大学出版社