大话操作系统之死锁

Posted 2021-04-19 叁研良语

一、死锁的基本概念

    死锁：指多个进程因竞争共享资源而造成的一种僵局，若无外力作用，这些进程永远不能向前推进。

    死锁发生：双方都拥有部分资源，同时在请求对方已占有的资源。

    产生死锁的原因：

（1） 竞争资源：资源数目不能满足进程需要

    资源一般分为可剥夺和不可剥夺资源，可剥夺的如：处理机、内存（优先权高的剥夺优先权低的）；不可剥夺资源如：磁带、打印机。竞争不可剥夺资源可能会引起死锁

（2） 顺序不当：

    进程运行过程中，请求和释放资源顺序不当；多个进程并发执行，相互的推进顺序不确定，可能会导致出现死锁。

二、产生死锁的必要条件

    只有4个条件都满足时，才会出现死锁。

（1）互斥：任一时刻只允许一个进程使用资源

（2）请求和保持：进程保持了至少一个资源，但又提出了新的资源请求，该资源又被其他进程占用。

（3）不剥夺：进程已经占用的资源，未使用完，不能被剥夺。

（4）环路等待：存在进程－资源环形链，即有进程集合{P0, P1, P2,….Pn},P0等待P1占用的资源，P1等待P2占用的资源…Pn等待P0占用的资源。

三、处理死锁的方法     

（1）预防死锁

    采用某种策略，限制并发进程对资源的请求，使系统在任何时刻都不同时满足死锁的四个必要条件

（2）避免死锁

    在资源的动态分配过程中，防止系统进入不安全状态。

（3）检测死锁

    允许系统进入死锁，但系统及时检测，并采取措施。

（4）解除死锁

    当检测到系统进入了死锁，采取措施解除。 

四、预防死锁

（1）摒弃“请求保持”条件（针对死锁的第2个条件）

    方法：预先静态分配法：

    预先分配进程运行所需的全部资源，保证不等待资源

    优点：简单 、易于实现、安全

    缺点：资源被严重浪费，降低了对资源的利用率，降低进程的并发程度；有可能无法预先知道所需资源

（2）摒弃“不可剥夺”条件

    当一个已经保持了某些资源的进程，再提出新的资源请求而不能立即得到满足时，必须释放它已持有的资源。

    缺点：实现较复杂，代价大。反复申请释放资源，降低系统吞吐率。

（3）摒弃“环路等待”条件

    方法：有序资源使用法：

    把资源分类按顺序排列，所有进程 对资源的请求必须按照资源序号递增次序提出。保证不形成环路；

    缺点：资源序号固定，限制新设备的增加；降低资源利用率；限制了用户简单、自主地编程。 

五、避免死锁--银行家算法

1. 系统的安全状态

    安全序列：指系统能按某种进程顺序（P1, P2, ….Pn），为进程Pi分配其所需资源，直至进程的最大需求，使每个进程都可顺利完成。 则（P1, P2, ….Pn）称为安全序列。

    不安全状态：系统无法找到安全序列

    安全、不安全、死锁状态的关系：

2. 银行家算法中的数据结构

    设系统中共有n个进程，m类资源

(1) 可利用资源向量Available[m]。

    若Available[i]＝k，表示系统中Ri类资源有k个。

(2) 最大需求矩阵Max[n,m]

    若Max[i,j]=k，表示进程 i 需要Rj类资源k个。

(3) 分配矩阵Allocation[n,m]

    若Allocation[i,j] = k，表示进程 Pi 现在拥有 Rj 类型的资源k个。 

(4)需求矩阵Need[n,m]

    若 Need[i,j] = k，表示进程 Pi 最多还需要Rj类型的资源k个，它才能完成任务

    Need[i,j]=Max[i,j]– Allocation[i,j]

3. 资源请求算法

    Requesti为进程 Pi 的请求向量。如果 Requesti [j] = k ，表示进程 Pi 需要Rj类型资源k个。

（1）如果 Requesti <= Needi ，转去执行第2步。否则产生错误，因为进程对资源的请求已经超过它事先声明的最大数量。

（2）如果 Requesti <=Available，转去执行第3步。 否则进程Pi必须等待，因为现有资源不够分配。

（3）假设将进程 Pi 请求的资源分配给它，并按如下方式修改状态      

    Available = Available – Requesti      

    Allocationi = Allocationi + Requesti      

    Needi = Needi – Requesti   

    则系统进入新状态，用安全算法验证新状态是安全的。

    如果安全->将资源分配给进程 Pi，系统进入新状态。

    如果不安全  进程 Pi必须等待，系统保持原状态。

4. 安全算法 

(1)Work 和 Finish 分别是长度为m 和 n 的向量， 分别初始化为：

    Work = Available

    Finish[i]=false (i = 1,3, …, n)

(2)查找这样的 i 使其满足：

    (a) Finish [i] = false

    (b) Needi <= Work

    如果没有这样的 i 存在就转去执行第4步

(3)Work = Work + Allocationi
     Finish[i] = true
     转去执行第2步

(4)如果对所有的i，Finish[i]==true ，那么系统是安全的。否则，系统处于不安全状态。

5. 例题

