对于计算机中的死锁，我们有四种处理的方法，分别为预防死锁、避免死锁、检测死锁和解除死锁，而今天要说的Dijkstra的银行家算法就是最具有代表性的避免死锁的算法。
银行家算法的名字来源于该算法原本是为银行系统设计的，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况，在OS中可以用它来避免死锁。
为实现银行家算法，每一个新进程在进入系统时，必须申明在运行过程中可能需要每种资源类型的最大单元数目，其数目不应超过系统所拥有的资源总量。当进程请求一组资源时，系统必须首先确定是否有足够的资源分配给该进程。若有，再进一步计算在将这些资源分配给进程后，是否会使系统处于不安全状态。如果不会，才将资源分配给它，否则让进程等待。
首先为实现银行家算法，在系统中必须设置这样四个数据结构：
（1）可利用资源向量Avaliable。这是一个含有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]
先来看看安全性算法，描述如下：
（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[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 |
反之，如果无法获得一条安全的序列，则系统是不安全的。
以上就是安全性算法，现在再来看银行家算法的过程。
设Requesti是进程Pi的请求向量，如果Requesti[j]=K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：
（1）如果Requesti[j]≤Need[i, j]，转向步骤（2）；否则所需资源数已超过它所宣布的最大值。
（2）如果Requesti[j]≤Available[i, j]，转向步骤（3）；否则无足够资源，Pi需等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：
Available[j]=Available[j]-Requesti[j]；
Allocation[i, j]=Allocation[i, j]+Requesti[j]；
Need[i, j]=Need[i, j]-Requesti[j]；
（4）系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
还是上述表格，若P0请求资源[1，0，0，0，1]，用银行家算法进行检查（因为是P0请求资源所以从P0开始检测）：
① Request0(1，0，0，0，1)≤Need0(1，0，2，1，1)；
② Request0(1，0，0，0，1)≤Available0(3，0，5，1，1)；
③ 系统先假定可为P0分配资源，并修改Available，Allocation0，Need0向量，根据公式可得Available=[2，0，5，1，0]，Need0=[0，0，2，1，0]，Allocation0=[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所申请的资源分配给它。
反之，如果无法获得一条安全的序列，则系统是不安全的，不能将资源分配给它。
来源：http://www.cnblogs.com/adamjwh/p/8232811.html