银行家算法课程设计报告.docx

银行家算法课程设计报告.docx

《银行家算法课程设计报告.docx》由会员分享，可在线阅读，更多相关《银行家算法课程设计报告.docx（20页珍藏版）》请在冰豆网上搜索。

银行家算法课程设计报告

中南大学

软件技术课程设计报告

课程名称：

模拟银行家算法原理

班级：

学号：

姓名：

指导老师：

2009年5月2日

一设计目的

模拟实现银行家算法，用银行家算法实现资源分配。

二问题描述

在死锁的避免中，银行家算法把系统状态分为安全状态和不安全状态，只要能使系统始终处于安全状态，便可以避免发生死锁。

所谓安全状态，是指系统能按某种顺序为每个进程分配所需资源，直到最大需求，使每一个进程都可以顺利完成，即可找到一个安全资源分配序列。

模拟实现这个工作过程。

三设计思路

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。

操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。

当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。

若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

四详细设计

1、初始化

由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。

2、银行家算法

在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。

在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。

设进程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）系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

（5）对于某一进程i，若对所有的j，有NEED[i][j]=0，则表此进程资源分配完毕，应将占用资源释放。

3、安全性检查算法

（1）设置两个工作向量Work=AVAILABLE;FINISH

（2）从进程集合中找到一个满足下述条件的进程，

FINISH==false;

NEED<=Work;

如找到，执行（3）；否则，执行（4）

（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。

Work+=ALLOCATION;

Finish=true;

GOTO2

（4）如所有的进程Finish=true，则表示安全；否则系统不安全。

4、流程图

开始

录入请求资源数

REQUEST[i]>NEED[i]或者

REQUEST[i]>AVAILABLE[i]

报错，重新输入

AVAILABLE[i]-=REQUEST[i];ALLOCATION[i]+=REQUEST[i];NEED[i]-=REQUEST[i];

初始化

安全性检查

安全

AVAILABLE[i]+=REQUEST[i];ALLOCATION[i]-=REQUEST[i];NEED[i]+=REQUEST[i];

保持原分配

进程执行完

释放资源

继续分配

结束

YES

NO

YES

NO

YES

YES

NO

NO

四源程序：

#include

#include

#include

//#include

//#include

usingnamespacestd;

#defineMAXPROCESS50/*最大进程数*/

#defineMAXRESOURCE100/*最大资源数*/

intAVAILABLE[MAXRESOURCE];/*可用资源数组*/

intMAX[MAXPROCESS][MAXRESOURCE];/*最大需求矩阵*/

intALLOCATION[MAXPROCESS][MAXRESOURCE];/*分配矩阵*/

intNEED[MAXPROCESS][MAXRESOURCE];/*需求矩阵*/

intREQUEST[MAXPROCESS][MAXRESOURCE];/*进程需要资源数*/

intSUMMIT[MAXRESOURCE]={0};/*各种资源总量*/

intNEEDc[MAXRESOURCE]={0};/*辅助向量*/

boolFINISH[MAXPROCESS];/*系统是否有足够的资源分配*/

intp[MAXPROCESS];/*记录序列*/

intm,n;/*m个进程,n个资源*/

voidInit（）;

boolSafe（）;

voidBank（）;

voidmain（）

{

//textbackground（0）;/*设置屏幕背景色*/

Init（）;

Safe（）;

Bank（）;

}

voidInit（）/*初始化算法*/

{inti,j;

cout<<""<

cout<<"银行家算法模拟"<

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

cout<<"通信0602唐敏0401060223"<

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

cout<<""<

cout<<"算法简介：

"<

cout<<"在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意"<

cout<<"的系统性能。

在该方法中把系统的状态分为安全状态和不安全状态，只要"<

cout<<"能使系统始终都处于安全状态，便可以避免发生死锁"<

cout<<"银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是"<

cout<<",才分配。

它是最具有代表性的避免死锁的算法。

"<

cout<<""<

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

cout<<""<

cout<<"请稍候...6秒后跳入主界面"<

Sleep（6000）;

system（"cls"）;

cout<<""<

cout<<"运行界面"<

cout<<">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"<

cout<<"请输入进程的数目:

"<

cin>>m;

cout<<"请输入资源的种类:

"<

cin>>n;

cout<<"请输入每个进程最多所需的各资源数,按照"<

for（i=0;i

for（j=0;j

cin>>MAX[i][j];

cout<<"请输入每个进程已分配的各资源数,也按照"<

for（i=0;i

{

for（j=0;j

{

cin>>ALLOCATION[i][j];

NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];

if（NEED[i][j]<0）

{

cout<<"您输入的第"<

"<

j--;

continue;

}

}

}

for（j=0;j

{

for（i=0;i

NEEDc[j]=ALLOCATION[i][j]+NEEDc[j];

}

//for（i=0;i

//{

//cout<<""<

//}

cout<<"请输入各个资源现有的数目:

"<

for（i=0;i

{

cin>>AVAILABLE[i];

}

for（i=0;i

{

SUMMIT[i]=AVAILABLE[i]+NEEDc[i];

}

//for（i=0;i

//cout<<""<

//cout<<""<

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

cout<<"初始化后状态显示:

"<

cout<<"每个进程最多所需的各资源数"<

for（i=0;i

{for（j=0;j

cout<<""<

if（j=n-1）

cout<<""<

}

cout<<"每个进程已分配的各资源数"<

for（i=0;i

{for（j=0;j

cout<<""<

if（j=n-1）

cout<<""<

}

