银行家算法实验报告Word格式.docx
《银行家算法实验报告Word格式.docx》由会员分享，可在线阅读，更多相关《银行家算法实验报告Word格式.docx（24页珍藏版）》请在冰豆网上搜索。
九、参考文献26
银行家算法
一、设计目的
本课程设计是学习完《计算机操作系统》课程后，进行的一次全面的综合训练。
通过这次课程设计，让我们更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强动手能力。
二、设计内容
编制银行家算法通用程序，并检测所给状态的系统安全性。
三、银行家算法的基本思想
（一）死锁
在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险——死锁。
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。
产生死锁的原因可归结为如下两点：
（1）竞争资源。
（2）进程间推进顺序非法。
死锁的发生必须具备下列四个必要条件：
（1）互斥条件。
（2）请求和保持条件。
（3）不剥夺条件。
（4）环路等待条件。
（二）系统安全状态
避免死锁的实质在于：
系统在进行资源分配时，如何使系统不进入不安全状态。
所谓安全状态，是指系统能按某种进程顺序（P1，P2，……，Pn）（称<
P1，P2，……，Pn>
序列为安全序列），来为每个进程Pi分配其所需资源，直至满足每个进程对资源的最大需求，使每个进程都可顺利的完成。
如果系统无法找到这样一个安全序列，则称系统处于不安全状态。
（三）银行家算法避免死锁
为实现银行家算法，系统中必须设置若干数据结构。
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、银行家算法
设Request[i]是进程Pi的请求向量，如果Request[i，j]=K,表示进程需要K个Rj类型的资源。
当Pi发出资源请求后，系统按下述步骤进行检查：
（1）如果Request[i，j]<
=Need[i，j]，便转向步骤
（2）；
否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
（2）如果Request[i，j]<
=Available[j]，便转向步骤（3）；
否则，表示尚无足够资源，Pi须等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available[j]=Available[j]-Request[i，j]；
Allocation[i，j]=Allocation[i，j]+Request[i，j]；
Need[i，j]=Need[i，j]-Request[i，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都满足，则表示系统处于安全状态；
否则，系统处于不安全状态。
四、系统模块间关系图
五、系统子模块结构图
六、输入、输出数据
执行程序，输入数据之前：
现在请分别输入对应的进程号、资源号和个数：
现在请选择1或2：
选择了1后：
因为未通过安全性测试，不予以分配，所以一切数据均无变化。
点击了1后：
现在又请分别输入其它需要测试的进程号、资源号和个数：
因为通过了安全性测试，并找到了一个安全序列，所以分配成功，有关数据均要发生变化。
（请对照前后数据及所输入的数据进行比较）
●资源类型1的可利用资源由4变成3；
●进程2的资源类型1的已分配资源由2变成3；
●进程2的资源类型1的已需求资源由1变成0；
七、源程序及系统文件使用说明
（一）源程序
#include"
stdafx.h"
#include<
iostream.h>
fstream.h>
windows.h>
stdlib.h>
#defineMAX_PROCESS32//最大进程数
#defineMAX_COURCE64//最大资源类别
intMAX_FACT_PROCESS;
//实际总进程数
intMAX_FACT_COURCE;
//实际资源类别数
intAvailable[MAX_COURCE];
//可利用资源向量
intMax[MAX_PROCESS][MAX_COURCE];
//最大需求矩阵
intAllocation[MAX_PROCESS][MAX_COURCE];
//分配矩阵
intNeed[MAX_PROCESS][MAX_COURCE];
//需求矩阵
intRequest_PROCESS;
//发出请求的进程
intRequest_COURCE;
//被请求资源类别
intRequest_COURCE_NEMBER;
//请求资源数
boolloop=true;
structCOMP
{
intvalue;
intnum;
intnext;
};
intflag=0;
voidRead_Initiate（void）//读入初始化文档
{
ifstreaminfile（"
Initiate.txt"
）;
if（!
infile）
{
cout<
<
"
不能打开输入文件:
endl;
exit
（1）;
}
cout<
开始读入初始化文档"
intch;
intArray[MAX_PROCESS*MAX_COURCE*2];
intnum=0;
while（infile>
>
ch）//初始化文档的第一个数字为长度
Array[num++]=ch;
num=0;
MAX_FACT_COURCE=Array[num++];
for（intj=0;
j<
MAX_FACT_COURCE;
j++）
Available[j]=Array[num++];
MAX_FACT_PROCESS=Array[num++];
for（inti=0;
i<
MAX_FACT_PROCESS;
i++）
for（intj=0;
Max[i][j]=Array[num++];
infile.close（）;
}
voidWrite_Initiate（void）//写入初始化文档（分配资源）
ofstreamoutfile（"
outfile）
不能打开初始化文档：
Array[num++]=MAX_FACT_COURCE;
Array[num++]=Available[i];
Array[num++]=MAX_FACT_PROCESS;
for（i=0;
Array[num++]=Max[i][j];
outfile<
Array[num++]<
"
;
outfile<
endl<
outfile<
intm_delay=3000;
Sleep（m_delay）;
outfile.close（）;
修改初始化文档成功!
voidAllocated_list（void）//读入已分配资源列表
Allocated_list.txt"
开始读入已分配资源列表"
intArray[MAX_PROCESS*MAX_COURCE];
ch）
Allocation[i][j]=Array[num++];
voidSet_Need（void）//设置需求矩阵
设置需求矩阵"
Need[i][j]=Max[i][j]-Allocation[i][j];
voidWrite_Allocation（void）//修改资源分配列表（资源分配）
不能打开资源分配列表：
Allocation[i][j]<
修改资源分配列表成功!
voidAllocate_Source（void）//开始分配（已通过扫描和安全性检测）
开始给第"
Request_PROCESS<
个进程分配第"
Request_COURCE<
类资源"
Request_COURCE_NEMBER<
个"
Write_Initiate（）;
Write_Allocation（）;
祝贺您，资源分配已成功!
boolTest_Safty（）//安全性检测
进入安全性检测!
intWork[MAX_COURCE];
Work[i]=Available[i];
boolFinish[MAX_PROCESS][MAX_COURCE];
Finish[i][j]=false;
COMPArray[32];
Array[i].value=Need[i][Request_COURCE-1];
Array[i].num=i;
for（intj=i+1;
{
if（Array[i].value>
=Array[j].value）
{
intt;
t=Array[j].value;
Array[j].value=Array[i].value;
Array[i].value=t;
t=Array[j].num;
Array[j].num=Array[i].num;
Array[i].num=t;
}
elsecontinue;
}
if（Finish[Request_PROCESS-1][Request_COURCE-1]==false&
&
Need[Request_PROCESS-1][Request_COURCE-1]<
=Work[Request_COURCE-1]）
Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Request_PROCESS-1][Request_COURCE-1];
Finish[Request_PROCESS-1][Request_COURCE-1]=true;
else
未通过安全性测试，不与以分配"
returnfalse;
if（Array[i].num==Request_PROCESS-1）
continue;
if（Array[i].num!
=Request_PROCESS-1&
Finish[Array[i].num][Request_COURCE-1]==false&
Need[Array[i].num][Request_COURCE-1]<
Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Array[i].num][Request_COURCE-1];
Finish[Array[i].num][Request_COURCE-1]=true;
if（Finish[i][Request_COURCE-1]==true）
continue;
else
cout<
returnfalse;
找到一个安全序列:
P"
--->
if（Array[i].num==Request_PROCESS）
Array[i].num<
已通过安全性测试!
Allocate_Source（）;
returntrue;
boolRUN（void）//执行银行家算法
*************************************************"
点击1执行!
点击2退出!
cin>
flag;
if（flag==2）
loop=false;
exit（0）;
if（flag==1）
开始扫描请求信息!
intm_delay=3000;
Sleep（m_delay）;
if（Request_COURCE_NEMBER>
Need[Request_PROCESS-1][Request_COURCE-1]）
第"
个进程请求第"
可是已超出该进程尚需的该类资源的最大数量,所以不予以分配!
!
Available[Request_COURCE-1]）
可是系统中尚无足够的资源,所以进入等待队列!
Available[Request_COURCE-1]=Available[Request_COURCE-1]-Request_COURCE_NEMBER;
Allocation[Request_PROCESS-1][Request_COURCE-1]=Allocation[Request_PROCESS-1][Request_COURCE-1]+Request_COURCE_NEMBER;
Need[Request_PROCESS-1][Request_COURCE-1]=Need[Request_PROCESS-1][Request_COURCE-1]-Request_COURCE_NEMBER;
扫描通过"
Sleep（m_delay）;
Test_Safty（）;
else
输入错误,请重新输入!
RUN（）;
voidmain（void）
inttflag;
inti;
intj;
chartch;
while（loop）
Read_Initiate（）;
资源个数：
MAX_FACT_COURCE<
可利用资源"
资源类型"
for（i=0;
i+1<
Available[i]<
进程个数：
MAX_FACT_PROCESS<
:
for（j=0;
cout<
Max[i][j]<
升级会员 