操作系统课程设计银行家算法设计.docx

操作系统课程设计银行家算法设计.docx

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

操作系统课程设计银行家算法设计

《操作系统》

课程设计报告

系别：

信息科学与技术系

专业班级：

学生姓名：

指导教师：

（课程设计时间：

2010年7月5日——2010年7月9日）

一、课程设计目的和意义

了解掌握银行家算法，学会模拟实现资源分配，同时有要求编写和调试一个系统分配资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生

二、课程设计题目描述及算法

题目：

银行家算法设计

设计要求：

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

设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。

（1）如果Request[N]<=NEED[I，N]，则转

（2）；否则，出错。

（2）如果Request[N]<=AVAILABLE，则转（3）；否则，出错。

（3）系统试探分配资源，修改相关数据：

AVAILABLE=AVAILABLE-REQUEST

ALLOCATION=ALLOCATION+REQUEST

NEED=NEED-REQUEST

（4）系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

上述三个矩阵存在如下关系：

Need[i,j]=Max[i，j]-Allocation[i，j]

三、课程设计报告内容

1.算法描述

设Request[i]是进程Pi的请求向量，如果Requesti[j]=K,表示进程Pi需要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等待。

2.数据结构

（1）可利用资源向量Available。

这是一个含有n个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。

如果Available[j]=K,则表示系统中现有Rj类资源K个。

（2）最大需求矩阵Max。

这是一个m*n的矩阵，它定义了系统中n个进程中每一个进程对m类资源的最大需求。

如果Max[i,j]=K,则表示进程i需要Rj类资源的最大数目为K。

（3）分配矩阵Allocation。

这也是一个m*n的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。

如果Allocation[i,j]=K,则表示进程i当前已分得Rj类资源的数目为K。

（4）需求矩阵Need。

这也是一个n*m的矩阵，用以表示每一个进程尚需的各类资源数。

如果Need[i,j]=K,则表示进程i还需要Rj类资源K个，方能完成其任务。

（5）工作数组Work.。

这是一个含有n个元素的数组，它代表可以提供分配的资源数，初始值是Available中的数值，随着资源的回收，它的值也会改变，公式是Work[i]=Work[i]+Allocation[i]。

3.主要函数说明

（1）Main（）主函数：

用来显示资源的分配情况和提示信息，同时用Main函数来调用其它子程序。

（2）Safe（）函数：

用来检查是否有安全序列，如果存在则返回一个‘1’给主函数，否则返回‘0’。

（3）Disp（）函数：

用来显示随机生成的资源包括Max、Need、Allocation、Available。

（4）Request（）函数：

用来进行资源请求，分为手动的和随机申请。

同时对申请的资源进行判断，检查申请是否有效，如果有效则返回一个‘1’给主函数，否则返回‘0’。

4.算法流程图

N

Y

Y

N

Y

Y

Y

Y

5.运行结果及说明

图1不存在安全序列

随机分配完资源后，进行安全检查，在检查过程中在屏幕上显示检查信息，上图为资源分配不安全时显示的信息。

若在程序中不将inti,j,k,h,l;改为intI;在检查Available是否满足Need时将检查m*n遍，并存在表达有歧异，改后就不需要全部检查，而是Available只要有一个不满足Need就停止检查。

图2存在安全路径

存在安全路径后，在屏幕上显示变化过程和安全路径。

提示是否申请资源。

由上图可知，进程p0最大需要的三种资源数分别为1079，需求资源数为431，当前已分配资源数为648，可利用资源数为11611。

p1、p2同理。

三个矩阵存在如下关系:

Need[i,j]=Max[i，j]-Allocation[i，j]

process[0]->need[0]

work[0]=17—已分配资源数6，可分配资源数11，则最大分配数17

同理work[1]=10、work[2]=19

Process[0]->need[1]

Work[0]=22—已分配资源数5，可分配17，则总可分配资源数22

后面的同理。

图3为申请资源

选择1则进行随机资源分配，选择2则进行手动资源分配。

图4手动分配

为保证程序只在选择的数为0、1或2时继续进行，使用If语句进行判断，不是选择的这三个进程数时终止程序并提示重新输入。

图5给p0手动配后生成的图形

与

图6随机分配生成的图形

比较

当手动输入的数小于所需资源数时，所需数减小，已分配数增多，p0原需要431，手动分配121后，为310，已分配变为769，p1、p2同理；当手动资源数为442时，need为000，但allocation为10811，并不等于1079，出现错误。

图7随机分配

当选择1时，进行随机分配，随机分配的资源数为321，无法满足需要，产生错误。

6.附录清单及分析

#include

#include

#include

#defineM3

#defineN3

intNeed[M][N],Allocation[M][N],Avalible[N],Max[M][N],finish[N];

//Need:

进程需要的资源数Allocation:

进程已分配的资源;Avalible:

进程可供分配的资源

voiddisplay（int*a,intn）//显示一维数组

{inti;

for（i=0;i

printf（"%3d",a[i]）;

}

voiddisp（）//显示资源列表

{inti;//--原为inti,j,k,h,l，改后Available只要有一个不满足Need就停止检查;

printf（"Nnumber\tMax\t\tneed\t\tallocation\tavalible\n"）;

for（i=0;i

{printf（"p%d\t",i）;//--分别显示P0,P1,P2的Max,Need,Allocation,Avalible

display（Max[i],N）;

printf（"\t"）;

display（Need[i],N）;

printf（"\t"）;

display（Allocation[i],N）;

printf（"\t"）;

if（i==0）

display（Avalible,N）;

printf（"\n"）;

}}

voidgrand（int*a,int*b,intn）//分配资源

{inti;

for（i=0;i

a[i]=b[i];

}

intcheck（int*a,int*b,intn）//检查Allocation是否与Max相等

{inti;

for（i=0;i

{if（a[i]

return1;

}

intcompare（int*a,int*b,intn）//比较数组的大小

{inti;

;//原本为charflag

for（i=0;i

{if（a[i]

return0;

}

return1;

}

intcomp（int*a,int*b,intn,intm）//比较数组

{inti;

for（i=0;i

{if（a[i]>b[i]）

{if（m==1）

printf（"requestNumber%dresoucehaveanerrorrequestoverflowavalible[%d]\n",i+1,i）;

if（m==2）

printf（"requestNumber%dresoucehaveanerrorrequestoverflowNeed[%d]\n",i+1,i）;

return0;}}

return1;

}

voiddec（int*a,int*b,intn）//数组相减

{inti;

for（i=0;i

a[i]-=b[i];

}

charinput（）//输入数据

{charc;

c=getchar（）-0x30;

returnc;

}

voidadd（int*a,int*b,intn,intm）//数组相加

{inti;

for（i=0;i

a[i]+=b[i];

for（i=0;i

{if（m==0）printf（"Avalible[%d]=%d",i,a[i]）;

if（m==3）printf（"\n"）;

if（m==1）printf（"workvaluesechangedwork[%d]=%d\n",i,a[i]）;

}

printf（"\n"）;

}

intsafe（）//检查安全序列

{inti,count=0,n,r1=1;//原为inti,count=0,n,j,r1=1;

intwork[N],sr[M],flag;

intfinish1[N];

grand（work,Avalible,N）;

printf（"checksafelist......\n"）;

for（i=0;i

finish1[i]=-1;

for（n=0;n

{for（i=0;i

{flag=compare（work,Need[i],N）;

if（flag==0）{printf（"can'tsatisfyprocess[%d]->need[%d]",n,i）;break;}

if（finish1[i]==-1&&flag==1&&finish[i]==-1）

{printf（"findarightneed----process[%d]->need[%d]\n",n,i）;

add（work,Allocation[i],N,r1）;

finish1[i]=1;sr[count]=i;

count++;//记录安全序列

}}}

if（count>=M）

{printf（"-----haveansafelist-----\n"）;

for（i=0;i

{if（i!

=M-1）

printf（"p%d->",sr[i]）;

else

printf（"p%d\n",sr[i]）;

}return1;}

else

{printf（"afterchecktherenosafelist.....\n"）;

printf（"can'tapplyresouce\n"）;

return0;

}}

intran_request（）//随机请求资源

{inti,flag1,flag2,r1=1,r2=2,r3=3;

intrequest[N],pn;//N=3

pn=rand（）%2;//pn进程标志

printf（"Process[%d]callforresouce\n",pn）;//随机进程X请求资源

for（i=0;i

request[i]=rand（）%5;//将随机资源给request[i],i=1,2,3,其实request是现在将要给予的资源

//而且request[1],[2],[3]即代表3种不同的资源类型

for（i=0;i

finish[i]=-1;

printf（"randomproducerequest[%d]:

",N）;//随机产生分配数

display（request,N）;//显示request[]数组

printf（"\n"）;

if（finish[pn]==-1）//finish记录进程是否分配完成

{

flag1=comp（request,Avalible,N,r1）;//flag1

flag2=comp（request,Need[pn],N,r2）;//flag2

if（flag1==1&&flag2==1）

{

printf（"callforrequestavailible"）;//显示需求有效

dec（Avalible,request,N）;//Avalible-request,指针形式，下2同

dec（Need[pn],request,N）;//Need-request

add（Allocation[pn],request,N,r3）;//Allocation+request

disp（）;

if（safe（）==1）

{

if（check（Allocation[pn],Max[pn],N）==1）

{

add（Avalible,Allocation[pn],N,0）;

finish[pn]=1;

}

return1;

}

else

return0;

}

}

else

printf（"theresoucehaveassingned\n"）;

}

intrequest（）//手动申请资源

{intrequest[N],pn;

inti,flag1,flag2,r1=1,r2=2,r3=3;

for（i=0;;i++）

{

printf（"pleaseinputtherequestnumberwhichyouwant:

"）;

scanf（"%d",&pn）;

printf（"\n"）;

if（pn>=0&&pn<=2）break;

else

printf（"inputerror,pleaseinputagain!

\n"）;//非进程数0、1、2警告

}

printf（"pleaseinputtherequestnumber:

\n"）;

for（i=0;i

{

printf（"The%drequest:

\n",i）;

scanf（"%d",&request[i]）;

}

for（i=0;i

finish[i]=-1;

printf（"randomproducerequest[%d]:

",N）;

display（request,N）;

printf（"\n"）;

if（finish[pn]==-1）//finish记录进程是否分配完成

{

flag1=comp（request,Avalible,N,r1）;//flag1

flag2=comp（request,Need[pn],N,r2）;//flag2

if（flag1==1&&flag2==1）

{

printf（"callforrequestavailible"）;//显示需求有效

dec（Avalible,request,N）;//Avalible-request,指针形式，下2同

dec（Need[pn],request,N）;//Need-request

add（Allocation[pn],request,N,r3）;//Allocation+request

disp（）;

if（safe（）==1）

{

if（check（Allocation[pn],Max[pn],N）==1）

{

add（Avalible,Allocation[pn],N,0）;

finish[pn]=1;

}

return1;

}

else

return0;

}

}

else

printf（"theresoucehaveassingned\n"）;

}

intmain（）

{inti,j,s_flag;

charc,s;

intav[N],s_ll[M][N];

for（i=0;i

{finish[i]=-1;}

srand（time（NULL））;

for（i=0;i

for（j=0;j

{Allocation[i][j]=rand（）%10;

Need[i][j]=rand（）%10;

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

}

for（i=0;i

{Avalible[i]=rand（）%12;}

disp（）;s_flag=safe（）;

if（s_flag==1）

{printf（"requestresource---（Y/N）\n"）;

c=getchar（）;

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

{

N1:

printf（"1---------randomrequestresouce\n"）;

printf（"2---------requestresoucebyman\n"）;

grand（av,Avalible,N）;//保存原始的available的值

for（i=0;i

{

grand（s_ll[i],Allocation[i],N）;}//grand函数为分配资源函数

getchar（）;

Mnu:

s=getchar（）;

switch（s）//进行分配选择

{

case'1':

if（ran_request（）==1）//ran_request（）随机请求资源

{

printf（"continuerequest（Y/N）\n"）;

getchar（）;c=getchar（）;

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

gotoN1;}

else

{

grand（Avalible,av,N）;

for（i=0;i

grand（Allocation[i],s_ll[i],N）;}

//grand（int*a,int*b,intn）/为分配资源函数，b按n大小赋值于a

break;

case'2':

if（request（）==1）//--request（）手动申请资源

{

printf（"continuerequest（Y/N）\n"）;

getchar（）;c=getchar（）;

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

gotoN1;}

else

{

grand（Avalible,av,N）;//grand（int*a,int*b,intn）

//为分配资源函数，b按n大小赋值于a

for（i=0;i

grand（Allocation[i],s_ll[i],N）;}

break;

default:

printf（"inputerror,pleaseinputagin...\n"）;gotoMnu;

}}

if（c=='N'||c=='n'）

printf（"Thankforyouruse....\n"）;}

return0;}

六、总结

通过这次的课程设计，我了解掌握了银行家算法，学会模拟实现资源分配，同时通过编写和调试一个系统分配资源的简单模拟程序，观察到了死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生。

虽然操作系统是以前学的，再接触时遗忘了许多，但是通过老师的讲解，同学的帮助，自己也仔细地看了这次课程设计的实验指导，捡回了许多东西，对于银行家算法的设计、编写的思路变得清晰。

通过几天反复的阅读实验指导，仔细的思考出现的问题，反复推敲、测试与修改，终于能完满的完成课程设计任务。

课程设计的时间虽然不长，但带了给我知识，也带给了我战胜困难、完成任务的欢乐。

希望以后有更多的机会接触这类的课程设计。

课程设计成绩:

项目

业务考核成绩（70%）

（百分制记分）

平时成绩（30%）

（百分制记分）

综合总成绩

（百分制记分）

注:

教师按学生实际成绩（平时成绩和业务考核成绩）登记并录入教务MIS系统，由系统自动转化为“优秀（90～100分）、良好（80～89分）、中等（70～79分）、及格（60～69分）和不及格（60分以下）”五等。

指导教师评语:

指导教师（签名）:

20年月日