cout<<"各个资源现有的数目:

"<

for（i=0;i

cout<<""<

cout<<""<

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

}

voidBank（）/*银行家算法*/

{

inti,j,cusneed;

charagain;

intsum=0;/*监测某一进程资源是否分配完毕*/

intadd=0;

while

（1）

{

cout<<"请输入要申请资源的进程号（注:

第1个进程号为0,依次类推）"<

cin>>cusneed;

cout<<"请输入进程所请求的各资源的数量"<

for（i=0;i

{

cin>>REQUEST[cusneed][i];

//}

//for（i=0;i

//{

if（REQUEST[cusneed][i]>NEED[cusneed][i]）

{

cout<<"您输入的本个请求数超过进程的需求量!

请重新输入!

"<

i--;

continue;

}

if（REQUEST[cusneed][i]>AVAILABLE[i]）

{

cout<<"您输入的本个请求数超过系统有的资源数!

请重新输入!

"<

i--;

continue;

}

}

for（i=0;i

{

AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

}

if（Safe（））

{

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

cout<<"同意分配请求!

"<

cout<<"此次分配后状态显示:

"<

cout<<"当前每个进程最多尚需的各资源数"<

for（i=0;i

{for（j=0;j

cout<<""<

if（j=n-1）

cout<<""<

}

cout<<"当前每个进程已分配过的各资源数"<

for（i=0;i

{for（j=0;j

cout<<""<

if（j=n-1）

cout<<""<

}

for（i=0;i

for（j=0;j

add=NEED[i][j]+add;//是否已分配完毕

if（add!

=0）

{

for（i=0;i

sum=NEED[cusneed][i]+sum;

cout<<"sum值:

"<

//cout<<""<

cout<<""<

if（sum==0）

{for（i=0;i

AVAILABLE[i]=ALLOCATION[cusneed][i]+AVAILABLE[i];

}

sum=0;

cout<<"各个资源现有的数目:

"<

for（i=0;i

cout<<""<

cout<<""<

add=0;

}

//cout<<""<

else

{

cout<<"各个资源现有的数目:

"<

for（i=0;i

cout<<""<

cout<<""<

}

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<

}

else

{

cout<<"您的请求被拒绝!

"<

for（i=0;i

{

AVAILABLE[i]+=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];

NEED[cusneed][i]+=REQUEST[cusneed][i];

}

}

for（i=0;i

{

FINISH[i]=false;

}

cout<<"您还想再次请求分配吗?

是请按y/Y,否请按其它键"<

cin>>again;

if（again=='y'||again=='Y'）

{

continue;

}

break;//跳出while

}

}

boolSafe（）/*安全性算法*/

{

inti,j,k,l=0;

intWork[MAXRESOURCE];/*工作数组*/

for（i=0;i

Work[i]=AVAILABLE[i];

for（i=0;i

{

FINISH[i]=false;

}

for（i=0;i

{

if（FINISH[i]==true）

{

continue;

}

else

{

for（j=0;j

{

if（NEED[i][j]>Work[j]）

{

break;

}

}

if（j==n）

{

FINISH[i]=true;//FINISH在此被赋值,表进程i可顺利进行

for（k=0;k

{

Work[k]+=ALLOCATION[i][k];

}

p[l++]=i;

i=-1;//再从i=0开始判断

}

else

{

continue;

}

}

if（l==m）//所有进程都可完成

{

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

cout<<"安全序列:

"<

for（i=0;i

{

cout<

if（i!

=l-1）//最后一项不输-->

{

cout<<"-->";

}

}

cout<<""<

returntrue;

}

}

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

returnfalse;

}

五运行调试及结果说明

初始化时若已分配资源多于最多所需资源则会报错，需重新输入（如上图所示）

初始化后状态显示

资源分配时请求量超过需求量或现有资源数同样会报错（如上图）

特殊情况：

若申请资源数既不大于资源需求量，又不大于现有资源数，但仍有可能导致死锁，如上图所示。

此时会显示系统不安全，请求被拒绝。

（为便于说明，以上均采用二阶矩阵。

其他类型矩阵原理相同）

Sum=0，表某一进程资源分配完毕，资源释放（请结合第四个图）

六总结

本次设计中首先要解决的问题是对所做题目的理解。

简单的文字描述总是生涩难懂，像银行家算法这一问题，如果单看题目要求往往不知如何下手，更不要谈下一步的设计过程。

但倘若联系实际生活中银行贷款这一现象，再来看问题时，一切开始显得清晰，再加上老师的指点，便可以把自己究竟该作何工作搞清楚。

这也给我一启示，我们要解决的诸多问题都源自生活，若要解决它，联系实际是个很不错的选择。

明白了需求，下一个难点是如何通过软件实现。

我所做的银行家算法这一题目，为了防止死锁，需要进行大量的判断，这也导致了一个问题，即在进行调试时，一旦出现问题，往往难以找到问题所在，针对这一问题，我编写了一些监测行（请参看源程序），这样能比较容易的找到问题的原因所在，这也是此次课程设计中在编程方面的一个收获。

通过本次课程设计，我对软件的开发的过程有了较为深入的了解，虽然只是对一个问题的简单模拟，但麻雀虽小五脏俱全，我对相关问题的解决已经有了一定的认识，对软件技术这门课程也有了更为透彻的感悟。

本次课程设计，锻炼了我分析问题和解决问题的能力，为今后相关问题的解决积累了宝贵经验，也增强了自己的耐心与自信，受益匪浅。