【操作系统】银行家算法

　对于计算机中的死锁，我们有四种处理的方法，分别为预防死锁、避免死锁、检测死锁和解除死锁，而今天要说的Dijkstra的银行家算法就是最具有代表性的避免死锁的算法。

　　银行家算法的名字来源于该算法原本是为银行系统设计的，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况，在OS中可以用它来避免死锁。

　　为实现银行家算法，每一个新进程在进入系统时，必须申明在运行过程中可能需要每种资源类型的最大单元数目，其数目不应超过系统所拥有的资源总量。当进程请求一组资源时，系统必须首先确定是否有足够的资源分配给该进程。若有，再进一步计算在将这些资源分配给进程后，是否会使系统处于不安全状态。如果不会，才将资源分配给它，否则让进程等待。

　　首先为实现银行家算法，在系统中必须设置这样四个数据结构：

　　（1）可利用资源向量Avaliable。这是一个含有m个元素的数组，其中每一个元素代表一类可利用的资源数目，其初始值是系统所配置的该类全部可用资源的数目，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态的改变。如果Available[j]=K，则表示系统中现有R_j类资源的最大数目为K_。

　　（2）最大需求矩阵Max。是一个n×m的矩阵，定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i, j]=K，则表示进程i需要R_j类资源的最大数目为K。

　　（3）分配矩阵Allocation。是一个n×m的矩阵，定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i, j]=K，则表示进程i当前已分得R_j类资源的数目为K。

　　（4）需求矩阵Need。是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i, j]=K，则表示进程i还需要R_j类资源K个方能完成其任务。

　　它们之间的关系为:　　Need[i, j]=Max[i, j]-Allocation[i, j]

　

　　先来看看安全性算法，描述如下：

　　（1）设置两个向量：

　　　　① 工作向量Work，表示系统可提供给进程继续运行所需的各类资源数目，含有m个元素，在执行安全算法开始时，Work=Available；

　　　　② Finish，表示系统是否有足够的资源分配给进程，使之运行完成。先令Finish[i]=false；当有足够资源分配给进程时，令Finish[i]=true。

　　（2）从进程集合中找到一个能满足下述条件的进程：

　　　　① Finish[i]=false；

　　　　② Need[i, j]≤Work[j]；

　　　　若找到，执行步骤（3），否则，执行步骤（4）。

　　（3）当进程P_i获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故执行：

　　　　Work[j]=Work[j]+Allocation[i, j]；

　　　　Finish[i]=true；

　　　　返回步骤（2）。

　　（4）如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态，否则，系统处于不安全状态。

 

　　下面对安全性算法举个实例：

　　假定系统中有5个进程｛P0，P1，P2，P3｝和5类资源，各种资源的数量分别为[5，6，8，6，4]，在某个时刻资源分配情况如下：

进程号	Allocation					Need
P0	0	2	1	1	1	1	0	2	1	1
P1	2	0	1	1	1	0	3	2	1	0
P2	0	1	0	1	1	0	3	3	2	2
P3	0	3	1	2	0	1	0	1	2	1

 

 

 

 

 

　　

　　我们首先先将表格补充完整，已知各种资源的数量，那只需用[5，6，8，6，4]减去所有对应进程号的Allocation的和[2，6，3，5，3]就可以得到Available的值为[3，0，5，1，1]。

　　题目中至少会有Max、Need、Allocation中的两个数据结构，根据公式Need[i, j]=Max[i, j]-Allocation[i, j]即可推出其余的数据结构。

　　比如这道题完整的表格如下：

进程号	Max					Allocation					Need					Available
P0	1	2	3	2	2	0	2	1	1	1	1	0	2	1	1	3	0	5	1	1
P1	2	3	3	2	1	2	0	1	1	1	0	3	2	1	0
P2	0	4	3	3	3	0	1	0	1	1	0	3	3	2	2
P3	1	3	2	4	1	0	3	1	2	0	1	0	1	2	1

 

 

 

 

　　

　　分析过程（最终结果只需一张表格即可）：进行安全性检测，首先根据上述安全性算法得出Work，从P0开始逐行检测，P0时Work=Available，判断发现Need≤Work，则P0满足条件，Finish=true，运算Work+Allocation，并将这个值作为新的Work值进行检测，P1是不满足Need≤Work，则跳过判断P2，同样不满足Need≤Work，跳过判断P3，发现满足Need≤Work，则P3满足条件，Finish=true，运算Work+Allocation，并将这个值作为新的Work值继续进行检测，回到P1，发现P1满足条件，Finish=true，继续进行上述操作，发现P2也满足条件，Finish=true，所有Finish值都为true，故存在这么一条安全序列｛P0，P3，P1，P2｝，故系统是安全的，表格如下：

进程号	Work					Need					Allocation					Work+Allocation					Finish
P0	3	0	5	1	1	1	0	2	1	1	0	2	1	1	1	3	2	6	2	2	true
P3	3	2	6	2	2	1	0	1	2	1	0	3	1	2	0	3	5	7	4	2	true
P1	3	5	7	4	2	0	3	2	1	0	2	0	1	1	1	5	5	8	5	3	true
P2	5	5	8	5	3	0	3	3	2	2	0	1	0	1	1	5	6	8	6	4	true

 

 

 

 

　　

　　反之，如果无法获得一条安全的序列，则系统是不安全的。

 

　　以上就是安全性算法，现在再来看银行家算法的过程。

　　设Request_i是进程Pi的请求向量，如果Request_i[j]=K，表示进程P_i需要K个R_j类型的资源。当P_i发出资源请求后，系统按下述步骤进行检查：

　　（1）如果Request_i[j]≤Need[i, j]，转向步骤（2）；否则所需资源数已超过它所宣布的最大值。

　　（2）如果Request_i[j]≤Available[i, j]，转向步骤（3）；否则无足够资源，P_i需等待。

　　（3）系统试探着把资源分配给进程P_i，并修改下面数据结构中的数值：

　　　　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）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程P_i，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程P_i等待。

　　

　　还是上述表格，若P0请求资源[1，0，0，0，1]，用银行家算法进行检查（因为是P0请求资源所以从P0开始检测）：

　　① Request₀(1，0，0，0，1)≤Need₀(1，0，2，1，1)；

　　② Request₀(1，0，0，0，1)≤Available₀(3，0，5，1，1)；

　　③ 系统先假定可为P0分配资源，并修改Available，Allocation₀，Need₀向量，根据公式可得Available=[2，0，5，1，0]，Need₀=[0，0，2，1，0]，Allocation₀=[1，2，1，1，2]，修改P0的这三个值；

　　④ 利用安全性算法检查此时系统是否安全，如下：

进程号	Work					Need					Allocation					Work+Allocation					Finish
P0	2	0	5	1	0	0	0	2	1	0	1	2	1	1	2	3	2	6	2	2	true
P3	3	2	6	2	2	1	0	1	2	1	0	3	1	2	0	3	5	7	4	2	true
P1	3	5	7	4	2	0	3	2	1	0	2	0	1	1	1	5	5	8	5	3	true
P2	5	5	8	5	3	0	3	3	2	2	0	1	0	1	1	5	6	8	6	4	true

 

 

 

 

　　

　　可以找到一个安全序列｛P0，P3，P1，P2｝。因此，系统是安全的，可以立即将P0所申请的资源分配给它。

　　反之，如果无法获得一条安全的序列，则系统是不安全的，不能将资源分配给它。