操作系统学习笔记——死锁（系统模型，特征，预防，避免，检测，恢复，银行家算法）

系统模型：

资源类型R1,R2,....,RM

       CPU，内存，I/O设备等

每个资源类型Ri有Wi实例

每个进程使用资源如下： 

request/get      free resource
use/hold         requested/used resource
release          free resource

可重复使用的资源

在一个时间只能一个进程使用且不能被删除
进程获得资源，后来释放由其他进程重用
资源类型：处理器，I/O通道，主和副存储器，设备和数据结构，如文件，数据库和信号量
如果每个进程拥有一个资源并请求其他资源，死锁可能发生

使用资源

创建和销毁
在I/O缓冲区的中断，信号，消息，信息
如果接收消息阻塞可能会发生死锁
可能少见的组合事件会引起死锁

 

资源分配图，一组顶点V和边E的集合

V有两种类型：P={P1,P2,...,Pn}，集合包括系统中的所有进程 ，R={R1,R2,...,Rm}，集合包括系统中的所有资源类型

边： Pi ->Rj ，表示进程Pi需要Rj资源； Rj -> Pi，资源Rj被进程所使用

如果图中不包含循环 ---->没有死锁

如果图中有循环-----> 1.如果每个资源类只有一个实例，那么死锁；2.如果每个资源类有几个实例，可能死锁

 

死锁特征：

 

死锁可能出现如果四个条件同时成立：4个必要条件

互斥：在一个时间只能有一个进程使用资源
持有并等待：进程保持至少一个资源正在等待获取其他进程持有的额外资源
无抢占：一个资源只能被进程自愿释放，进程已经完成了它的任务之后
循环等待：存在等待进程集合{P0,P1,...,PN}，P0正在等待P1所占的资源，P1正在等待P2占用的资源，...，Pn-1在等待Pn所占用的资源，Pn等待P0

死锁出现，会出现这4个条件，但是这4个条件出现，不一定出现死锁

 

死锁处理办法（预防，避免，检测，恢复）：

预防的约束条件最强，恢复最弱。

1.确保系统永远不会进入死锁状态。

2.运行系统进入死锁状态，然后恢复。

3.忽略这个问题，假装系统中从来没有发生死锁；用于大多数操作系统，包括UNIX

 

死锁预防：限制申请方式

互斥——共享资源不是必须的，必须占用非共享资源。（这方法不好）

占用并等待——必须保证当一个进程请求的资源，它不持有任何其他资源。（要么不占资源，要么占用所有资源，资源利用率低）

       需要进程请求并分配器所有资源，它开始执行之前或允许进程请求资源仅当进程没有资源。

       资源利用率低，可能发生饥饿。

无抢占——（太暴力，抢占别个资源，互斥就没用了）

         如果进程占有某些资源，并请求其他不能被立即分配的资源，则释放当前正占有的资源

        被抢占资源添加到资源列表中

        只有当它能够获得旧的资源以及它请求新的资源，进程可以得到执行

循环等待——对所有资源类型进行排序，并要求每个进程按照资源的顺序进行申请。

 

死锁避免：

需要系统具有一些额外的先验信息提供。

最简单和最有效的模式是要求每个进程声明它可能需要的每个类型资源的最大数目。

资源的分配状态是通过限定提供与分配的资源数量，和进程的最大需求。

死锁避免算法动态检查的资源分配状态，以确保永远不会有一个环形等待状态。

 

当一个进程请求可用资源，系统必须判断立即分配是否能使系统处于安全状态。

系统处于安全状态指：针对所有进程，存在安全序列

序列【P1,P2,...,PN】是安全的：针对每个 Pi，Pi 要求的资源能够由当前可用的资源+所有的 Pj 持有的资源来满足，其中 j<i

        如果Pi 资源的需求不是立即可用，那么Pi 可以等到所有 Pj 完成。

        当 Pi 完成后， P(i+1) 可以得到所需要的资源，执行，返回所分配的资源，并终止

        用同样的方法， P(i+2) ，P(i+3) 和 Pn能获得其所需的资源

 

