这死锁了，你有钥呀

看看“银行家算法”和“死锁检测算法”这两把钥匙，怎么开死锁。

---

A、
假设在系统中有四个进程和四种类型的资源，系统使用银行家算法来避免死锁。最大资源需求矩阵是

Claim=⎡⎣⎢⎢⎢⎢44136435121211171⎤⎦⎥⎥⎥⎥

其中Claimij(1≤i≤4且1≤j≤4)表示进程i对于资源j的醉倒需求。系统中每一种类型的资源总量由向量[16,5,2,8]给出。当前的资源分配情况由下面的矩阵给出。

Allocation=⎡⎣⎢⎢⎢⎢4113021101011020⎤⎦⎥⎥⎥⎥

其中，Allocationij表示当前分配给进程i的资源j的数量。
a)说明这个状态是安全的。
b)说明进程0申请1个单位的资源2是否允许。

解：
a)先将模型建立起来
1.初始状态：
Claim=⎡⎣⎢⎢⎢⎢44136435121211171⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢4113021101011020⎤⎦⎥⎥⎥⎥ Resource=[16,5,2,8]
由Allocation和Resource矩阵可知，可用资源量Available＝[7,1,0,5]
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢03123414020200151⎤⎦⎥⎥⎥⎥，对进程遍历发现P1的资源申请量在可用范围内，则P1先执行。

2.进程P1运行之后:
Claim=⎡⎣⎢⎢⎢⎢40136405120211071⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢4013001100011020⎤⎦⎥⎥⎥⎥
则可用资源量Available＝[8,3,1,5]
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢00123404020200051⎤⎦⎥⎥⎥⎥，发现可用资源可分配给进程P3的资源申请，则P3执行。

3.进程P3运行之后：
Claim=⎡⎣⎢⎢⎢⎢40130405020201070⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢4010001000001020⎤⎦⎥⎥⎥⎥
则可用资源量Available＝[11,4,2,5]
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢00120404020200050⎤⎦⎥⎥⎥⎥，可将可用资源分配给进程P0，执行P0。

4.进程P0运行之后：
Claim=⎡⎣⎢⎢⎢⎢00130005000200070⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢4010001000001020⎤⎦⎥⎥⎥⎥
则可用资源量Available＝[15,4,2,6]
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢00120004000200050⎤⎦⎥⎥⎥⎥，剩余的进程P2也可运行。
综上该状态安全
b)
假设将资源2的分配一个单位给进程0：
1.初始态：
Claim=⎡⎣⎢⎢⎢⎢44136435121211171⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢4113121101011020⎤⎦⎥⎥⎥⎥ Resource=[16,5,2,8]
由Allocation和Resource矩阵可知，可用资源量Available＝[7,0,0,5]
其中总资源量和最大需求量不变，
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢03123314020200151⎤⎦⎥⎥⎥⎥，运行P3进程

2.进程P3运行之后：
Claim=⎡⎣⎢⎢⎢⎢44130435021201170⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢4110121001001020⎤⎦⎥⎥⎥⎥ Resource=[16,5,2,8]
由Allocation和Resource矩阵可知，可用资源量Available＝[10,1,1,5]
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢03120314020200150⎤⎦⎥⎥⎥⎥，可运行进程P1

3. 进程P1运行之后：
Claim=⎡⎣⎢⎢⎢⎢40130405020201070⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢4010101000001020⎤⎦⎥⎥⎥⎥ Resource=[16,5,2,8]
由Allocation和Resource矩阵可知，可用资源量Available＝[11,3,2,5]
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢00120304020200050⎤⎦⎥⎥⎥⎥，运行进程P0

4.进程P0运行之后：
Claim=⎡⎣⎢⎢⎢⎢00130005000200070⎤⎦⎥⎥⎥⎥ Allocation=⎡⎣⎢⎢⎢⎢0010001000000020⎤⎦⎥⎥⎥⎥ Resource=[16,5,2,8]
由Allocation和Resource矩阵可知，可用资源量Available＝[15,4,2,6]
各进程对资源的需求矩阵Claim−Allocation=⎡⎣⎢⎢⎢⎢00120004000200050⎤⎦⎥⎥⎥⎥，剩余的进程P2也可运行至结束。
综上，所有进程能运行结束，可以将资源2的分配一个单位给进程0

---

B、
在银行家算法中，若出现系数资源分配。

