银行家算法课程设计报告Word格式文档下载.docx
《银行家算法课程设计报告Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《银行家算法课程设计报告Word格式文档下载.docx（24页珍藏版）》请在冰豆网上搜索。
1.3运行环境
TurboC;
VisualC++6.0
2需求分析
2.1问题描述
当系统在进行资源管理时，如果对进城申请的资源分配不当，可能会使系统进入死锁状态，因而后面到来的进程也无法顺利执行。
银行家算法中，要对当前申请资源的进程申请资源的数目进行判断，如果可以试分配，则试求出一个安全序列，如果可以求出，则说明给这个进程分配资源后系统不会进入不安全状态，将该进程申请的资源分配给他，若求不出安全序列，则说明将资源分配给该进程后系统会进入不安全状态，所以就使该进程进入阻塞状态，等待以后可以分配资源时再执行该进程，然后系统继续服务其它进程。
通过这样一个过程，可以有效避免系统进入死锁状态。
2.2基本要求
（1）对各个进程的进程名，最大需求资源，已分配资源，系统可用资源等进行有序的输入。
（2）对申请资源的进程要有合法性判断（如进程名，申请资源数等）。
（3）若有进程申请资源，首先要对它申请的资源数进行判断。
（4）在上面判断合法的前提下进行试分配，利用银行家算法求出安全序列。
如果可以求出安全序列，则为该进程分配资源，否则使它进入阻塞状态。
2.3概要分析
在避免死锁的算法中，允许进程动态地申请资源，系统在进行资源分配之前，先计算资源分配的安全性。
若此次分配不会使系统进入不安全状态，便将资源分配给该进程否则进程等待。
所谓安全状态是指系统能按某种顺序如<
p1，p2，……，pn>
（称<
为安全序列），就这样来为每个进程分配资源，直至最大需求。
使每个进程都可以顺序地执行完毕。
若系统不存在这样一个安全序列，那么系统此时会进入不安全状态。
虽然并非所有的不安全状态都会产生死锁状态，但当系统进入不安全状态后，便可能进而进入死锁状态；
反之，只要系统处于安全状态，系统便可避免进入死锁状态。
因此，避免死锁的实质在于，如何使系统不进入不安全状态，银行家算法就是用来判断某种情况会不会进入不安全状态。
3算法思想
3.1安全性算法的算法思想
思想:
系统在进行资源分配之前，应先计算此次资源分配后状态的安全性。
若此次分配后的状态是安全状态，则将资源分配给进程；
否则，令进程等待。
3.1.1设置两个向量
（1）工作向量Work[m]:
它表示系统可提供给进程继续运行所需的各类资源数目，Work初∶=Available;
（2）Finish[n]:
它表示系统是否有足够的资源分配给进程，使之运行完成。
false表示未完成，true表示完成。
3.1.2安全性检测
3.2银行家算法的算法思想
3.2.1银行家算法的思路
先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。
若请求合法，则进行试分配。
最后对试分配后的状态调用安全性检查算法进行安全性检查。
若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。
3.2.2银行家算法
进程i发出申请资源请求：
（1）调用check_distribution（int*p,intk）检查申请量是否不大于需求量再检查检查申请量是否小于系统中的可利用资源数量：
若条件不符重新输入，不允许申请大于需求量。
（2）若以上条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：
Available[i,j]=Available[i,j]-Requesti[j]；
Allocation[i][j]=Allocation[i][j]+Requesti[j]；
need[i][j]=need[i][j]-Requesti[j]；
（3）进行试分配，执行安全性检查，调用check_safe（）函数检查此次资源试分配后系统是否处于安全状态。
若安全，才正式将资源分配给进程；
否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
（4）用while循环语句实现输入字符Y/N判断是否继续进行资源申请。
3.2.3安全性检查算法
（1）设置向量：
工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work[]=Available[]。
Finish[]，它表示系统是否有足够的资源分配给每个进程，使之运行完成。
开始时先做Finish[i]=0；
当有足够的资源分配给进程时，再令Finish[i]=1。
（2）在进程中查找符合以下条件的进程：
条件1：
Finish[i]=0；
条件2：
need[i][j]<
=Work[j]
若找到，则执行步骤（3）否则，执行步骤（4）
（3）当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]=Work[j]+Allocation[i][j]；
Finish[i]=1；
gotostep2；
（4）最后循环检查是否所有的Finish[i]=1都满足，如果是，则返回1表示系统处于安全状态，否则，返回0表示系统处于不安全状态。
4详细设计
4.1银行家算法中用到的主要数据结构设计
（1）进程名向量charprocessnema[N];
//进程名
（2）可利用资源向量intAvailable[M];
//资源清单——系统中现有各资源空闲个数。
（3）最大需求矩阵intMax[N][M];
//最大需求矩阵——每个进程对各资源的最大需求数分配矩阵
（4）已分配矩阵intAllocation[N][M];
//分配矩阵——系统给每个进程已分配的各类资源数
（5）需求矩阵intNeed[N][M];
//需求矩阵——每个进程还需要每种资源的个数申请各类资源数量
（6）申请向量intRequest[M]//进程申请资源的向量
（7）工作向量intWork[N][M];
//初始第一个向量为Available[],随寻找安全序列时为其余每个向量赋值，可以防止安全序列未找到而丢了初始状态的值
（8）安全序列向量intsequence[N]={0};
//存放安全序列号
（9）标志向量intFinish[N]//求安全序列时记录每个进程是否可以顺利执行
4.2算法整体设计与调用
主函数voidmain（），首先输入每个进程信息，然后判断是否有进程申请资源，若有，则调用intcheck_distribution（int*p,intk）函数判断是否可以进行试分配，如果满足试分配条件，调用intcheck_safe（）函数求安全序列，如果可以求出安全序列，则说明分配后系统不会进入不安全状态，正式将资源分配给申请资源的进程，最后用voidprint（）函数输出分配资源后每个进程的信息。
如果求不出安全序列，说明分配后系统会处于不安全状态，则不能将资源分配给该进程，让其等待，系统恢复原始状态。
如果申请资源的数量不满足条件，则让该进程等待。
继续判断其他申请资源的进程。
（1）intcheck_distribution（int*p,intk）：
这个函数用来判断是否可以进行试分配，如果函数结果返回1，说明可以进行试分配，如果行数返回0，说明申请资源的进程申请的资源数目不满足Request[]<
=need[]或Request[]<
=available[]条件，不能为该进程进行试分配。
（2）intcheck_safe（）：
这个函数用来求安全序列，首先初始化Work[0][i]=Available[i]，然后循环找满足条件Finish[i]==0&
&
Need[i][0]<
=Work[k][0]的进程，k表示最近执行的进程的进程号，找到后将进程i加入sequence[]向量，再将Finish[i]=1，表示进程可以顺利执行则Work[k][j]=Work[k-1][j]+Allocation[i][j]，k表示同上。
再继续找下一个满足条件的进程。
如果单循环结束时每个进程的Finish[i]都等于1，则说明可以找到安全序列，返回1，如果不是每个Finish[i]都等于1，则说明找不到一个安全序列，返回0
（3）voidprint（）：
这个函数用来输出进程信息，按表格形式输出，并且输出顺序和安全序列相同，便于查看进程执行执行过程，并且在执行过程中各矩阵信息变化也很容易跟踪查看。
（4）系统模块
4.3模块设计与时间复杂度分析
4.3.1intcheck_distribution（int*p,intk）：
检查是否可以试分配函数
用for（i=0;
i<
M;
i++）判断是否满足约束条件p[i]<
=Need[k][i]，时间复杂度为O（M）。
4.3.2intcheck_safe（）银行家算法
（1）用for（i=0;
i++）循环{Work[k][i]=Available[i];
//-Request[i]}初始化Work矩阵
（2）用for（m=0;
m<
N;
m++）循环找出满足（0==Finish[i]&
=Work[k][0]&
Need[i][1]<
=Work[k][1]&
Need[i][2]<
=Work[k][2]）条件的进程，修改各资源信息。
因为是N个进程，所以最多循环N次就可以找出所有矩阵。
（3）用for（i=0;
i++）/检查是否所有进程都执行完了，如果所有进程都可执行则finish值等于1。
（4）由上面执行可以得出intcheck_safe（）函数时间复杂度为O（N）或O（M）。
4.3.2voidprint（）输出函数
for（i=0;
i++）{for（j=0;
j<
j++）{}循环输出每个进程的每一类资源信息，时间复杂度为O（N）或O（M）。
4.4程序流程图
4.5.1主函数voidmain（）函数流程图（4-1）
4-1
4.5.2判断试分配函数intcheck_distribution（int*p,intk）流程图（4-2）
4-2
4.5.3银行家算法intcheck_safe（）流程图
（4-3）
4-3
4.5.4输出函数voidprint（）
流程图（4-4）
4-4
5程序调试、分析与修改
5.1分模块调试与分析
函数的书写分模块进行，每完成一个模块进行调试、测试直到该函数运行无误。
5.1.1进程信息的输入与输出调试
（1）能正确无误的输入进程名向量processnema[N]，输入系统现有各类资源数量Available[M]向量，输入每个进程对各类资源的最大需求数Max[N][M]矩阵，输入系统给每个进程已分配的各类资源数Allocation[N][M]矩阵。
输出程序过程如
下：
（2）在进程信息输入中没有出现多大问题，在进程信息输出时，按设计要求输出的话应该是一个表格形式，在输出函数设计最初，由于有些部分分割或空格没有填充好，导致输出表格比较乱，没有达到设计要求，经过修改后输出形式才符合了设计要求，进程信息输入完成后，初始状态各进程信息输出如下：
5.1.2进程请求资源输入出错提示信息处理
（1）在系统询问是否有进程申请资源时，如果有输入信息出错，系统会给与出错提示，如果输入信息正确则系统将继续执行下面操作，执行如下：
5.1.3判断是否可以试分配函数intcheck_distribution（int*p,intk）
（1）在这个函数中主要是对申请资源的进程申请的资源数量是否满足约束条件Request[]<
=available[],如果不满足将打出提示信息，如果满足，则返回1继续执行下面程序，执行结果如下：
5.1.4求安全序列函数intcheck_safe（）
（1）如果申请资源的进程申请的资源数目满足试分配条件，则再用这个函数来求试分配后的安全序列，如果可以求出安全序列，则说明这次分配不会使系统进入不安全状态，正式将资源分配给该进程，修改系统资源信息。
如果求不出安全序列，说明这次分配后系统会进入不安全状态，不能给该进程分配资源，系统恢复初始状态，打印出提示信息，执行结果如下：
6结论
银行家算法是通过检查试分配，求安全序列，从而判断是否可以为申请资源的进程分配资源，从而有效地避免系统进入死锁状态。
7小结
虽然并非所有的不安全状态都会产生死锁状态，但系统进入不安全状态时，便可能进而进入死锁状态后，当系统在进行资源管理时，如果对进城申请的资源分配不当，可能会使系统进入死锁状态，因而后面到来的进程也无法顺利执行。
因此，避免死锁的实质在于；
如何使系统不进入不安全状态。
对先者ang下图所示：
<
参考文献
[1]《数据结构实验指导书》网上资料
[2]《计算机操作系统》汤子瀛哲凤屏汤小丹，西安电子科技大学出版社；
[3]《C语言程序设计》谭浩强，清华大学出版社；
附录（源代码）
#include<
stdio.h>
#defineN5//进程个数
#defineM3//资源种类数
voidprint（）;
intcheck_safe（）;
intcheck_distribution（int*p,intk）;
charprocessnema[N];
intRequest[M];
//请求向量
intFinish[N];
//标记某一个进程是否可以执行
intWork[N][M];
//初始为Available[][],随寻找安全序列而变化，防止安全序列未找到而丢了初始状态的值
intAvailable[M];
//资源清单——系统中现有各资源空闲个数
intWork_Allocation[N][M];
intMax[N][M];
//最大需求矩阵——每个进程对各类资源的最大需求数
intAllocation[N][M];
//分配矩阵——系统给每个进程已分配的各类资源数
intNeed[N][M];
//需求矩阵——每个进程还需要每种资源的个数
intsequence[N]={0};
voidmain（）
{
inti=0,j=0,k=0;
//记录申请资源的进程的序列号
intflag=0;
//标记输入的进程名是否存在
intsafe=0;
//标志系统是否出于安全状态,0表示不安全，1表示安全
intdistribution=0;
//标志是否可以进行试分配0表示可以，1表示不可以
charflag1;
//标记是否有进程申请资源//Need[N][M]=Max[N][M]-Allocation[N][M];
charname;
//要请求资源的进程名
printf（"
~~~~~~~~~~~银行家算法~~~~~~~~~~~~~\n"
）;
请分别初始化各矩阵信息\n"
*请输入各进程的进程名\n"
//进程名连续输入
for（i=0;
i++）
{
scanf（"
%c"
&
processnema[i]）;
}
请输入现有各资源空闲个数\n"
%d"
Available[i]）;
请分别输入每个进程对各类资源的最大需求数\n"
for（j=0;
j++）
{
scanf（"
Max[i][j]）;
}
请分别输入系统给每个进程已分配的各类资源数\n"
Allocation[i][j]）;
//printf（"
请分别输入每个进程还需要每种资源的个数\n"
Need[i][j]=Max[i][j]-Allocation[i][j];
信息输入完毕\n"
sequence[i]=i;
print（）;
safe=check_safe（）;
//检查初始状态是否安全
if（0==safe）
printf（"
系统现处于不安状态，不能为进程分配资源，进入死锁状态。
。
\n"
exit（0）;
elseif（1==safe）
系统处于安全状态，可以为进程分配资源。
while
（1）
safe=0;
getchar（）;
是否有进程请求系统资源...?
（Y/N）\n"
flag1=getchar（）;
//scanf（"
flag1）;
if（'
Y'
==flag1||'
y'
==flag1）
printf（"
请输入进程名:
"
while
（1）
{
//name=;
scanf（"
name）;
for（i=0;
i++）//检查进程名输入是否正确
{
if（name==processnema[i]）
{
flag=1;
//输入的进程名存在
k=i;
break;
//找到申请资源的进程序列号跳出
}
}
getchar（）;
//将在此之前的一个回车接收了，不然会影响输入
if（flag!
=1）//进程名输入不合法
printf（"
你输入的进程不存在，请重新输入:
continue;
else
break;
//进程名输入合法，则执行下面操作
}
elseif（'
N'
n'
进程执行完毕，退出系统。
break;
!
=flag1&
'
=flag1）
你的输入有误，请重新输入:
"
continue;
请输入该进程请求各类资源的数量\n"
Request[i]）;
distribution=check_distribution（Request,k）;
//检查是否可以试分配
if（1==distribution）//*****************************************检查
safe=check_safe（）;
//可以试分配，则求安全序列
if（1==safe）//试分配成功
printf（"
试分配成功，可以为该进程分配资源。
//distribution//是否给申请资源的进程分配资源
Allocation[k][i]=Allocation[k][i]+Request[i];
//为进程分配资源后修改该进程的有关资源数
Need[k][i]=Need[k][i]-Request[i];
分配后各资源数量如下:
print（）;
升级会员 