不安全状态包含了死锁状态。

如果系统处于安全状态---->无死锁

如果处于不安全状态----->可能死锁

避免死锁：确保系统永远不会进入不安全状态

 

银行家算法：

银行家算法以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。

在银行系统中，客户完成项目需要申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求并完成项目时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。

银行家算法前提条件：

多个实例。多个进程、资源实例
每个进程都必须能最大限度地利用资源。
当一个进程请求一个资源，就不得不等待。
当一个进程获得所有的资源就必须在一段有限的时间释放它们。

基于上述前提条件，银行家算法通过尝试寻找允许每个进程获得的最大资源并结束（把资源返还给操作系统）的进程请求的一个理想执行时序，来决定一个状态是否是安全的。

不存在这满足要求的执行时序的状态都是不安全的。

 

银行家算法数据结构：

n = 进程数量， m = 资源类型数量

Max（总需求量）： n x m矩阵。如果Max[i,j] = k，表示进程Pi 最多请求资源类型Rj的k个实例。

Available（剩余空闲量）：长度为m的向量。如果Available[j] = k，有k个类型Rj的资源实例可用。运行过程中动态变化的

Allocation（已分配量）： n x m矩阵。如果Allocation[i, j] = k，则Pi 当前分配了 k 个Rj 的实例。

Need（未来需要量）： n x m 矩阵。如果 Need[i, j ] = k，则Pi 可能需要至少k个 Rj 实例来完成任务。

 

关系：Need[i, j] = Max[i , j ] - Allocation[i , j]

 

安全状态估计算法：

1. Work和 Finish 分别是长度为m 和 n 的向量。
   初始化： 
         Work = Available                       当前资源剩余空闲量
        Finish[i] = false for i 1,2,...,n       线程i没结束
2. 找这样的i ：        接下来找出Need 比 Work小的进程i
    (a) Finish[i] = false
    (b) Need(i) <= Work
    没有找到这样的i，转4
3. Work = Work + Allocation(i)    进程i的资源需求量小于当前剩余空闲资源量，
   Finish[i] = true               所以配置给它再回收
   转2
4. If Finish[i] = true for all i,        所有进程的Finish为True，表明系统处于安全状态
    then the system is in a safe state

如果所有进程都能完成，那么就是一个安全状态。

 

银行家算法：

初始化：请求 = 进程Pi 的请求向量，如果 Request i [j] = k ，那么进程Pi 想要 k 个资源 Rj 的实例。

While:

1.如果 Request i <= Need i，转到步骤2。否则，提出错误条件，因为进程已经超过了其最大要求

2.如果 Request i <= Available，转到步骤3。否则 Pi 必须等待，因为资源不可用。

3.假装给Pi 分配它需要的资源：  //生成一个需要判断状态是否安全的资源分配环境。将更新后的数据传入安全状态估计算法

Available =  Available - Request;
Allocation(i) = Allocation(i) + Request(i);
Need(i) = Need(i) - Request(i);

  如果返回safe，将资源分配给Pi；如果返回unsafe，Pi必须等待，等待旧的资源分配状态被恢复

 

例子：

claim matrix C。最大需要的资源MAX

	R1	R2	R3
P1	3	2	2
P2	6	1	3
P3	3	1	4
P4	4	2	2

Allocation matrix A。已经分配了的情况

	R1	R2	R3
P1	1	0	0
P2	6	1	2
P3	2	1	1
P4	0	0	2

Need矩阵。C-A

	R1	R2	R3
P1	2	2	2
P2	0	0	1
P3	1	0	3
P4	4	2	0

  Resource vector R                         

R1	R2	R3
9	3	6

Available vector V

R1	R2	R3
0	1	1

以上是初始状态。

接下来看哪个进程的需求资源时满足Available的，发现P2的【0, 0，1】满足，因为它小于 【0,1,1】，所以P2可以完成任务，然后将它的资源返还给系统，就是将已分配的【6,1,2】返还给Available，此时矩阵会如下：

Allocation matrix A:

	R1	R2	R3
