银行家算法

 Allocation　　　Max　　　Available
 　　ＡＢＣＤ　　ＡＢＣＤ　　ＡＢＣＤ
 P1　００１４　　０６５６　　１５２０　
 P2　１４３２　　１９４２　
 P3　１３５４　　１３５６
 P4　１０００　　１７５０

我们会看到一个资源分配表，要判断是否为安全状态，首先先找出它的Need，Need即Max(最多需要多少资源)减去Allocation(原本已经分配出去的资源)，计算结果如下：

 NEED
 ＡＢＣＤ
 ０６４２　
 ０５１０
 ０００２
 ０７５０

然后加一个全都为false的字段

 FINISH
 false
 false
 false
 false

接下来找出need比available小的(千万不能把它当成4位数 他是4个不同的数)

   NEED　　Available
 ＡＢＣＤ　　ＡＢＣＤ
 ０６４２　　１５２０
 ０５１０<-
 ０００２
 ０７５０

P2的需求小于能用的，所以配置给他再回收

  NEED　　Available
 ＡＢＣＤ　　ＡＢＣＤ
 ０６４２　　１５２０
 ００００　＋１４３２
 ０００２－－－－－－－
 ０７５０　　２９５２

此时P2 FINISH的false要改成true(己完成)

 FINISH
 false
 true
 false
 false

接下来继续往下找，发现P3的需求为0002，小于能用的2952，所以资源配置给他再回收

 　NEED　　Available
 ＡＢＣＤ　　Ａ　Ｂ　Ｃ　Ｄ
 ０６４２　　２　９　５　２
 ００００　＋１　３　５　４
 ０００２－－－－－－－－－－
 ０７５０　　３　12　10　6

同样的将P3的false改成true

 FINISH
 false
 true
 true
 false

依此类推，做完P4→P1，当全部的FINISH都变成true时，就是安全状态。

安全和不安全的状态 [编辑]

如果所有过程有可能完成执行（终止），则一个状态（如上述范例）被认为是安全的。由于系统无法知道什么时候一个过程将终止，或者之后它需要多少资源，系统假定所有进程将最终试图获取其声明的最大资源并在不久之后终止。在大多数情况下，这是一个合理的假设，因为系统不是特别关注每个进程运行了多久（至少不是从避免死锁的角度）。此外，如果一个进程终止前没有获取其它能获取的最多的资源，它只是让系统更容易处理。

基于这一假设，该算法通过尝试寻找允许每个进程获得的最大资源并结束（把资源返还给系统）的进程请求的一个理想集合，来决定一个状态是否是安全的。不存在这个集合的状态都是不安全的。

                   --------------------------------------------------------------来源于维基百科

例题：

某系统有R1，R2，R3共3中资源，在T0时刻P0，P1，P2，P3和P4这5个进程对资源的占用和需求情况如下表1，此时系统的可用资源向量为(3,3,2)。试问：

1、T0时刻系统是否存在安全序列？

2、P1请求资源：P1发出请求向量Request（1,0,2），系统是否接受该请求？请使用银行家算法检查

3、P4请求资源：P4发出请求向量Request（3,3,0），系统按银行家算法检查.

4、P0请求资源：P0发出请求向量Request（0,2,0），系统按银行家算法检查.

　　　　　　表1 T0时刻的资源分配表

	MAX	Allocation	Need	Available
P0	7 5 3	0 1 0	7 4 3	3 3 2
P1	3 2 2	2 0 0	1 2 2
P2	9 0 2	3 0 2	6 0 0
P3	2 2 2	2 1 1	0 1 1
P4	4 3 3	0 0 2	4 3 1

 

an：

　　1、T0时刻系统是否存在安全序列？

　　　　Available > Need1 ----> 可用资源分配给P1，直到P1进程执行完成，然后Available = Available + Allocation1 = （5,3,2）

           Available > Need3 -----> 可用资源分配给P3，直到P3进程执行完成，然后Available = Available + Allocation3 = （7,4,3）

　　　　Available> Need4.....

       　得到安全序列为：P1，P3，P4，P2，P0

　　2、P1请求资源：P1发出请求向量Request（1,0,2），系统是否接受该请求？请使用银行家算法检查

　　　第一步（假分配检查）：把Request分配给P1，必须满足Request要小于Available，Request要小于Need。

                       Request（1,0,2）< Available（3,3,2）

                       Request（1,0,2）< Need（1,2,2）

        因为满足第一步检查，进入第二层检查（安全序列检查）。

　　　第二步（安全序列检查）：建立安全性检查表

	Work	Need	Allocation	Work+Allocation	Finish
P1	2 3 0	0 2 0	3 0 2

　　如果 Work > Need ,那么执行Work+Allocation，得到：　　　　　　　　　　　　　　　　

	Work	Need	Allocation	Work+Allocation	Finish
P1	2 3 0	0 2 0	3 0 2	5 3 2	true
	5 3 2

　  找到Need<Work的进程，如果没有找到这样的进程而进程集合没有执行，则算法返回，得到不存在安全序列结果，否则继续执行该算法。

　  这里我们找到了P3进程。修改安全序列检查表：

	Work	Need	Allocation	Work+Allocation	Finish
P1	2 3 0	0 2 0	3 0 2	5 3 2	true
P3	5 3 2	0 1 1	2 1 1	7 4 3	true
	7 4 3

　　这样一直执行到所有的进程到完成，以完成该安全序列检查表：

	Work	Need	Allocation	Work+Allocation	Finish
P1	2 3 0	0 2 0	3 0 2	5 3 2	true
P3	5 3 2	0 1 1	2 1 1	7 4 3	true
P4	7 4 3	4 3 1	0 0 2	7 4 5	true
P0	7 4 5	7 4 3	0 1 0	7 5 5	true
P2	7 5 5	6 0 0	3 0 2	10 5 7	true

      这样就找到了整个安全序列为：P1，P3，P4，P0，P2

（注释：work的值即为上一项work+allocation，只要满足need<allocation,即执行work+Allocation）