6.死锁

死锁逻辑图

死锁的定义

多个进程由于资源竞争而造成的一种僵局，若无外力作用，这些进程将永远无法向前推进。

死锁的原因以及条件

产生死锁的原因

1. 系统资源的竞争
2. 进程推进顺序不当

产生死锁的必要条件

（只要发生死锁,那么这四个条件必然都成立；反之则不然,有时候即使四个条件都满足,那也不一定发生死锁）

1. 互斥条件：进程间必须互斥使用某些资源才可能产生死锁
2. 不可抢占条件：进程已经获得的资源不能被剥夺
3. 请求和保持条件：进程已经占有至少一个资源，但又提出了新的资源请求
4. 循环等待条件：在发生死锁时，必然存在一个“进程—资源”环形链

死锁的处理策略

• 预防死锁：通过设置某些限制条件，破坏四个必要条件中的一个或几个。该方法比较简单，但由于限制条件过于严格，往往导致系统资源利用率和吞吐量低（预防死锁的方法中，破坏循环等待条件的资源利用率和系统吞吐量最好）

• 避免死锁：不需事先预防，但在资源的动态分配时，用某种方法防止系统进入不安全状态，从而避免死锁。该方法比较难于实现，但可获得较高的资源利用率和系统吞吐量

• 死锁的检测与解除：允许系统产生死锁，但能及时检测出来，并通过某些措施解除。该方法实现难度最大，可获得更好的资源利用率和系统吞吐量

死锁处理策略分析

1. 预防死锁（破坏必要条件，防止死锁发生）

   

   • 破坏“请求和保持”条件 → 一次申请所有资源 ：

     优点：实现简单，安全性较高

     缺点：资源严重浪费，进程延迟运行、发生饥饿现象

   • 破坏“不可抢占”条件 → 强行剥夺：

     比较复杂，而且要付出很大代价，释放已经保持的资源往往意味着前一段工作的失效

     该方法还可能反复的申请和释放资源，而使进程的执行无限期的延长，从而延长了进程的周转时间、增加了系统开销、降低了系统吞吐量

   • 破坏“循环等待”条件 → 顺序资源分配法：

     优点：系统吞吐量和资源利用率都有明显改善

     缺点：

     1. 资源序号必须相对稳定，限制了新设备的增加
     2. 序号的给出可能和用户使用的频率不符，从而造成某些设备长时间闲置
     3. 影响了用户简单、自主的编程（必须按规定次序申请资源）

2. 避免死锁（银行家算法：正确动态分配资源，防止进入不安全状态）

   在避免死锁的方法中，允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次资源分配的安全性。若此次分配不会导致系统进入不安全状态，则将资源分配给进程， 否则，令进程等待。

   安全状态：是指系统能按某种进程推进顺序 \((P_1, P_2,…，P_n)\)，为每个进程\(P_i\)分配其所需资源，直至满足每个进程对资源的最大需求，使每个进程都可顺序完成。此时称\(P_1, P_2,…，P_n\)序列为安全序列，如果系统无法找到这样一个安全序列，则称系统处于不安全状态。

   注意：

   • 系统处于不安全状态不一定发生死锁，发生死锁一定是不安全状态
   • 系统处于安全状态，一定不会发生死锁

   ---

   ★银行家算法：

   • 可利用资源向量 Available:每一个元素代表一类可利用资源的数目
   • 最大需求矩阵Max:每一个进程对每类资源的最大需求
   • 分配矩阵Allocation:每一类资源当前已分配给每一进程的资源数
   • 需求矩阵Need:每一个进程尚需的各类资源数
   • Need=Max-Allocation

   ---

   银行家算法描述：

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

   （1）如果\(Request_i[j]<=Need[i,j]\)，便转向步骤（2）；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。

   （2）如果\(Request_i[j]<=Available[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\)等待。

   ---

   ★安全性算法：

   （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\)都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

   例题1：

   

   （1）

   Process	Work	Allocation	Need	Work+Allocation	Finish
   P0	1 6 2 2	0 0 3 2	0 0 1 2	1 6 5 4	true
   P3	1 6 5 4	0 3 3 2	0 6 5 2	1 9 8 6	true
   P1	1 9 8 6	1 0 0 0	1 7 5 0	2 9 8 6	true
   P2	2 9 8 6	1 3 5 4	2 3 5 6	3 12 13 10	true
   P4	3 12 13 10	0 0 1 4	0 6 5 6	3 12 14 14	true

   由安全性检查可知，存在安全序列{P0,P3,P1,P4,P2}，因此该状态是安全的

   （2）若进程\(P_2\)提出请求\(Request_2(1,2,2,2)\)，系统按银行家算法进行检查

   1. \(Request_2(1,2,2,2)<=Need_2(2,3,5,6)\)

   2. \(Request_2(1,2,2,2)<=Available(1,6,2,2)\)

   3. 系统假定把资源分配给\(P_2\)，并修改\(Allocation ，Need， Available\)向量，如下所示：

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

   4. 由安全性算法可知，此时所有\(Need\)都不满足\(Need<=Available\)，系统中的资源无法满足任何进程的需求，从而进入不安全状态，所以不能将资源分配给\(P_2\)

   ---

   例题2:

   

   (1)

   Need=Max-Allocation=

   Process	Need
   P1	3 4 7
   P2	1 3 4
   P3	0 0 6
   P4	2 2 1
   P5	1 1 0

   
   

   Process	Work	Allocation	Need	Work+Allocation	Finish
   P4	2 3 3	2 0 4	2 2 1	4 3 7	true
   P5	4 3 7	3 1 4	1 1 0	7 4 11	true
   P3	7 4 11	4 0 5	0 0 6	11 4 16	true
   P2	11 4 16	4 0 2	1 3 4	15 4 18	true
   P1	15 4 8	2 1 2	3 4 7	17 5 20	true

   由安全性检查可知，存在安全序列{P4,P5,P3,P2,P1},因此该状态是安全的

   （2）

   1. \(Request_2(0,3,4)<=Need_2(1,3,4)\)

   2. \(Request_2(0,3,4)>Available(2,3,3)\),

   说明没有足够的资源，\(P_2\)需要等待，不能实施资源分配

   （3）

   1. \(Request_4(2,0,1)<=Need_4(2,2,1)\)

   2. \(Request_4(2,0,1)<=Available(2,3,3)\)

   3. 系统假定把资源分配给\(P_4\)，并修改\(Allocation ，Need， Available\)向量

   Process	Allocation	Need	Available
   P1	2 1 2	3 4 7	0 3 2
   P2	4 0 2	1 3 4
   P3	4 0 5	0 0 6
   P4	4 0 5	0 2 0
   P5	3 1 4	1 1 0

   4. 利用安全性算法检查系统此时的状态

   Process	Work	Allocation	Need	Work+Allocation	Finish
   P4	0 3 2	4 0 5	0 2 0	4 3 7	true
   P5	4 3 7	3 1 4	1 1 0	7 4 11	true
   P3	7 4 11	4 0 5	0 0 6	11 4 16	true
   P2	11 4 16	4 0 2	1 3 4	15 4 18	true
   P1	15 4 8	2 1 2	3 4 7	17 5 20	true

   由安全性检查可知，存在安全序列{P4,P5,P3,P2,P1},因此该状态是安全的，可以实施资源分配

3. 检测死锁（死锁定理+资源分配图）

   资源分配图化到最简无死锁，不能化到最简则检测到死锁。

   死锁定理：S状态是死锁的充分条件是，当且仅当S状态的资源分配图是不可完全简化的

   死锁检测：

   • 资源剥夺法
   • 撤销进程法
   • 进程回退法