P1	1	0	0
P2	0	0	0
P3	2	1	1
P4	0	0	2

Need矩阵。C-A

	R1	R2	R3
P1	2	2	2
P2	0	0	0
P3	1	0	3
P4	4	2	0

Available vector V

R1	R2	R3
6	2	3

接下来进入下一个阶段，从P1,P3,P4中，看哪个进程的Need满足Avaliable，发现都小于可用资源，都满足，所以就随便选一个，先选P1，P1完成了任务，将P1分配的资源返还给系统：

Allocation matrix A:

	R1	R2	R3
P1	0	0	0
P2	0	0	0
P3	2	1	1
P4	0	0	2

Need矩阵。C-A

	R1	R2	R3
P1	0	0	0
P2	0	0	0
P3	1	0	3
P4	4	2	0

Available vector V

R1	R2	R3
7	2	3

再P3,P4随便选一个：假如选P3

Allocation matrix A:

	R1	R2	R3
P1	0	0	0
P2	0	0	0
P3	0	0	0
P4	0	0	2

Need矩阵。C-A

	R1	R2	R3
P1	0	0	0
P2	0	0	0
P3	1	0	3
P4	4	2	0

Available vector V

R1	R2	R3
9	3	4

最后再选P4。

所以所有的进程都能顺利结束，他们的资源也能得到满足。这就是安全的状态。

所以P2,P1,P3,P4就是安全的序列。

 

不安全的状态的例子就不写了。反正就是Available vector不能让所有进程得到所需的资源。

 

银行家算法就是假定分配给某进程资源后，剩下的状态是否是安全的，是的话就能给他分配。

 

死锁检测：

条件更宽了。允许系统进入死锁状态。

 

每个资源类型单一实例：

资源分配图简化为资源等待图

定期调用检测算法来搜索图中是否存在循环。算法需要n^2次操作，n是图中顶点的数目。

 

资源类型几个实例：

数据结构：

Available：长度为M的向量表示每种类型可用资源的数量。

Allocation：一个 n x m矩阵定义了当前分配给各个进程每种类型资源的数量。如果Allocation[i, j ]  = k ，进程 Pi 拥有资源 Rj 的k个实例。

Request：一个 n x m矩阵表示各进程的当前请求。如果Request[ i , j ] = k，表示进程Pi 请求 k 个资源 Rj 的实例。

死锁检测算法：

和检查安全序列很像

死锁检测算法

1.Work 和 Finish 分别是长度为m与 n 的向量，初始化：
    (a) Work = Available                            work为当前空闲资源量
    (b) For i = 1,2,...,n, if Allocation i > 0,     Finish为线程是否可结束
        then Finish[i] = false;
        otherwise Finish[i] = true.
2.找出这样的索引 i ：
    (a) Finish[i] = false        线程没有结束的线程，且此线程将
    (b) Request i <= Work        需要的资源量小于当前空闲资源量
    如果没有找到，转到4.
3. Work = Work + Allocation i，    把找到的线程拥有的资源释放回当前空闲资源中
    Finish[i] = true
    转到2.
4. If Finish[i] == false,            如果有Finish[i]等于false，这表示系统处于死锁
    for some i,1<=i<=n，
    系统处于死锁状态。此外，
    if Finish[i] == false,Pi死锁

算法需要O(m*n^2)操作检测是否系统处于死锁状态。

在操作系统很少使用检测、银行家算法的原因：开销比较大；对银行家算法来说，每个进程需要提前知道每个进程所需要的最大资源个数，对一般程序来说，这个信息很难获得。

更多的是用来调试。

 

死锁恢复：

终止所有的死锁进程；

在一个时间内终止一个进程直到死锁消除

终止进程的顺序应该是：

进程的优先级
进程运行了多久以及需要多少时间才能完成
进程占用的资源
进程完成需要的资源
多少进程需要被终止
进程是交互还是批处理

选择一个受害者 —— 最小的成本
回滚 —— 返回到一些安全状态，重启进程到安全状态
饥饿 —— 同一进程可能一直被选作受害者，包括回滚的数量。