银行家算法模拟实现.docx

资源描述

银行家算法模拟实现.docx

《银行家算法模拟实现.docx》由会员分享，可在线阅读，更多相关《银行家算法模拟实现.docx（19页珍藏版）》请在冰豆网上搜索。

银行家算法模拟实现.docx

银行家算法模拟实现

操作系统课程设计报告

专业

计算机科学与技术

学生姓名

班级

计算机科学与技术

学号

指导教师

完成日期

2014.3.20

题目：

银行家算法的模拟实现

一、设计目的

本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。

二、设计内容

1）概述

用C或C++语言编制银行家算法通用程序，并检测所给状态的系统安全性。

1.算法介绍：

数据结构：

1）可利用资源向量Available；

2）最大需求矩阵Max；

3）分配矩阵Allocation；

4）需求矩阵Need

2.功能介绍

模拟实现Dijkstra的银行家算法以避免死锁的出现，分两部分组成：

第一部分：

银行家算法（扫描）；

第二部分：

安全性算法。

2）设计原理

一．银行家算法的基本概念

1、死锁概念。

在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险━━死锁。

所谓死锁（Deadlock）,是指多个进程在运行中因争夺资源而造成的一种僵局（Deadly_Embrace）,当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。

2、关于死锁的一些结论：

参与死锁的进程最少是两个

（两个以上进程才会出现死锁）

参与死锁的进程至少有两个已经占有资源

参与死锁的所有进程都在等待资源

参与死锁的进程是当前系统中所有进程的子集

注：

如果死锁发生，会浪费大量系统资源，甚至导致系统崩溃。

3、资源分类。

永久性资源：

可以被多个进程多次使用（可再用资源）

可抢占资源

不可抢占资源

临时性资源：

只可使用一次的资源；如信号量,中断信号，同步信号等（可消耗性资源）

　　　　　　“申请--分配--使用--释放”模式

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

不安全状态:

不存在一个安全序列，不安全状态一定导致死锁。

二．银行家算法

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;

gotostep2；

4）如果所有进程的Finish[i]:

=true，则表示系统处于安全状态；否则，系统处于不安全状态。

三．银行家算法之例

假定系统中有五个进程：

{P0，P1，P2，P3，P4}和三种类型的资源{A，B，C}，每一种资源的数量分别为10、5、7,在T0时刻的资源分配情况如图1所示。

资源情况

进程

Max

Allocation

Need

Available

ABC

753

010

743

332

（230）

322

200

（302）

122

（020）

902

302

600

222

211

011

433

002

431

图1T0时刻的资源分配表

（1）T0时刻的安全性：

利用安全性算法对T0时刻的资源分配情况进行分析（如图2）可知，在T0时刻存在着一个安全序列｛P1，P3，P4，P2，P0｝，故系统是安全的。

资源情况

进程

Work

Need

Allocation

Work+Allocation

Finish

ABC

332

122

200

532

true

532

011

211

743

431

002

745

600

302

1047

743

010

1057

图2T0时刻的安全序列

（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

ABC

230

020

302

532

true

532

011

211

743

431

002

745

743

010

755

600

302

1057

图3P1申请资源时的安全性检查

由所进行的安全性检查得知，可以找到一个安全序列｛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

ABC

030

732

210

302

020

302

600

211

011

002

432

图4为P0分配资源后的有关资源数据

（5）进行安全性检查：

可用资源Available（2,1,0）已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。

3）详细设计及编码

1）银行家算法流程图

2）程序源代码

#include

#defineFalse0

#defineTrue1

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

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

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

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

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

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

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

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

intM=100;//作业的最大数为100

intN=100;//资源的最大数为100

voidshowdata（）//显示资源矩阵

{

inti,j;

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

for（i=0;i

cout<

for（j=0;j

cout<

cout<<"MaxAllocationNeed"<

cout<<"进程名";

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<

}

intchangdata（inti）//进行资源分配

{

intj;

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];

}

return1;

}

intsafe（）//安全性算法

{

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

intj;

intflag=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<<"系统是安全的!

cout<<"分配的序列:

for（i=0;i

cout<

if（i";

}

cout<

return0;

}

voidshare（）//利用银行家算法对申请资源对进行判定

{

charch;

inti=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（）;//根据进程需求量进行银行家算法判断

}

voidaddresources（）{//添加资源

intn,flag;

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

cin>>n;

flag=N;

N=N+n;

for（inti=0;i

cout<<"名称:

cin>>name[flag];

cout<<"数量:

cin>>Avaliable[flag++];

}

showdata（）;

safe（）;

}

voiddelresources（）{//删除资源

charming;

inti,flag=1;

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

do{

cin>>ming;

for（i=0;i

if（ming==name[i]）{

flag=0;

break;

}

if（i==N）

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

}

while（flag）;

for（intj=i;j

{

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

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

}

N=N-1;

showdata（）;

safe（）;

}

voidchangeresources（）{//修改资源函数

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

for（inti=0;i

cout<

cout<<"输入系统可用资源[Avaliable]:

cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];

cout<<"经修改后的系统可用资源为"<

for（intk=0;k

cout<

showdata（）;

safe（）;

}

voidaddprocess（）{//添加作业

intflag=M;

M=M+1;

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

for（inti=0;i

cout<

cin>>Max[flag][i];

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

}

showdata（）;

safe（）;

}

intmain（）//主函数

{

inti,j,number,choice,m,n,flag;

charming;

cout<<"*****************单处理机系统进程调度实现*****************"<

cout<<"请首先输入系统可供资源种类的数量:

cin>>n;

N=n;

for（i=0;i

{

cout<<"资源"<

cin>>ming;

name[i]=ming;

cout<<"资源的数量:

cin>>number;

Avaliable[i]=number;

}

cout<

cout<<"请输入作业的数量:

cin>>m;

M=m;

cout<<"请输入各进程的最大需求量（"<

for（i=0;i

for（j=0;j

cin>>Max[i][j];

do{

flag=0;

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

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）

{

case1:

addresources（）;break;

case

展开阅读全文