操作系统课程设计银行家算法.docx
《操作系统课程设计银行家算法.docx》由会员分享，可在线阅读，更多相关《操作系统课程设计银行家算法.docx（13页珍藏版）》请在冰豆网上搜索。
操作系统课程设计银行家算法
《操作系统--课程设计报告》
银行家算法
姓名：
学号：
专业：
指导老师：
一、设计目的1..
二、设计要求1..
三、设计内容和步骤1..
四、算法描述4..
五、实验结果1..1.
六、实验心得1..2.
、设计目的
银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
二、设计要求
在了解和掌握银行家算法的基础上，能熟练的处理课本例题中所给状态的安全性问题，能编制银行家算法通用程序，将调试结果显示在计算机屏幕上。
具体程序的功能要求：
1．设定进程对各类资源最大申请表示及初值确定。
2．设定系统提供资源初始状况（已分配资源、可用资源）。
3．设定每次某个进程对各类资源的申请表示。
4．编制程序，依据银行家算法，决定其申请是否得到满足。
三、设计内容和步骤
设计内容
银行家算法的思路：
先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。
若请求合法，则进行试分配。
最后对试分配后的状态调用安全性检查算法进行安全性检查。
若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。
设计步骤
1、为实现银行家算法，系统中需要设置若干数据结构，用来表示系统中各进程的资源分配及需求情况。
假定系统中有M个进程，N类资源。
进程数和资源数由程序中直接定义
#defineM5//总进程数
#defineN3//总资源数
银行家算法中使用的数据结构如下：
1）可利用资源Available。
这是一个含有m个元素的数组，其中的每一个元素代表一类资源的空闲资源数目，其初值是系统中所配置的该类资源的数目，其数值随该类资源的分配和回收而动态的改变。
如果Available[j]=k，表示系统中Rj类资源有k个。
（2）最大需求矩阵Max这是一个n*m的矩阵，它定义了系统中每一个进程对各类资源的最大需求数目。
如果Max[i，j]=k，表示进程Pi对Rj类资源的最大需求数为k个。
（3）分配矩阵Allocation。
这是一个n*m的矩阵，它定义了系统中当前已分配给每一个进程的各类资源。
如果Allocation[i,j]=k,表示进程Pi当前已分到Rj类资源有k个。
（4）需求矩阵Neec。
这是一个n*m的矩阵，它定义了系统中每一个进程
还需要的各类资源的数目。
如果Need[i，j]=k，表示进程Pi需要Rj类资源有
k个，才能完成任务。
intMax[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//每个进
程对每类资源的最大需求
intAllocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//
系统已分配资源
intAvaliable[3]={3,3,2};//系统可利用资源
intNeed[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//还需要
资源
intRequest[3];
2、实现过程
主函数
voidmain（）//主函数
{intchoice;
showdata（）;
safeAlgorithm（）;
do
{printf（"\n输入接下来你要进行的操作1：
分配资源2:
显示资源否则按任意键退出"）;
scanf（"%d",&choice）;
switch（choice）
{case1:
bankerAlgorithm（）;break;case2:
showdata（）;break;default:
break;
}}while（（choice==1）||（choice==2））;
}其中用到的函数操作有三个showdata（）;//显示资源矩阵safeAlgorithm（）;//安全性检测算法
bankerAlgorithm（）;//利用银行家算法对申请资源对进行判定
3、安全性检查
程序中安全性算法的描述如下：
（1）设置如下两个工作向量：
Work：
表示系统可提供给进程继续运行的各类资源的空闲资源数目，它含有m
个元素，执行安全性算法开始时，Work=Available。
Finish：
表示系统是否有足够的资源分配给进程，使之运行完成。
开始时，Finish[i]
=false；当有足够的资源分配给进程Pi时，令Finish[i]=true。
（2）从进程集合中找到一个能满足下列条件的进程：
Finish[i]==false；Needi<=Work；，如果找到了就执行步骤（3），否则执行步骤（4）。
（3）当进程Pi获得资源后，可执行直到完成，并释放出分配给它的资源，故应执行
Work=Work+Allocation;
Finish[i]=false；
然后转向第
（2）步骤。
4）若所有进程中的Finish[i]都是true，则表示系统处于安全状态；否则，系统处于不安全状态。
此过程由一个安全性检测函数实现：
safeAlgorithm（）;//安全性检测算法
4、对进程申请资源的处理
当某一进程提出资源申请时，系统须做出判断，能否将所申请资源分配给该进程。
设request为进程i的请求向量，如果request[j]=K，表示进程i需要K个j资源。
当系统发出请求后，系统按下述步骤开始检查：
（1）如果request[j]<=need[i][j],转向步骤2；否则报告出错，申请的资
源大于它需要的最大值。
（2）如果request[j]<=available[j],转向步骤3；否则报告出错，尚无足够的资源。
（3）系统试探着把资源分配给p[i]，并修改下列数据结构中的值：
available[j]=available[j]-request[j]allocation[i][j]=allocation[i][j]+request[j]need[i][j]=need[i][j]-request[j]
（4）系统进行安全性算法，检查此次分配后，系统是否还处于安全状态，若安全，把资源分配给进程i；否则，恢复原来的资源分配状态，让进程i等待。
整个过程由银行家算法实现：
bankerAlgorithm（）//利用银行家算法对申请资源对进行判定
四、算法描述
#include
#include
#defineM5//定义进程数
#defineN3//定义资源数s
#defineFalse0
#defineTrue1
intMax[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//每个进
程对每类资源的最大需求
intAllocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//
系统已分配资源
intAvaliable[3]={3,3,2};//系统可利用资源
还需要
intNeed[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//资源
intRequest[3];
voidshowdata（）//显示资源矩阵
{
inti,j;
printf（"系统目前可利用的资源数量:
\nA,B,C\n"）;printf（"resouce:
"）;
for（j=0;jprintf（"%d,",Avaliable[j]）;//输出分配资源printf（"\n"）;
printf（"各进程的资源需求:
\n"）;
for（i=0;i{
printf（"pr%d:
",i）;
for（j=0;j{
printf（"%d,",Max[i][j]）;//输出最大需求资源数
}printf（"\n"）;
}
printf（"各进程得到资源:
\n"）;
for（i=0;i{
printf（"pr%d:
",i）;
for（j=0;jprintf（"%d,",Allocation[i][j]）;//输出已分配资源数
printf（"\n"）;
}
printf（"各进程还需求资源:
\n"）;
for（i=0;i{
printf（"pr%d:
",i）;
for（j=0;jprintf（"%d,",Need[i][j]）;//输出还需要资源数printf（"\n"）;
}
}
voidrelease（inti）//判断是否安全，若不安全则释放第j类资源{
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];
}
}
voiddistribute（inti）//若符合条件则对第j类资源进行分配
{
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];
}
voidsafeAlgorithm（）//安全性算法
{
intWork[3],Finish[M]={0},result[M],run;
/*work：
表示系统可提供给进程继续运行的所需的各类资源数目
finish：
表示系统是否有足够的资源分配给进程
result用来存放依次执行成功的线程*/
inti,j,k=0,m,demand;
for（i=0;i<3;i++）
{
Work[i]=Avaliable[i];//开始的时候work=available
}
for（i=0;i{
demand=0;
for（j=0;j{
if（Finish[i]==False&&Need[i][j]<=Work[j]）
{demand++;
if（demand==3）〃只有ABC三类资源都满足才把相应的线程
记入数组result中
{for（m=0;mWork[m]=Work[m]+Allocation[i][m];//重新分配第i类线程的当前可利用资源
Finish[i]=True;
result[k]=i;
i=-1;
k++;
}
}
else
if（Finish[i]==False）
{
if（i==M-1）
{printf（"系统不安全\n"）;//如果不成功，输出系统不安全
run=False;}
break;
}
}
}
printf（"系统资源分配成功!
"）;//如果安全，输出成功
printf（"分配的序列:
\n"）;
for（i=0;i{
printf（"pr%d",result[i]）;
}
}
voidbankerAlgorithm（）//利用银行家算法对申请资源对进行判定
{
inti,j,OK=1,run=True;
printf（"\n请输入第一个要求分配的资源进程号从（0to4）:
"）;scanf（"%d",&i）;//输入须申请的资源号printf（"请输入进程%d申请的资源:
\n",i）;
for（j=0;j<3;j++）
{
printf（"第%d个资源:
",j+1）;
scanf（"%d",&Request[j]）;//输入需要申请的资源
}
for（j=0;j{
if（Request[j]>Need[i][j]）//判断申请是否大于需求，若大于则出错
{
printf（"进程%d申请的资源大于它需要的资源",i）;
printf（"error!
\n"）;
OK=0;
break;
}
else
{if（Request[j]>Avaliable[j]）//判断申请是否大于当前资源，若大于则出错
{
printf（"进程%d申请的资源大于当前可利用资源",i）;
printf（"error!
\n"）;
OK=0;
break;
}
}
}
if（OK==1）//若都符合条件，则进行分配
{
distribute（i）;//根据进程请求分配资源
showdata（）;//显示变换后的资源
safeAlgorithm（）;//通过安全算法判断该序列是否安全
if（run==False）//若不安全，则进行释放第I类资源
{release（i）;}
}
}
voidmain（）//主函数
{intchoice;
showdata（）;safeAlgorithm（）;
do
{printf（"\n输入接下来你要进行的操作1：
分配资源2:
显示资源否则按任意键退出"）;
scanf（"%d",&choice）;switch（choice）
{case1:
bankerAlgorithm（）;break;case2:
showdata（）;break;default:
break;
}
}while（（choice==1）||（choice==2））;
五、实验结果
系统目前可利用的资源数量二
A,B,Crcsouce:
3,3,2^
各进程的资源需求，pi?
0:
7,3,p（rl=3,2,2,pt*2:
5,0,2^pr3:
2□.2-2,
3^-3,
各进程得到资源：
pi*0:
0,1,
prl:
2,0,
pr-2-3,0^2,pr-3:
2,1^1>pi*4：
0,0-2,各进程还需求资源匕pr0:
7,4^3,tri：
1,2,2>pr2:
£亠0”0”
-0,1,1,P^4：
4,3^1,系统资源分酉嘛功»分配的序列:
pi'lpi'3pi'0pi*2pr4裔入接下来你要进行的操作1;分配资源示资源否则按任意键退出
揃入接下来你要进行为操作「分配资漏^显示资源
否则按任竜犍退田丄
豈一个
籍2X§l=i
>3个谡｛■原：
丄
索统冃乔］■利用的资源数呈=
A
瞬源进程号X
ouoet2,2,1,
各进程的资源需求兰
pi*l:
3.£.2.
pr-2=¥.0.2"
pH2,2^2.
pi*4.:
理.-3亠3-
怦进程得到资源=
pi*0:
prl:
2,Rl,H,
pi'2:
3,0^2.
pi*3：
e2A13LM
各进程还需求资源=
pr-0:
6,3,2,
pi'l:
JL尸运*£-
pi*2：
:
吕，日亠0）.
Pi'S：
:
❺■丄.：
L.
二
系疑资源芬盲己成功时亍配前序列=
pi*3pi'lpi^0p片2pi*4
输入按p来俊要进行拥操作i:
井配说源
2=显示贵源
否则按任意犍退田
六、实验心得
在避免死锁的方法中，允许进程动态地申请资源，系统在进行资源分配之前，先计算资源分配的安全性。
若此次分配不会导致系统进入不安全状态，便将资源分配给进程，否则进程等待。
银行家算法是死锁避免算法中的一种，通过上面这个例子，我们看到银行家算法确实能保证系统时时刻刻都处于安全状态，但它要
不断检测每个进程对各类资源的占用和申请情况，需花费较多的时间。
本次实验为时两天多，总体上来说实验是比较成功的。
由于时间仓促，做的不是很完美，敬请老师谅解。
升级会员 