银行家死锁避免算法模拟.docx
《银行家死锁避免算法模拟.docx》由会员分享，可在线阅读，更多相关《银行家死锁避免算法模拟.docx（14页珍藏版）》请在冰豆网上搜索。
银行家死锁避免算法模拟
银行家死锁避免算法模拟
1.课程设计目的
通过本次实验掌握银行家死锁避免算法的基本思想。
当进程提出资源申请时，能够用该算法判断是否拒绝进程请求。
2.课程设计摘要
银行家算法:
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
4.课程设计原理分析
在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险一一死锁。
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵局状态时，若无外力作用，它们都将无法再向前推进。
为保证系统中诸进程的正常运行，应事先采取必要的措施，来预防死锁。
最有代表性的避免死锁的方法，是Dijkstra的银行家算法。
死锁：
死锁的产生，必须同时满足四个条件，第一个为互斥条件，即一个资源每次只能由一个进程占用；第二个为请求和保持条件，指进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源又被其他进程占有，此时请求进程阻塞，但又对自己已获得的其他资源保持不放；第三个为非剥夺条件，即在出现死锁的系统中一定有不可剥夺使用的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一个进程所持有的资源。
防止死锁的机构只能确保上述四个条件之一不出现，则系统就不会发生死锁。
银行家算法原理:
银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
通过这个算法可以用来解决生活中的实际问题，如银行贷款等。
银行家算法，顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行家资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。
在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。
如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。
把一个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块PCB其中“状态”有就绪
态、等待态和完成态。
当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。
“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。
显然，，每个进程的资源需求总量不能超过系统拥有的资源总数，银行算法
进行资源分配可以避免死锁•
算法思想：
将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。
银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。
用银行家算法分配资源时，测试进程对资源的最大需求量，若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。
5.算法实现
1.程序流程图:
系统必须做
若是，
2.算法描述：
银行家算法的设计思想是：
当用户申请一组资源时，
出判断；如果把这些资源分出去，系统是否还处于安全装他
就可以分出这些资源；否则，该申请暂不能满足。
3.数据结构描述：
（n表示系统中进程的数目，m表示资源的分类数。
）
3.1.Available是一个长度为m的向量，它表示每类资源可用的数
量。
Available[j]=k，表示rj类资源可用的数量为k。
3.2.Max是一个nxm矩阵，它表示每个进程对资源的最大需求。
Max
[i,j]=k，表示进程pi至多可以申请k个rj类资源单位。
3.3.Allocation是一个nxm矩阵，它表示当前分给每个进程的资
源数目。
Allocation[i,j]=k，表示进程pi当前分到k个rj类资
源。
34Need是一个nxm矩阵，它表示每个进程还缺少多少资源。
Need[i,j]=k,表示进程pi尚需k个rj类资源才能完成其任务。
显
然Need[i,j]=Max[i,j]-Allocation[i,j]。
这些数据结构的大小和数值随时间推移而改变。
4.系统所执行的安全性算法描述如下:
4.1.设置2个向量：
工作向量Work:
它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work=Available。
Finish[i]:
它表示系统是否有足够的资源分配给进程，使之完成运行。
开始时先做Finish[i]=true。
42从进程集合中找到一个满足下述条件的进程：
Finish[i]=flase;Need[i,j]43当进程pi获得资源后，可顺利执行，直至完成，并释放分配给它的资源。
4.4.如果所有进程的Finish[i]=true都满足。
则表示系统处于安全
状态；否则，系统处于不安全状态。
6.程序源代码
#include#include#includeusingnamespacestd;#defineFalse0
#defineTrue1
各进程所需各类资源的最大需求系统可用资源
资源的名称
intAllocation[100][100]={0};〃
intM=100;〃作业的最大数为100
intN=100;〃资源的最大数为100
voidshowdata（）〃显示资源矩阵
inti,j;
cout<<"系统目前可用的资源[Avaliable]:
"<cout<cout<for（j=O；jcout<cout<<"MaxAllocationNeed"<cout<<"进程名";
for（j=0;j<3;j++）{for（i=0;icout<<"";
}
cout<for（i=0;icout<<""<for（j=0;jcout<cout<<"";
for（j=0;jcout<cout<<"";
for（j=0;jcout<cout<}
}
intchangdata（inti）//进行资源分配
{
intj;
for（j=0;jAvaliable[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=O,m,apply,Finish[100]={0};
intj;
intflag=0;
Work[0]=Avaliable[0];
Work[1]=Avaliable[1];
Work[2]=Avaliable[2];
for（i=0;iapply=O;
for（j=0;jif（Finish[i]==False&&Need[i][j]<=Work[j]）{
apply++;
if（apply==N）{
for（m=0;mWork[m]=Work[m]+Allocation[i][m];〃变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
flag++;
}
}
}
}
for（i=0;iif（Finish[i]==False）{
cout<<"系统不安全"<return-1;
}
}
cout<<"系统是安全的!
"<cout<<"分配的序列：
"；
for（i=0;icout<if（i";
}
cout<return0;
}
voidshare（）〃利用银行家算法对申请资源对进行判定
{
charch;
inti=0,j=0;
ch='y';
cout<<"请输入要求分配的资源进程号（0-"<";
cin>>i;〃输入须申请的资源号
cout<<"请输入进程"<"<for（j=0;j{
cout<";
cin>>Request[j];〃输入需要申请的资源
}
for（j=O；jif（Request[j]>Need[i][j]）〃判断申请是否大于需求，若大于则出错
{
cout<<"进程"<cout<<"分配不合理，不予分配！
"<ch='n';
break;
}
else{
若大于则
if（Request[j]>Avaliable[j]）〃判断申请是否大于当前资源,
{//出错
cout<<"进程"<cout<<"分配出错，不予分配!
"<ch='n';
break;
}
}
}
if（ch=='y'）{
changdata（i）;//根据进程需求量变换资源
showdata（）;〃根据进程需求量显示变换后的资源
safe（）;//根据进程需求量进行银行家算法判断
}
}
voidaddresources（）{//添加资源
intn,flag;
cout<<"请输入需要添加资源种类的数量:
";
cin»n;
flag=N;
N=N+n;
for（inti=0;icout<<"名称:
";
cin»name[flag];
cout<<"数量:
";
cin>>Avaliable[flag++];
}
showdata（）;
safe（）;
}
voidchangeresources（）{〃修改资源函数
cout<<"系统目前可用的资源[Avaliable]:
"<for（inti=0;icout<"<cout<<"输入系统可用资源[Avaliable]:
"<cin>>Avaliable[0]»Avaliable[1]»Avaliable[2];cout<<"经修改后的系统可用资源为"<for（intk=0;kcout<"<safe（）;
}
voiddelresources（）{〃删除资源
charming;
inti,flag=1;
cout<<"请输入需要删除的资源名称：
";
do{
cin»ming;
for（i=0;iif（ming==name[i]）{
flag=0;
break;
}
if（i==N）
cout<<"该资源名称不存在，请重新输入：
";
}
while（flag）;
for（intj=i;j{
name[j]=name[j+1];
Avaliable[j]=Avaliable[j+1];
}
N=N-1;
showdata（）;
safe（）;
}
voidaddprocess（）{〃添加作业
intflag=M;
M=M+1;
cout<<"请输入该作业的最大需求量[Max]"<for（inti=0;icout<";
cin>>Max[flag][i];
Need[flag][i]=Max[flag][i]-Allocation[flag][i];
}
showdata（）;
safe（）;
}
intmain（）〃主函数
{
inti,j,number,choice,m,n,flag;
charming;
cout<<"*****************资源管理系统的设计与实现
cout<<"请首先输入系统可供资源种类的数量：
"；
cin»n;
N=n;
for（i=0;i{
cout<<"资源"<";
cin»ming;
name[i]=ming;
cout<<"资源的数量
cin»number;
Avaliable[i]=number;
}
cout<cout<<"请输入作业的数量:
";
cin»m;
M=m;
cout<<"请输入各进程的最大需求量（"<"<for（i=0;ifor（j=0;jcin>>Max[i][j];
do{
flag=0;
cout<<"请输入各进程已经申请的资源量（"<阵）[Allocation]:
"<for（i=0;ifor（j=0;jcin>>Allocation[i][j];
if（Allocation[i][j]>Max[i][j]）
flag=1;
Need[i][j]=Max[i][j]-Allocation[i][j];
}
if（flag）
cout<<"申请的资源大于最大需求量，请重新输入!
\n";
}
while（flag）;
showdata（）;〃显示各种资源
safe（）;〃用银行家算法判定系统是否安全
while（choice）
{
case1:
addresources（）;break;
case2:
delresources（）;break;
case3:
changeresources（）;break;
case4:
share（）;break;
case5:
addprocess（）;break;
case0:
choice=0;break;
default:
cout<<"请正确选择功能号（0-5）!
"<}
}
return1;
}
调试及运行结果:
检测结果如下:
1•假设系统只有一种资源a,剩余数量为2,分配情况如下:
进程
需求总量
已占资源
还需数量
0
8
4
4
1
4
2
2
2
9
2
7
2•假设系统只有一种资源a,剩余数量为2,分配情况如下:
进程
需求总量
已占资源
还需数量
0
8
3
5
1
4
2
2
2
9
4
5
注：
“系统不安全”表示此种情况是银行家算法也解不了的死锁
3•假设系统有2种资源a,b,a的剩余数量为4,b的剩余数量为3,分
配情况如下：
需求总量
已占资源
还需数量
进程
a
b
a
b
a
b
0
8
7
2
2
6
5
1
9
9
2
1
7
8
2
5
6
2
4
3
2
7.实验总结
通过本次试验，加深了自己对于死锁问题和银行家算法的理解。
对于银行家算法的思想有了更加深刻的认识，并且意识到银行家算法
并不是能避免所有的死锁，可以称这种情况为潜在的死锁。
升级会员 