进程 Allocation Need P0 0, 0, 3, 2 0, 0, 1, 2 P1 1, 0, 0, 0 1, 7, 5, 0 P2 1, 3, 5, 4 2, 3, 5, 6 P3 0, 3, 3, 2 0, 6, 5, 2 P4 0, 0, 1, 4 0, 6, 5, 6

可用资源：Available＝[1,6,2,2]
问：
1）表格描述的死锁模型是什么？
2）该状态是否安全？
3）如果进程P2提出申请request=[1,2,2,2]

解：
1）本题中，直接给出了需求量，而未给出最大需求量，同时也没有给出资源总量。
Allocation=⎡⎣⎢⎢⎢⎢⎢01100003303053120424⎤⎦⎥⎥⎥⎥⎥ Need=⎡⎣⎢⎢⎢⎢⎢01200073661555520626⎤⎦⎥⎥⎥⎥⎥ Claim=⎡⎣⎢⎢⎢⎢⎢02300076964510864010410⎤⎦⎥⎥⎥⎥⎥
Available＝[1,6,2,2] Resource＝[3,12,14,14]

2）以下使用Allocation、Need、Available三个矩阵进行解题
由初始态可知，可以运行进程P0。
P0运行之后，Available＝[1,6,5,4]，
Allocation=⎡⎣⎢⎢⎢⎢⎢01100003300053100424⎤⎦⎥⎥⎥⎥⎥ Need=⎡⎣⎢⎢⎢⎢⎢01200073660555500626⎤⎦⎥⎥⎥⎥⎥，此时，可以运行进程P3。
P3运行之后，Available＝[1,9,8,6]，
Allocation=⎡⎣⎢⎢⎢⎢⎢01100003000050100404⎤⎦⎥⎥⎥⎥⎥ Need=⎡⎣⎢⎢⎢⎢⎢01200073060550500606⎤⎦⎥⎥⎥⎥⎥，此时，可以运行进程P1。
P1运行之后，Available＝[2,9,8,6]，
Allocation=⎡⎣⎢⎢⎢⎢⎢00100003000050100404⎤⎦⎥⎥⎥⎥⎥ Need=⎡⎣⎢⎢⎢⎢⎢00200003060050500606⎤⎦⎥⎥⎥⎥⎥，此时，可以运行进程P2。
P2运行之后，Available＝[3,12,13,10]，
Allocation=⎡⎣⎢⎢⎢⎢⎢00000000000000100004⎤⎦⎥⎥⎥⎥⎥ Need=⎡⎣⎢⎢⎢⎢⎢00000000060000500006⎤⎦⎥⎥⎥⎥⎥，此时，可以运行进程P4至结束。
综上，所有程序可运行完成，该状态安全。
3）若将现有资源量分配给P2，则可用资源量变为Available＝[0,4,0,0] Need=⎡⎣⎢⎢⎢⎢⎢01100071661535520426⎤⎦⎥⎥⎥⎥⎥
显然，可用资源并不能使得任意一个进程完成，因此，不能分配。

---

C、
把死锁检测算法应用于下面的数据，并给出结果。
Available=[2,1,0,0]

Request=⎡⎣⎢⎢212001010100⎤⎦⎥⎥

Allocation=⎡⎣⎢⎢020001102010⎤⎦⎥⎥

0）Allocation矩阵中未出现某行未0的情况，则不标记进程。
1）初始化W=Available=[2,1,0,0]；
2）在Request中寻找进程i的资源请求小于W，标记进程2，W+=[0,1,2,0]，W=[2,2,2,0]；
3）重新回到Request中寻找进程i的资源请求小于W，标记进程1，W+=[2,0,0,1]，W=[4,2,2,1]
4）发现W可以满足最后一个进程的请求，标记进程0，进程都被标记，表明当前状态未发生死锁。

---

如果单看算法过程，可以发现两个算法并没有太大的差别；那么问题来了，这两个算法明明一样，为什么一定要分开说呢？
是呀，除了死锁模型中的矩阵不一样，还有哪里不同？没错，就是因为模型不一样。
银行家算法，需要最大资源请求量矩阵，这是用于处理进程开始到结束的整一个周期；
而死锁检测算法，并不需要最大资源请求量矩阵，取而代之的是请求量向量，这就可以处理一个进程周期里的某个资源请求。
从而，死锁检测可以减少对处理器的占用，但是缺少了银行家算法能提前判别死锁的能力。
因此，将算法运用到合适的场合，能帮助我们高效的解决问题。