操作系统实验报告记录三银行家算法Word格式.docx
《操作系统实验报告记录三银行家算法Word格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告记录三银行家算法Word格式.docx（17页珍藏版）》请在冰豆网上搜索。
否则系统不安全。
3.银行家算法
在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。
在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。
银行家算法的基本思想是分配资源之前,判断系统是否是安全的;
若是,才分配。
它是最具有代表性的避免死锁的算法。
设进程j提出请求REQUEST[i]，则银行家算法按如下规则进行判断。
（1）.如果REQUEST[j][i]<
=NEED[j][i]，则转
（2）；
否则，出错。
（2）.如果REQUEST[j][i]<
=AVAILABLE[j][i]，则转（3）；
（3）.系统试探分配资源，修改相关数据：
AVAILABLE[i]-=REQUEST[j][i];
ALLOCATION[j][i]+=REQUEST[j][i];
NEED[j][i]-=REQUEST[j][i];
用到的数据结构：
实现银行家算法要有若干数据结构，它们用来表示资源分配系统的状态。
令n表示系统中进程的数目，m表示资源的分类数。
还需要以下数据结构：
1）.Available是一个长度为m的向量，它表示每类资源可用的数量。
Available[j]=k，表示j类资源可用的数量为k。
2）.Max是一个n×
m矩阵，它表示每个进程对资源的最大需求。
Max[i，j]=k，表示进程pi至多可以申请k个j类资源单位。
3）.Allocation是一个n×
m矩阵，它表示当前分给每个进程的资源数目。
Allocation[i，j]=k，表示进程i当前分到k个j类资源。
4）.Need是一个n×
m矩阵，它表示每个进程还缺少多少资源。
Need[i，j]=k，表示进程pi尚需k个j类资源才能完成其任务。
显然Need[i，j]=Max[i，j]-Allocation[i，j]。
（二）流程图
四、运行结果示例
这里以书上的例子为例，初值如下表：
Allocation
Max
Available
ABC
P0
010
753
332
P1
200
322
P2
301
900
P3
211
222
P4
002
433
现在让进程P1再申请A:
1B:
0C:
2个资源，首先调用安全算法测试如果分配后系统是否安全，然后给出了分配序列，如下图：
如果再让P4申请A:
0B:
2C:
0个资源，首先调用安全算法测试如果分配后系统是否安全，发现分配后系统不安全，于是报分配错误，不予分配，结果如下图：
七、实验体会
银行家算法的具体实现，我学到了很多课本上没有的知识。
想要完成模拟银行家算法的C++程序，首先就是要彻底熟悉算法，了解算法的基本原理，才能开始着手程序设计在程序设计设计过程中，遇到了一些困难，通过向同学询问，翻阅资料等，问题被一一解决了。
首先就是在知识层面上了解了银行家算法这种进程调度和避免死锁的算法，并用C++程序真正模拟出安全性检查和银行家算法过程，复习了之前所学C++和数据结构的知识；
在编程过程中虽然遇到很多困难，解决问题的过程中，同时也锻炼了我不怕困难，勇于迎接挑战的精神，为以后的工作打下了坚实的基础。
八、源程序并附上注释
#include<
iostream>
string.h>
stdio.h>
iomanip>
#defineFalse0
#defineTrue1
usingnamespacestd;
intMax[100][100]={0};
//各进程所需各类资源的最大需求
intReMax[100][100]={0};
intAvaliable[100]={0};
//系统可用资源
intReAvaliable[100]={0};
charname[100]={0};
//资源的名称
intAllocation[100][100]={0};
//系统已分配资源
intReAllocation[100][100]={0};
intNeed[100][100]={0};
//还需要资源
intReNeed[100][100]={0};
intRequest[100]={0};
//请求资源向量
inttemp[100]={0};
//存放安全序列
intWork[100]={0};
//存放系统可提供资源
intM=100;
//进程的最大数量为100
intN=100;
//资源的最大数量为100
voidshowdata（）//显示资源矩阵
{
inti,j;
cout<
<
endl;
"
MaxAllocationNeedAvaliable"
<
;
for（j=0;
j<
4;
j++）{
for（i=0;
i<
N;
i++）
cout<
name[i]<
cout<
}
for（i=0;
M;
i++）{
i<
for（j=0;
j++）
Max[i][j]<
Allocation[i][j]<
Need[i][j]<
if（i==0）{
for（j=0;
cout<
Avaliable[j]<
}
}
voidsave（）{
N;
{
ReAvaliable[i]=Avaliable[i];
M;
j<
ReMax[i][j]=Max[i][j];
ReAllocation[i][j]=Allocation[i][j];
ReNeed[i][j]=Need[i][j];
voidrestore（）{
Avaliable[i]=ReAvaliable[i];
Max[i][j]=ReMax[i][j];
Allocation[i][j]=ReAllocation[i][j];
Need[i][j]=ReNeed[i][j];
intchangdata（inti）//进行资源分配
intj;
j++）{
Avaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
return1;
intsafe（）//安全性算法
inti,k=0,m,apply,Finish[100]={0};
intflag=0;
for（intnum=0;
num<
num++）
Work[num]=Avaliable[num];
apply=0;
if（Finish[i]==False&
&
Need[i][j]<
=Work[j]）{
apply++;
if（apply==N）{
for（m=0;
m<
m++）
Work[m]=Work[m]+Allocation[i][m];
//变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
flag++;
}
}
if（Finish[i]==False）{
系统不安全,所有状态不改变！
"
//不成功系统不安全
return1;
系统是安全的!
//如果安全，输出成功
save（）;
//进行保存
安全序列:
i++）{//输出运行进程数组
temp[i];
if（i<
M-1）cout<
->
endl<
endl;
return0;
voidshare（）//利用银行家算法对申请资源对进行判定
boolch=true;
inti=0,j=0;
//ch='
y'
请输入请求分配资源的进程号（0-"
M-1<
）:
cin>
>
i;
//输入须申请的资源号
请输入进程"
申请的资源数量:
name[j]<
:
cin>
Request[j];
//输入需要申请的资源
if（Request[j]>
Need[i][j]）//判断申请是否大于需求，若大于则出错
{
进程"
申请的资源大于它需要的资源"
分配不合理，不予分配！
ch=false;
break;
else{
if（Request[j]>
Avaliable[j]）//判断申请是否大于当前资源，若大于则
{//出错
进程"
申请的资源大于系统现在可利用的资源"
分配出错，不予分配!
ch=false;
break;
if（ch）{
changdata（i）;
//根据进程需求量变换资源
if（safe（））{
restore（）;
}//根据进程需求量进行银行家算法判断
showdata（）;
//根据进程需求量显示变换后的资源
voidchangeresources（）{//修改资源函数
当前的[Avaliable]:
for（inti=0;
Avaliable[i]<
endl<
输入修改值:
Avaliable[i];
修改后的[Avaliable]:
for（intk=0;
k<
k++）
name[k]<
Avaliable[k]<
showdata（）;
safe（）;
intmain（）//主函数
inti,j,number,m,n,flag;
intchoice=1;
charming;
请输入系统资源的种类数:
n;
N=n;
请依次输入系统资源的名称与数量：
n;
//cout<
资源"
i+1<
的名称:
ming>
number;
name[i]=ming;
的数量:
//cin>
number;
Avaliable[i]=number;
请输入进程的数量:
m;
M=m;
请输入各进程的最大需求量（"
m<
*"
n<
矩阵）[Max]:
m;
cin>
Max[i][j];
do{
flag=0;
请输入各进程已经申请的资源量（"
矩阵）[Allocation]:
Allocation[i][j];
if（Allocation[i][j]>
Max[i][j]）
flag=1;
Need[i][j]=Max[i][j]-Allocation[i][j];
Avaliable[j]=Avaliable[j]-Allocation[i][j];
if（flag）
申请的资源大于最大需求量，请重新输入!
\n"
}while（flag）;
//显示各种资源
//用银行家算法判定系统是否安全
while（choice）
**************银行家算法演示***************"
1:
修改现有资源实例数量"
2:
进程请求系统分配资源"
3:
显示各个矩阵内容"
0:
退出程序"
*******************************************"
请选择操作：
choice;
switch（choice）
case1:
changeresources（）;
break;
case2:
share（）;
case3:
case0:
choice=0;
default:
请正确选择功能号（0-3）!
您已成功退出程序！
升级会员 