银行家算法不难，完整做一两道例题就可以理解。

5 个进程： P0~P4；

3类资源：A (10 个实例), B (5 个实例) , C (7 个实例).

假设在 T0时刻,系统状态如下：

导出Need矩阵。 

Need矩阵定义为：  Need = Max – Allocation。

则得到：

 

    用安全算法可证明系统目前是安全的，因为存在安全序列：< P1, P3, P4, P2, P0>. 

    假设这时进程P1发出资源请求：     

    Request1 =  (1,0,2) 

首先检查：     

    Request1 <= Need1  (1,0,2) <= (1,2,2)

再检查 

    Request1 <=Available (1,0,2) <=(3,3,2)

    即满足申请资源的条件。假设将资源分配给它，则得到如下的新状态：

    执行安全算法可以找到安全序列： <P1, P3, P4, P0, P2> 

六、死锁的检测

    系统为进程分配资源时，若未采取避免和预防死锁的措施，系统必须提供检测和解除死锁的手段。即：

（1）保存资源的请求和分配信息

（2）利用某种算法对这些信息加以检查，以判断是否存在死锁。

1. 资源分配图

    有向图G的顶点为资源（矩形框加黑点表示）或进程（圆圈表示）

    从资源R到进程P的边表示资源R已分配1个给进程P

    从进程P到资源R的边表示P正因请求R而处于等待状态。 

 

2.  死锁定理

    资源分配图的化简方法：   

    删除既不处于等待状态又不独立的进程的所有弧（包括请求边和分配边），该点变为孤立点。    

    重复上述过程，若最后所有进程结点是孤立点，则称该资源图是完全可简化的，否则是不可完全简化的

    死锁定理：S为死锁状态的充分条件是：当且仅当S状态的资源分配图不可完全简化。其中的有边进程为死锁进程。

3. 死锁检测算法（类似银行家算法）

（1）检测算法中的数据结构

    设系统中有n个进程，m类资源

    Available:长度为 m 的向量，表示各种类型资源的可用实例数

    Allocation:为 n * m 矩阵，表示目前已分配给各个进程的各种资源的数量

    Request:为 n*m 矩阵，表示目前各个进程请求资源的情况。

    若Request[i,j] = k, 表示进程 Pi 正在请求 k 个类型为Rj的资源。

（2）算法描述

    (1)设Work 和 Finish 分别是长度为m 和 n 的向量，各自初始化为： 

    (a) Work = Available

    (b) 对于i = 1,2, …, n，如果 Allocationi 不等于 0, 那么Finish[i] = false；否则 Finish[i] = true.

    (2) 查找这样的下标 i ，使其满足：

    (a) Finish[i] == false

    (b) Requesti <= Work

    如果不存在这样的 i ，转去执行第4步  

    (3) Work = Work + Allocationi
    Finish[i] = true
    转去执行第2步 。

    (4) 如果对某个i （ 1 <= i <= n ），若Finish[i] == false，那么系统死锁。 而且，如果 Finish[i] == false，那么进程 Pi 正处于死锁状态。

（3）例子如下：

设系统有5个进程P0 - P4；

3类资源：A (7 个), B (2 个), C (6 个).

假设在 T0时刻： 

Allocation        Request        Available

     A B C           A B C           A B C

P0 0 1 0           0 0 0             0 0 0

P1 2 0 0           2 0 2

P2 3 0 3           0 0 0 

P3 2 1 1           1 0 0 

P4 0 0 2           0 0 2

序列： <P0, P2, P3, P1, P4> 表明对所有的i ， Finish[i] = true。即表明系统现在不处于死锁状态。  

七、死锁的解除

解除死锁的方法：

（1）终止进程 

1. 终止所有死锁的进程。代价大。易实现。

2. 一次只终止一个进程，直到消除环路为止。

（2）剥夺资源

1.选择一个牺牲者

    代价最小

2.后退（也称回滚-Rollback）

    退回到安全状态，在此重新启动进程完全回滚：中止进程后重新开始

3.饿死

    如果仅仅是基于代价来选择进程的话，某些进程可能会饿死。因此“代价”还应增加一个因素：做牺牲品的次数。

八、典例拓展

例：

在著名的“哲学家就餐问题”中，当5位哲学家同时饿了，同时取得左手的筷子，再同时申请右手的筷子，此时发生死锁。请简述如何用死锁预防、死锁避免、死锁检测与恢复的方法解决该死锁问题。

答：

死锁预防：

    破坏占有等待条件：每位哲学家拿筷子时必须左右筷子同时申请，即采用资源一次性分配法，若缺一则不可获得资源分配。

    破坏非剥夺条件：第1位哲学家拿筷子时，若左右邻居中有等待资源者，则可强行抢夺其已经占有的筷子。

    破坏循环等待：对5根筷子顺序编号，即1，2，3，4，5，每位哲学家只能按由小到大的顺序申请(资源顺序分配法)。

死锁避免：每次分配筷子时，执行银行家算法，确保系统不会进入不安全状态。

死锁检测与恢复：对筷子的申请和分配不加限制，但定期（例如每隔5秒）检测是否已发生死锁，是则剥夺其中一位哲学家的筷子分配给其他人.