银行家算法.docx
《银行家算法.docx》由会员分享，可在线阅读，更多相关《银行家算法.docx（14页珍藏版）》请在冰豆网上搜索。
银行家算法
银行家算法
1课程设计的目的
通过此次课程设计，了解多道程序系统中多个进程并发执行的资源分配，掌握死锁产生的原因，产生死锁的必要条件以及预防死锁的方法。
清楚系统安全态的基本概念掌握银行家算法，了解资源在并发执行中资源分配策略。
理解死锁避免，在当前计算机系统中不常使用的原因。
模拟银行家算法，用银行家算法实现资源分配。
2课程设计的开发语言
此次课程设计，采用C语言作为基本的编程语言。
其编程实现简单，结构清晰，更接近硬件，执行效率高。
3功能描述
本程序模拟银行家管理银行，可以把一定数量的作业供多个用户周转使用，为了保证作业的安全银行家规定：
（1）当一个用户对作业的最大需求量不超过管理员现有的资金就要接纳该用户。
（2）用户可以分期贷款，但贷款的总数不能超过最大需求量。
（3）当管理员现有的作业不能满足用户的要求，对该用户的请求可以推迟支付，但总能是用户在有限的时间里得到请求。
（4）当用户得到所需的全部作业后，一定能在有限的时间里归还所有的作业。
假设有4类资源A，B，C，D。
如果要满足上述条件系统必须具备4个功能：
（1）完成输出某时刻的资源分配检测。
（2）利用银行家算法设计安全态。
（3）进行安全性检查。
（4）统一调度，按需求调配资源。
4设计方案论证
4.1设计思路
设Request[i][j]是进程Pi的请求向量，如果Request[i][j]=K，表示进程Pi需要K个Rj类型的资源。
当Pi发出资源请求后，系统按下面步骤进行检查：
（1）如果Resquest[i][j]<=Need[i,j]，便转向步骤
（2）；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。
如果Resquest[i][j]<=Available[j]，便转向（3）；否则，表示尚无足够资源，Pi需等待。
（2）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值；
Available[j]:
=Available[j]-Resquest[i][j]；
Allocation[i,j]:
=Allocation[i,j]+Resques[i][j]；
Need[i,j]:
=Need[i,j]-Resquest[i][j]；
（3）系统执行安全算法，检查此处资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的分配状态，让进程Pi等待。
4.2结构设计
图1系统总体功能框图
系统函数的描述及流程图
（1）当前资源资源显示函数output（）：
显示当前资源分配详细情况，包括：
各种资源的总数，系统目前各种资源可用的数量、个进程已经得到的资源数量、各进程还需的资源量。
（2）银行家算法bank（）：
进银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。
（3）当前安全态检查函Security（）：
用于判断当前状态的安全性，根据不同地方调用提示处理不同的事件。
（4）主函数main（）：
逐个调用上面的方法，进行显示状态、安全性检查、银行家算法函数，是进程
图2银行家算法的主函数流程图
图3资源输出函数output（）的流程图
4.3算法设计
4.3.1死锁产生的原因
（1）竞争资源。
当系统中多个进程共享资源，如打印机、公用队列等，其数目不足以满足进程需要时，就会引起诸进程对资源的竞争，产生死锁。
其中，竞争的资源包括：
可剥夺和非可剥夺性资源，以及临界资源。
（2）进程间推进顺序非法。
进程在运行过程中，请求和释放的顺序不当，也同样会导致产生进程死锁。
其中进程的推进包括：
进程推进合法和进程推进非法。
4.3.2产生死锁的必要条件
（1）互斥条件。
指进程所分配到的资源进程进行排它性使用，即在一段时间内某资源只有一个进程占用。
如果此时还有其它进程请求该资源，则请求者只能等待，直至占有该资源的进程用完间资源释放。
（2）请求和保持条件。
指进程已经保持了至少一个资源，但有提出了新的资源请求，而该资源又被其它进程占有，此时请求进程阻塞，但又对自己已占的资源保持不妨。
（3）不剥夺条件。
指进程已获得资源，在未之前不能被剥夺，只能在使用完时自己释放。
（4）环路等待条件。
只在发生死锁时，必然存在一个资源的环形链。
4.3.3处理死锁的基本方法
（1）预防死锁。
该方法通过某些条件，去破坏产生死锁的四个必要条件。
（2）避免死锁。
在资源的动态分配过程中，用某种方法去防止系统进入不安全状态。
（3）检测死锁。
系统通过设置死锁检测机构，及时检测出死锁的发生。
（4）解除死锁。
当检测出系统发生死锁时，采用某种机制，将进程从死锁状态解脱出来。
4.3.4利用银行家算法避免死锁的数据结构
（1）可以用资源向量Available。
这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初值系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态的改变。
如果Available[j]=K，则表示系统中该类资源有K个。
（2）最大需求矩阵Max。
n*m的矩阵，它定义了系统中的每一类资源当前已分配给每一进程的资源数。
如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K。
（3）需求矩阵Need。
这也是n*m的矩阵，用以表示每一个进程尚需的各类资源数。
如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务。
上述三个矩阵间存在下述关系：
Need[i,j]=Max[i,j]-Allocation[i,j]；
4.4系统函数设计
4.4.1安全态检查函数Security（）
（1）设置两个工作向量work=available；finish[m]=false；
（2）从进程集合中找到一个满足下述条件的的进程
finish[i]=false；need<=work；如果找到就执行（3）；否则执行（4）；
（3）设进程获得资源可顺利执行，直至完成，从而释放资源。
work=work+allocation；finish=true；Goto2;
（4）如果所有的进程finish[m]=true,则表示安全；否则系统不安全。
intSecurity（intavialable[4],intneed[5][4],intallocation[5][4]）
{
intj,i,work[4],finish[5]={0,0,0,0,0};
for（j=0;j<4;j++）
work[j]=avialable[j];
for（i=0;i<5;i++）
{if（finish[i]==0）{
for（j=0;j<4;j++）if（need[i][j]<=work[i]&need[i][j]<=work[i]&need[i][j]<=work[i]）
work[j]=work[j]+allocation[i][j];finish[j]=1;}}
for（i=0;i<5;i++）
{if（finish[i]==0）return0;
elsereturn1;}
}
4.4.2银行家算法函数bank（）
进程i发出请求申请k个j资源，Resquest[i][j]=k
（1）检查申请量是否大于需求量：
Resquest[i][j]<=Need[i,j]，若条件不符重新输入，不允许申请量大于需求量。
（2）检查申请量是否小于系统中的可以用的资源数：
Resquest[i][j]<=Available[j]，若条件不符，申请资源失败，阻塞该进程，用goto语句跳到重新申请资源。
（3）若以上两个条件都满足，则系统试探将资源分配给申请的进程，并修改数据结构的值。
Available[j]:
=Available[j]-Resquest[i][j]；
Allocation[i,j]:
=Allocation[i,j]+Resques[i][j]；
Need[i,j]:
=Need[i,j]-Resquest[i][j]；
（4）试分配后，执行安全性检查，调用安全算法检查此次资源分配后系统是否出于安全态。
若安全，才正式将资源分配给进程；否则本次试探失败，恢复原来的资源分配状态，让进程等待。
Bank（inti,intrequest[4],intneed[5][4],intavialable[3],intallocation[5][4]）
{intj;
printf（"Theprocessid:
%d\n",i）;
for（j=0;j<4;j++）
printf（"%d",request[j]）;
if（request[0]<=need[i][0]&request[1]<=need[i][1]&request[2]<=need[i][2]<=resquest[3]）
{if（request[0]<=avialable[0]&request[1]<=avialable[1]&request[2]<=avialable[2]）
{for（j=0;j<4;j++）{
avialable[j]=avialable[j]-request[j];
allocation[i][j]=allocation[i][j]+request[j];
need[i][j]=need[i][j]-request[j];}
}
4.5数据表格
假定系统中有5个进程{P0,P1,P3,P4,P5}和三类资源{A,B,C,D},各类资源的数量分别为在T0时刻的资源分配情况
表1T0时刻的资源分配表
资源情况
进程
Max
ABCD
Allocation
ABCD
Need
ABCD
Available
ABCD
P0
0044
0032
0012
1622
P1
2750
1000
1750
P2
361010
1354
2356
P3
0984
0332
0652
P4
06610
0014
0656
5源程序代码
output（intarr[5][4]）
{
inti;
intj;
printf（"ABC\n"）;
for（i=0;i<5;i++）
{
printf（"P%d",i）;
for（j=0;j<4;j++）
{
printf（"%d",arr[i][j]）;}
printf（"\n"）;
}
}
intSecurity（intavialable[4],intneed[5][4],intallocation[5][4]）
{
intj;
inti;
intwork[4];
intfinish[5]={0,0,0,0,0};
for（j=0;j<4;j++）
work[j]=avialable[j];
for（i=0;i<5;i++）{
if（finish[i]==0）
{
for（j=0;j<4;j++）
if（need[i][j]<=work[i]&need[i][j]<=work[i]&need[i][j]<=work[i]）
work[j]=work[j]+allocation[i][j];
finish[j]=1;
}
}
for（i=0;i<5;i++）
{if（finish[i]==0）
return0;
elsereturn1;
}
}
Bank（inti,intrequest[4],intneed[5][3],intavialable[4],intallocation[5][4]）
{
intj;
printf（"Theprocessid:
%d\n",i）;
printf（"TheProcessRequest:
"）;
for（j=0;j<4;j++）
printf（"%d",request[j]）;
printf（"\n"）;
if（request[0]<=need[i][0]&request[1]<=need[i][1]&request[2]<=need[i][2]）
{
if（request[0]<=avialable[0]&request[1]<=avialable[1]&request[2]<=avialable[2]）
{
for（j=0;j<4;j++）
{
avialable[j]=avialable[j]-request[j];
allocation[i][j]=allocation[i][j]+request[j];
need[i][j]=need[i][j]-request[j];
}
printf（"Thesourceafterrequest:
\n"）;
printf（"Allocation\n"）;
output（allocation）;
printf（"Need\n"）;
output（need）;
printf（"TheAvialableafterrequest:
"）;
for（j=0;j<4;j++）
printf（"%d",avialable[j]）;
printf（"\n"）;}
elseprintf（"RequestError!
"）;
}
elseprintf（"RequestError!
"）;
}
main（）
{
intid,i;
intAvialable[4]={1,6,2,2};
intMax[5][4]={{0,0,4,4},{2,7,5,0},{3,6,10,10},{0,9,8,4},{0,6,6,10}};
intAllocation[5][4]={{0,0,3,2},{1,0,0,0},{1,3,5,4},{0,3,3,2},{0,0,1,4}};
intNeed[5][4]={{0,0,1,2},{1,7,5,0},{2,3,5,6},{0,6,5,2},{0,6,5,6}};
intRequest[4];
printf（"Thesourcebeforerequest:
\n"）;
printf（"MAX\n"）;
output（Max）;
printf（"Allocation\n"）;
output（Allocation）;
printf（"Need\n"）;
output（Need）;
printf（"TheAvialablebeforerequest:
"）;
for（i=0;i<4;i++）
printf（"%d",Avialable[i]）;
printf（"\n"）;
printf（"InputtheidandrequestofProcess:
"）;
scanf（"%d%d%d%d%d",&id,&Request[0],&Request[1],&Request[2],&Request[3]）;
Bank（id,Request,Need,Avialable,Allocation）;
}
6运行结果与分析
程序运行时首先进入此界面，在主界面上有5个进程分别为{P0，P1，P2，P3，P4}，包含4类资源A，B，C，D。
显示它们对资源的最大需求矩阵，已分配矩阵和需求矩阵，以及系统当前可用的资源。
可以根据所给的提示输入进程号和对资源的需求量。
图4银行家算法的初始运行界面
根据提示输入所选的进程号和它所需要的各类资源数，系统自动进行安全态检查，分析资源是否可以分配给该进程，以及分匹配后，系统所剩的可用资源数。
每次分配完后，系统资源的最大分配矩阵，可分配矩阵，以及需求矩阵都会发生相应的变化。
分配完后，将显示出分配完后所剩资源数，供用户进行下面的判断。
图5进行资源分配后的界面
如果进程所申请的资源数大于它的需求，或者是大于现在已有的资源数，系统进行检查，认为此时进程进程的请求不合理，不予以处理，分配资源失败。
图6进程请求失败运行界面
7设计体会
本次课程设计用C语言编程模拟银行家算法，主要为了确定安全态，解决死锁问题。
具体实现利用了3个矩阵来完成。
在设计过程中，深化了对死锁问题的理解。
从死锁产生的原因，产生死锁的必要条件，到如何解决死锁，直至最后用银行家算法确定安全态。
银行家算法是一个分配资源的过程，是分配的顺序不会产生死锁。
其基本思想是，按该算法分配资源时，每次分配后存在这一个进程，如果让它单独运行下去，必须让它获得所需的全部资源，也就是说他能结束，而它结束又能将资源释放，给其它进程使用。
整个过程中，增加了对课堂知识的理解，并能够根据自己的理解让其用程序实现，将课堂所学勇于实践，自己的能力也有所提高。
对于此算法，其基本功能均已实现，但也有需要提高的地方。
由于是模拟银行家算法，所以，在编程时事先限定了进程的个数。
如果要使程序更加完美，可以采用循环，让其动态输入，但基本原理不变。
该课程设计进一步培养综合应用知识进行程序设计的能力。
通过完成这一设计,学会利用计算机解决实际问题的初步能力,对课本上的知识进行了复习，从中找出了不少盲点，清楚了只有把学的知识作扎实，多动手多思考，这样才能最大限度的减少知识的漏洞。
参考文献
[1]屠立德.计算机操作系统基础[M].北京:
清华大学出版社,2000.3:
30-48
[2]申利民.操作系统常见题解析及模拟题[M].北京:
国防工业出版社.2004.1:
20-39
[3]陈琦.操作系统实验指导书[M].北京：
电子工业出版社,1999.2:
10-20
[4]张尧学.张高,计算机操作系统教程[M].北京:
清华大学出社,2006:
119-125
[5]汤子赢,哲凤屏，汤晓丹.计算机操作系统（修订版）[M].西安:
西安电子科技大学出版社:
2006.10:
90-100
升级会员 