当前位置：首页 > news >正文

2.4 死锁 (答案见原书 P165)

news 2025/9/22 11:23:40

第2章进程与线程 (续)

2.4 死锁 (答案见原书 P165)

01. 下列情况中,可能导致死锁的是 ( C )

题目原文

下列情况中,可能导致死锁的是 ( )
A. 进程释放资源
B. 一个进程进入死循环
C. 多个进程竞争资源出现了循环等待
D. 多个进程竞争使用共享型的设备

正确答案：C

题目解析

考点分析： 本题考察产生死锁的四个必要条件。
死锁四条件：
1. 互斥 (Mutual Exclusion): 资源是排他性使用的。
2. 占有并等待 (Hold and Wait): 进程已占有至少一个资源，同时又在请求新的资源。
3. 非剥夺 (No Preemption): 资源不能被强制抢占。
4. 循环等待 (Circular Wait): 存在一个进程资源的循环等待链。
正确选项分析 (C. 多个进程竞争资源出现了循环等待)：
- 循环等待是产生死锁的最直接、最形象的特征。当互斥、占有并等待、非剥夺这三个条件都已满足时，只要再形成一个循环等待链，死锁就必然发生。
- 因此，出现循环等待是导致死锁的关键情况。
错误选项分析：
- A. 进程释放资源：是解除死锁的可能手段，而不是导致。
- B. 死循环：是进程自身的逻辑问题，会耗尽CPU时间，但与多个进程间的资源死锁无关。
- D. 共享型设备：如磁盘，可以被多个进程并发访问，不满足“互斥”条件，因此不会因为竞争共享设备而死锁。

02. 在哲学家进餐问题中…下列说法中正确的是 ( C )

题目原文
02. 在哲学家进餐问题中,若所有哲学家同时拿起左筷子,则发生死锁,因为他们都需要右筷子才能用餐。为了让尽可能多的哲学家可以同时用餐, 并且不发生死锁, 可以利用信号量 PV 操作实现同步互斥, 下列说法中正确的是 ( )
A. 使用信号量进行控制的方法一定可以避免死锁
B. 同时检查两支筷子是否可用的方法可以预防死锁,但是会导致饥饿问题
C. 限制允许拿起筷子的哲学家数量可以预防死锁,它破坏了“循环等待”条件
D. 对哲学家顺序编号,奇数号哲学家先拿左筷子,然后拿右筷子,而偶数号哲学家刚好相反,可以预防死锁,它破坏了“互斥”条件

正确答案：C

题目解析

考点分析： 本题考察哲学家就餐问题的死锁预防策略。
正确选项分析 (C. 限制允许…哲学家数量…破坏了“循环等待”)：
- 方法： 最多只允许n-1（即4个）哲学家同时拿起筷子。
- 原理： 如果最多只有4个哲学家在桌上，即使他们都拿起了左手的筷子，也必然会剩下5-4=1只筷子是空闲的。那么，至少有一个哲学家（那个空闲筷子旁边的）可以拿到第二只筷子，从而吃完饭、释放筷子，打破这个潜在的循环等待链。
- 因此，这个方法通过破坏“循环等待”条件来预防死锁。
错误选项分析：
- A: 使用信号量如果编程不当，同样会死锁（如经典的死锁解法）。
- B: 同时检查（一次性申请所有资源）破坏的是“占有并等待”条件，且不会导致饥饿。
- D: 奇偶编号哲学家按不同顺序拿筷子，破坏的也是“循环等待”条件，而不是“互斥”条件（筷子本身仍然是互斥的）。

03. 下列关于进程死锁的描述中,错误的是 ( C )

题目原文
03. 下列关于进程死锁的描述中,错误的是 ( )
A. 若每个进程只能同时申请或拥有一个资源,就不会发生死锁
B. 若多个进程可以无冲突共享访问所有资源,就不会发生死锁
C. 若所有进程的执行严格区分优先级, 就不会发生死锁
D. 若进程资源请求之间不存在循环等待,就不会发生死锁

正确答案：C

题目解析

考点分析： 本题考察对死锁条件的深入理解。
错误选项分析 (C. 若所有进程的执行严格区分优先级, 就不会发生死锁)：
- 这是错误的。简单的优先级方案不能保证避免死锁。
- 反例： 进程P1（优先级高）占有资源R1，请求资源R2。同时，进程P2（优先级低）占有资源R2，请求资源R1。此时，即使P1优先级高，它也无法从P2那里抢占到R2（因为不满足“可剥夺”条件），而P2又因为优先级低无法运行来释放R2。死锁依然发生。
正确选项分析：
- A: 正确。如果每个进程最多只拥有一个资源，它就不会在占有资源的同时去请求另一个资源，从而破坏了“占有并等待”条件。
- B: 正确。如果资源都是可共享的，就破坏了“互斥”条件。
- D: 正确。循环等待是死锁的四个必要条件之一。

04. 一次分配所有资源的方法可以预防死锁的发生,它破坏死锁 4 个必要条件 ( B )

题目原文
04. 一次分配所有资源的方法可以预防死锁的发生,它破坏死锁 4 个必要条件 ( )
A. 互斥 B. 占有并请求 C. 非剥夺 D. 循环等待

正确答案：B

题目解析

考点分析： 本题考察死锁预防策略与死锁条件的对应关系。
正确选项分析 (B. 占有并请求, Hold and Wait)：
- 方法： 要求一个进程在开始执行前，必须一次性地申请到它所需要的全部资源。如果不能全部分配，则一个资源也不给它，让它等待。
- 原理： 这种方法保证了任何一个正在运行的进程，都不会处于“已经占有了一部分资源，同时又在请求新资源”的状态。
- 它直接破坏了“占有并请求”这个必要条件。
错误选项分析：
- A, C, D: 这种方法不影响互斥、非剥夺和循环等待这三个条件。

05. 系统产生死锁的可能原因是 ( A )

题目原文
05. 系统产生死锁的可能原因是 ( )
A. 独占资源分配不当
B. 系统资源不足
C. 进程运行太快
D. CPU 内核太多

正确答案：A

题目解析

考点分析： 本题考察产生死锁的根本原因。
正确选项分析 (A. 独占资源分配不当)：
- 死锁的本质是多个进程对独占资源（互斥资源） 的不当竞争。
- “分配不当”可以体现在两个方面：
  1. 资源分配策略有问题，允许了“占有并等待”等危险状态的出现。
  2. 进程推进顺序不当，导致形成了循环等待链。
- 这两者都属于广义上的“分配不当”。
错误选项分析：
- B. 系统资源不足： 资源不足是死锁产生的诱因，但不是根本原因。即使资源充足，如果分配策略不当，仍然可能发生死锁。
- C, D: 与进程运行速度和CPU核数无关。

06. 死锁的避免是根据 ( D ) 采取措施实现的。

题目原文
06. 死锁的避免是根据 ( ) 采取措施实现的。
A. 配置足够的系统资源
B. 使进程的推进顺序合理
C. 破坏死锁的四个必要条件之一
D. 防止系统进入不安全状态

正确答案：D

题目解析

考点分析： 本题要求区分死锁预防和死锁避免这两个概念。
正确选项分析 (D. 防止系统进入不安全状态)：
- 死锁避免 (Deadlock Avoidance): 是一种动态的策略。它不限制死锁必要条件的成立，而是允许进程动态地申请资源。
- 但是，在每次分配资源之前，系统会先进行一次安全性检查（如运行银行家算法），预测这次分配是否可能导致未来发生死锁。
- 如果分配后系统会进入不安全状态（即找不到一个能让所有进程都顺利完成的安全序列），系统就会拒绝这次分配，让进程等待。
- 因此，死锁避免的核心思想就是防止系统进入不安全状态。
错误选项分析：
- C: 破坏死锁的四个必要条件之一，是死锁预防（Deadlock Prevention） 的策略。

07. 死锁预防是保证系统不进入死锁状态的静态策略,其解决办法是破坏产生死锁的四个必要条件之一。下列方法中破坏了“循环等待”条件的是 ( D )

题目原文
07. 死锁预防是保证系统不进入死锁状态的静态策略,其解决办法是破坏产生死锁的四个必要条件之一。下列方法中破坏了“循环等待”条件的是 ( )
A. 银行家算法 B. 一次性分配策略 C. 剥夺资源法 D. 资源有序分配策略

正确答案：D

题目解析

考点分析： 本题考察死锁预防中，破坏“循环等待”条件的具体方法。
正确选项分析 (D. 资源有序分配策略)：
- 方法： 将系统中所有的资源类型进行线性排序，并赋予唯一的序号。
- 规则： 规定所有进程申请资源时，都必须严格按照序号递增的顺序进行申请。
- 原理： 这种方法保证了资源分配图中不可能出现环路。例如，一个进程占有了高序号的资源后，就不能再回头去申请低序号的资源，从而破坏了形成循环等待链的可能。
错误选项分析：
- A. 银行家算法：属于死锁避免。
- B. 一次性分配策略：破坏“占有并等待”。
- C. 剥夺资源法：破坏“非剥夺”。

08. 可以防止系统出现死锁的手段是 ( C )

题目原文
08. 可以防止系统出现死锁的手段是 ( )
A. 用 PV 操作管理共享资源 B. 使进程互斥地使用共享资源
C. 采用资源静态分配策略 D. 定时运行死锁检测程序

正确答案：C

题目解析

考点分析： 本题要求从几个选项中找出能预防（防止） 死锁的策略。
正确选项分析 (C. 采用资源静态分配策略)：
- 资源静态分配策略就是指一次性分配所有资源的方法。
- 如第4题所述，这种方法通过破坏“占有并等待”条件，可以从根本上预防死锁的发生。
错误选项分析：
- A: PV操作使用不当，恰恰是导致死锁的常见原因。
- B: 互斥是死锁的必要条件之一，不是防止手段。
- D: 死锁检测程序是在死锁已经发生后进行检测和解除，属于死锁检测与解除，而不是“防止”。

09. 某系统中有三个并发进程都需要四个同类资源,则该系统必然不会发生死锁的最少资源是 ( B )

题目原文
09. 某系统中有三个并发进程都需要四个同类资源,则该系统必然不会发生死锁的最少资源是 ( )
A. 9 B. 10 C. 11 D. 12

正确答案：B

题目解析

考点分析： 本题是经典的利用死锁定理进行计算的题目。
死锁定理：
- 设有 n 个进程，每个进程最多需要 m 个同类资源。
- 系统中该类资源的总数为 R。
- 必然不会发生死锁的充分条件是：R > n * (m - 1)。
- 最少资源数就是 n * (m - 1) + 1。
分析过程：
1. 确定参数：
  - 进程数 n = 3。
  - 每个进程最多需要 m = 4 个资源。
2. 计算最坏情况：
  - 死锁发生的最坏情况是，每个进程都只差最后一个资源就能完成任务。
  - 即，3个进程每个都先成功申请到了 m-1 = 4-1 = 3 个资源。
  - 此时，它们都占有3个，同时请求第4个，形成死锁。
  - 为了避免这种情况，系统中的总资源数 R 必须多到，即使在这种最坏情况下，也至少还剩一个资源可以分配给其中一个进程，让它完成、释放资源，从而打破僵局。
3. 计算最少资源数：
  - 最坏情况已分配资源数 = n * (m - 1) = 3 * (4 - 1) = 3 * 3 = 9。
  - 为了保证不发生死锁，总资源数 R 至少要比这个数多1。
  - R_min = 9 + 1 = 10。
结论： 最少需要10个资源。

10. 某系统中共有 11 台磁带机, X 个进程共享此磁带机设备,每个进程最多请求使用 3 台,则系统必然不会死锁的最大 X 值是 ( B )

题目原文
10. 某系统中共有 11 台磁带机, X 个进程共享此磁带机设备,每个进程最多请求使用 3 台,则系统必然不会死锁的最大 X 值是 ( )
A. 4 B. 5 C. 6 D. 7

正确答案：B

题目解析

考点分析： 本题是死锁定理的逆向应用。
套用公式： R > n * (m - 1)
分析过程：
1. 确定参数：
  - 资源总数 R = 11。
  - 进程数 n = X (待求)。
  - 每个进程最多需要 m = 3 个资源。
2. 代入不等式：
  - 11 > X * (3 - 1)
  - 11 > X * 2
  - X < 11 / 2
  - X < 5.5
3. 确定X的最大整数值：
  - 因为X是进程数，必须是整数。
  - 小于5.5的最大整数是 5。
结论： X的最大值是5。
验算： 如果有5个进程，每个进程都先申请2台磁带机，共用掉5*2=10台，此时还剩1台，可以满足任何一个进程的需求，不会死锁。如果有6个进程，每个都申请2台，共用掉6*2=12台，资源不足，可能死锁。

11. 若系统中有 5 个某类资源供若干进程共享, 则不会引起死锁的情况是 ( A )

题目原文
11. 若系统中有 5 个某类资源供若干进程共享, 则不会引起死锁的情况是 ( )
A. 有 6 个进程,每个进程需 1 个资源
B. 有 5 个进程,每个进程需 2 个资源
C. 有 4 个进程,每个进程需 3 个资源
D. 有 3 个进程,每个进程需 4 个资源

正确答案：A

题目解析

考点分析： 本题考察通过死锁定理判断不同场景下是否可能发生死锁。
死锁定理（充分条件）： R > n * (m - 1) 则不会死锁。其中 R是资源总数，n是进程数，m是每个进程最大需求。
逐项验证：
- A. R=5, n=6, m=1
  - n * (m-1) = 6 * (1-1) = 0。
  - 5 > 0。条件满足，不会死锁。
  - （直观理解：每个进程只需要1个资源，拿到就结束，不会占有并等待，破坏了该条件）。
- B. R=5, n=5, m=2
  - n * (m-1) = 5 * (2-1) = 5。
  - 5 > 5 不成立。可能死锁。（最坏情况：5个进程各占1个，都等待第2个）。
- C. R=5, n=4, m=3
  - n * (m-1) = 4 * (3-1) = 8。
  - 5 > 8 不成立。可能死锁。（最坏情况：4个进程各占2个，需要8个资源，但总共只有5个，不可能）。
  - 【修正分析C】 最坏情况：3个进程各占2个（共用6个资源，不可能）；2个进程各占2个（用4个），剩1个，此时第3个进程申请3个，阻塞。另外两个进程也申请第3个，死锁。
- D. R=5, n=3, m=4
  - n * (m-1) = 3 * (4-1) = 9。
  - 5 > 9 不成立。可能死锁。（最坏情况：2个进程各占3个，需要6个资源，不可能）。
结论： 只有A情况明确不会引起死锁。

12. 解除死锁通常不采用的方法是 ( D )

题目原文
12. 解除死锁通常不采用的方法是 ( )
A. 终止一个死锁进程 B. 终止所有死锁进程
C. 从死锁进程处抢夺资源 D. 从非死锁进程处抢夺资源

正确答案：D

题目解析

考点分析： 本题考察死锁解除的常用策略。
正确选项分析 (D. 从非死锁进程处抢夺资源)：
- 死锁解除的目标是打破死锁环。
- 抢夺非死锁进程的资源，对打破已形成的死锁环没有任何帮助，反而可能会导致新的死锁或使该无辜进程饿死。这是一种非常不合理且无效的方法。
错误选项分析（是解除死锁的方法）：
- A. 终止一个死锁进程： 这是最常用的方法之一。终止环路中的一个进程，并释放其所有资源，从而打破循环等待。
- B. 终止所有死锁进程： 是一种更“暴力”但简单的方法，可以彻底解决当前的死锁状态。
- C. 从死锁进程处抢夺资源： 即资源剥夺。从死锁环路中的一个或多个进程处强制收回一些资源，分配给其他进程，以打破僵局。

13. 采用资源剥夺法可以解除死锁,还可以采用 ( B ) 方法解除死锁。

题目原文
13. 采用资源剥夺法可以解除死锁,还可以采用 ( ) 方法解除死锁。
A. 执行并行操作 B. 撤销进程 C. 拒绝分配新资源 D. 修改信号量

正确答案：B

题目解析

考点分析： 本题与上一题类似，考察死锁解除的两大类方法。
正确选项分析 (B. 撤销进程, Process Termination)：
- 死锁解除的主要方法可以归为两大类：
  1. 资源剥夺 (Resource Preemption): 从一个或多个死锁进程中抢占资源。
  2. 撤销进程 (Process Termination): 终止（杀死）一个或多个死锁进程。
错误选项分析：
- A, C, D: 都不是标准的死锁解除方法。

14. 在下列死锁的解决方法中, 属于死锁预防策略的是 ( B )

题目原文
14. 在下列死锁的解决方法中, 属于死锁预防策略的是 ( )
A. 银行家算法 B. 资源有序分配算法
C. 死锁检测算法 D. 资源分配图化简法

正确答案：B

题目解析

考点分析： 本题要求从多种死锁处理方法中，识别出死锁预防。
正确选项分析 (B. 资源有序分配算法)：
- 死锁预防 (Prevention): 通过施加较强的限制，从根本上破坏死锁产生的四个必要条件之一，使得死锁永远不可能发生。
- 资源有序分配算法就是通过破坏“循环等待”条件来实现死锁预防的。
错误选项分析：
- A. 银行家算法： 属于死锁避免 (Avoidance)。
- C. 死锁检测算法 和 D. 资源分配图化简法（是死锁检测的一种实现）：都属于死锁检测与解除 (Detection & Recovery)。

15. 三个进程共享四个同类资源…则该系统 ( C )

题目原文
15. 三个进程共享四个同类资源,这些资源的分配与释放只能一次一个。已知每个进程最多需要两个该类资源, 则该系统 ( )
A. 有些进程可能永远得不到该类资源 B. 必然有死锁
C. 进程请求该类资源必然能得到 D. 必然是死锁
[选项应为“不会发生死锁”]
正确答案：C

题目解析

考点分析： 本题是死锁定理的应用判断。
分析过程：
1. 确定参数：
  - 资源总数 R = 4。
  - 进程数 n = 3。
  - 每个进程最多需要 m = 2。
2. 应用死锁定理： R > n * (m - 1) ?
  - n * (m - 1) = 3 * (2 - 1) = 3。
  - 4 > 3。条件满足。
3. 得出结论：
  - 该系统必然不会发生死锁。
分析选项：
- C. 进程请求该类资源必然能得到： 这个说法是“不会发生死锁”的推论。因为系统不会死锁，所以任何一个进程的请求，在等待有限时间后，最终必然能够得到满足。
- A, B, D: 都是错误的。
【答案校对】 您提供的答案是C。与分析一致。

16. 以下有关资源分配图的描述中,正确的是 ( D )

题目原文
16. 以下有关资源分配图的描述中,正确的是 ( )
A. 有向边包括进程指向资源类的分配边和资源类指向进程申请边两类
B. 矩形框表示进程,其中圆点表示申请同一类资源的各个进程
C. 圆圈结点表示资源类
D. 资源分配图是一个有向图,用于表示某时刻系统资源与进程之间的状态

正确答案：D

题目解析

考点分析： 本题考察对资源分配图（Resource-Allocation Graph）各组成元素和作用的理解。
正确选项分析 (D. …是一个有向图,用于表示某时刻…状态)：
- 这准确地描述了资源分配图的性质和作用。它是一个有向图，用于快照系统在某一特定时刻的资源分配和请求情况。
错误选项分析：
- A: 方向说反了。
  - 请求边 (Request Edge): 从进程 -> 资源类。
  - 分配边 (Assignment Edge): 从资源类中的实例 -> 进程。
- B: 圆圈表示进程，矩形框表示资源类。
- C: 矩形框表示资源类，其中的圆点表示该类资源中的实例。

17. 死锁的四个必要条件中,无法破坏的是 ( B )

题目原文
17. 死锁的四个必要条件中,无法破坏的是 ( )
A. 环路等待资源 B. 互斥使用资源 C. 占有且等待资源 D. 非抢夺式分配

正确答案：B

题目解析

考点分析： 本题考察在死锁预防中，哪个条件是无法或不应被破坏的。
正确选项分析 (B. 互斥使用资源)：
- “互斥”条件是由资源本身的固有属性决定的。
- 像打印机、磁带机这类设备，在物理上就只允许一个进程使用，我们无法通过软件技术将其变成可共享的（SPOOLing是模拟共享，底层访问仍是互斥的）。
- 强行破坏这类资源的互斥条件，会导致输出混乱或数据损坏，这是不能接受的。
- 因此，互斥条件通常是不能被破坏的。
错误选项分析（都可以被破坏）：
- A. 环路等待 -> 资源有序分配法。
- C. 占有且等待 -> 一次性分配法。
- D. 非抢夺 -> 资源剥夺法。

18. 死锁与安全状态的关系是 ( D )

题目原文
18. 死锁与安全状态的关系是 ( )
A. 死锁状态有可能是安全状态 B. 安全状态有可能成为死锁状态
C. 不安全状态就是死锁状态 D. 死锁状态一定是不安全状态

正确答案：D

题目解析

考点分析： 本题考察安全状态、不安全状态和死锁状态三者之间的关系。
正确选项分析 (D. 死锁状态一定是不安全状态)：
- 安全状态： 指系统存在一个安全序列，可以按照这个序列分配资源，使得所有进程都能顺利完成。
- 死锁状态： 指系统中存在一组进程循环等待，无法向前推进。
- 如果系统处于死锁状态，那么必然不存在一个能让所有进程都完成的安全序列。
- 因此，死锁状态是不安全状态的一个真子集。
错误选项分析：
- A: 死锁状态一定是不安全的。
- B: 安全状态定义就是不会导致死锁。
- C: 不安全状态不一定是死锁状态。不安全状态只是可能会导致死锁，如果后续进程请求资源的顺序比较“幸运”，也可能避免死锁而顺利完成。

19. 死锁检测时检查的是 ( A )

题目原文
19. 死锁检测时检查的是 ( )
A. 资源有向图 B. 前驱图 C. 搜索树 D. 安全图

正确答案：A

题目解析

考点分析： 本题考察死锁检测算法所依赖的数据结构。
正确选项分析 (A. 资源有向图)：
- 资源分配图是描述系统当前资源分配和请求状态的有力工具。
- 死锁检测算法的核心就是分析当前的资源分配图。
- 判断定理： 如果资源分配图中没有环路，则系统一定没有发生死锁。如果图中存在环路，则可能发生了死锁（如果每类资源只有一个实例，则有环必死锁）。
- 通过图的化简等算法来检测图中是否存在无法消除的环路，是死锁检测的基本方法。
错误选项分析：
- B, C, D: 都不是用于死锁检测的标准数据结构。

20. 某个系统采用下列资源分配策略…这种分配策略会导致 ( D )

题目原文
20. 某个系统采用下列资源分配策略。若一个进程提出资源请求得不到满足,而此时没有由于等待资源而被阻塞的进程, 则自己就被阻塞。而当此时已有等待资源而被阻塞的进程, 则检查所有由于等待资源而被阻塞的进程。若它们有申请进程所需要的资源,则将这些资源取出并分配给申请进程。这种分配策略会导致 ( )
A. 死锁 B. 颠簸 C. 回退 D. 饥饿

正确答案：D

题目解析

考点分析： 本题通过描述一个特殊的资源分配策略，考察其可能导致的后果。
正确选项分析 (D. 饥饿)：
- 分析策略：
  1. 一个高优先级的进程P_high来了，请求资源R。
  2. R被一个低优先级的进程P_low占有，P_low正在等待其他资源。
  3. 系统发现P_low是阻塞的，于是剥夺了P_low的资源R，分配给了P_high。
- 后果： 这种策略下，低优先级的进程P_low好不容易申请到的资源，总是可能被后来到达的高优先级进程抢走。如果高优先级进程不断到来，那么P_low可能永远也无法集齐它所需要的所有资源，从而长时间得不到服务，这就是饥饿。
错误选项分析：
- A. 死锁：这种剥夺机制恰恰是破坏了死锁的“非剥夺”条件，所以它不容易导致死锁。
- B. 颠簸：是虚拟内存中的概念。
- C. 回退：是解除死锁的一种方法。
【答案校对】 您提供的答案是A (死锁)。
- 为什么可能导致死锁？ 让我们重新思考。
  - P1申请R1(成功)，申请R2(失败，被P2持有)，P1阻塞。
  - P2申请R2(成功)，申请R1(失败，被P1持有)，P2阻塞。
  - 现在P3来了，申请R1。系统发现P1是阻塞的，于是从P1处剥夺R1给P3。
  - 现在P4来了，申请R2。系统发现P2是阻塞的，于是从P2处剥夺R2给P4。
  - P1和P2的资源都被抢走了，但它们仍然在等待对方的资源，死锁环依然存在。
- 结论： 这种“只抢阻塞进程”的策略，并不能有效解决已形成的死锁，反而可能使情况更复杂。但它本身不是死锁的直接原因。饥饿是更直接、更明显的后果。此题答案A存在争议。

21. 系统的资源分配图在下列情况下,无法判断是否处于死锁状态的有 ( C )

I.出现了环路 II.没有环路 III.每种资源只有一个,并出现环路
IV.每个进程结点至少有一条请求边

正确答案：C

题目解析

考点分析： 本题考察资源分配图与死锁状态的充要关系。
【答案校对与分析】 您提供的答案是A (I, II, III, IV)。但这个答案是错误的。
我们来逐项分析：
- I. 出现了环路：
  - 这是可能死锁的信号。
  - 如果环路中的每类资源都只有一个实例，则必然死锁。
  - 如果环路中有资源类型具有多个实例，则不一定死锁（可能有其他未参与环路的进程会释放资源，打破僵局）。
  - 因此，仅凭“出现环路”，我们无法100%判断是否处于死锁状态（除非知道资源实例数）。
- II. 没有环路：
  - 没有环路是没有死锁的充分条件。
  - 因此，当没有环路时，我们可以明确地判断系统不处于死锁状态。
- III. 每种资源只有一个,并出现环路：
  - 这是必然死锁的充要条件。
  - 因此，当这种情况出现时，我们可以明确地判断系统处于死锁状态。
- IV. 每个进程结点至少有一条请求边：
  - 这只说明每个进程都在等待资源，但没有提供环路信息，无法判断是否死锁。
结论：
- 可以明确判断的情况是：II (非死锁) 和 III (死锁)。
- 无法明确判断的情况是：I (可能死锁) 和 IV (信息不足)。
- 因此，正确的答案应该是 I 和 IV。您提供的答案A是错误的。

22. 下列关于死锁的说法中, 正确的有 ( D )

I.死锁状态一定是不安全状态
II.产生死锁的根本原因是系统资源分配不足和进程推进顺序非法
III.资源的有序分配策略可以破坏死锁的循环等待条件
IV.采用资源剥夺法可以解除死锁,还可以采用撤销进程方法解除死锁

正确答案：D

题目解析

考点分析： 本题是对本章所有死锁知识的全面综合考察。
逐项分析：
- I. 死锁状态一定是不安全状态： 正确。
  - 安全状态的定义是存在一个安全序列。
  - 死锁状态下，所有环内进程都无法继续，自然也就不存在能让所有进程都完成的安全序列。
  - 死锁是不安全状态的一个特例（真子集）。
- II. …根本原因是资源分配不足和进程推进顺序非法： 正确。
  - 资源分配不足（竞争）： 这是死锁产生的前提。
  - 进程推进顺序非法（不当）： 这是导致“占有并等待”、“循环等待”等条件形成的关键。
  - 这两个因素共同导致了死锁。
- III. 资源的有序分配策略可以破坏死锁的循环等待条件： 正确。
  - 这是死锁预防的经典策略。通过规定资源申请的线性顺序，从根本上杜绝了形成环路的可能性。
- IV. 采用资源剥夺法…还可以采用撤销进程方法…： 正确。
  - 这正是死锁解除的两大类基本方法。
组合判断： I、II、III、IV 四个说法都是正确的。

(23) 下面是一个并发进程的程序代码,正确的是（ B ）

题目原文

Semaphore x1=x2=y=1;
int c1=c2=0;
P1() {                          P2() {while(1){                       while(1){P(x1);                          P(x2);if(++c1==1) P(y);               if(++c2==1) P(y);V(x1);                          V(x2);computer(A);                    computer(B);P(x1);                          P(x2);if(--c1==0) V(y);               if(--c2==0) V(y);V(x1);                          V(x2);}                               }
}                               }

A. 进程不会死锁,也不会“饥饿”
B. 进程不会死锁,但是会“饥饿”
C. 进程会死锁,但是不会“饥饿”
D. 进程会死锁,也会“饥饿”

正确答案：B

题目解析

考点分析： 本题是经典的读者-写者问题的一个变种实现，要求分析该算法是否存在死锁和饥饿问题。
分析算法逻辑：
- y 信号量：初值为1，看起来像一个互斥锁，用于保护某个共享资源。computer(A)和computer(B)像是临界区。
- x1, x2 信号量：初值为1，它们各自保护着对计数器 c1, c2 的访问，是c1和c2的互斥锁。
- c1, c2 计数器：c1记录了正在访问或等待访问资源A的P1类进程数，c2记录了P2类进程数。
- 进入临界区逻辑 (if(++c1==1) P(y)):
  - 当第一个P1进程到达时（c1从0变为1），它会尝试获取y锁。
  - 后续的P1进程到达时（c1>1），它们不会去获取y锁。
- 退出临界区逻辑 (if(--c1==0) V(y)):
  - 当最后一个P1进程退出时（c1从1变为0），它会释放y锁。
- 整体来看：
  - P1进程之间可以并发地执行computer(A)。
  - P2进程之间可以并发地执行computer(B)。
  - 但是，只要有一个P1在访问A，任何P2都无法获取y锁，反之亦然。这实现了P1类进程和P2类进程的互斥。
  - 这实际上是一个“两类读者”互斥的问题，或者说，P1是“读者”，P2是“写者”（反之亦然）。
分析死锁 (Deadlock)：
- 死锁通常由循环等待资源引起。
- 我们来分析资源获取顺序：
  - P1获取资源的顺序是 x1 -> (可能) y。
  - P2获取资源的顺序是 x2 -> (可能) y。
- x1和x2是不同的信号量，分别由P1和P2独占。y是共享的。
- 一个进程（如P1）在持有x1的同时请求y，而另一个进程（P2）在持有x2的同时请求y。它们争抢的是同一个资源y，没有形成循环等待链（如P1等P2的，P2又等P1的）。
- P1在执行P(y)之前，会先释放x1 (V(x1))。所以P1不会占有x1的同时等待y。P2同理。
- 因此，该算法不会发生死锁。
分析饥饿 (Starvation)：
- 饥饿是指一个进程可能无限期地等待某个资源。
- 考虑以下场景：
  1. 进程P1进入，执行++c1==1，成功获取P(y)锁。
  2. 在P1执行computer(A)期间，大量新的P1进程到来。它们都会成功执行++c1，然后继续执行computer(A)。c1的值会持续大于1。
  3. 与此同时，一个P2进程到来。它执行++c2==1，然后尝试执行P(y)，但因为y锁被P1持有，P2被阻塞。
  4. 现在，第一个P1执行完毕，它执行--c1==0。因为此时c1很大（由于后面来了很多P1），c1不等于0，所以它不会执行V(y)来释放锁。
  5. 后续的P1进程陆续完成，c1的值逐渐减小。
  6. 问题在于： 如果在c1减到0之前，又有一个新的P1进程到来，它会执行++c1，使得c1的值再次增加。
- 结论： 只要有P1进程“源源不断”地到来，c1的值就可能永远不会变回0。这样，y锁就永远不会被释放，导致被阻塞的P2进程无限期地等待，发生饥饿。
- 同理，如果P2先进入，P1也可能饿死。这是一种典型的“读者优先”模型，只要有读者在读，写者就必须等待，新来的读者还可以继续进入，导致写者饥饿。
最终判断： 进程不会死锁，但是会发生饥饿。

(24) 有两个并发进程,对于如下这段程序的运行,正确的说法是（ C ）

题目原文

int x,y,z,t,u;
P1() {                         P2() {while(1){                      while(1){x=1;                           x=0;y=0;                           t=0;if x>=1 then y=y+1;            if x<=1 then t=t+2;z=y;                           u=t;}                              }
}                              }

A. 程序能正确运行,结果唯一
B. 程序不能正确运行,可能有两种结果
C. 程序不能正确运行,结果不确定
D. 程序不能正确运行,可能会死锁

正确答案：C

题目解析

考点分析： 本题考察并发环境下，由于指令交错执行导致的对共享变量的竞态条件（Race Condition），以及由此产生的程序结果的不确定性。
分析过程：
1. 识别共享变量： 变量 x 是被进程P1和P2共同读写的共享变量。y, z 是P1的局部（或私有）变量，t, u 是P2的局部变量。
2. 分析竞态条件：
  - 两个进程都在一个无限循环中，不断地修改和读取共享变量x。
  - 由于P1和P2是并发执行的，它们的执行顺序是异步的、不可预测的。
  - 一个进程在执行if语句时，对x的读取和另一个进程对x的写入操作可能会发生交错。
3. 分析P1中 z 的可能值：
  - P1的逻辑是 x=1; y=0; if(x>=1) y=y+1; z=y;
  - 情况1 (P1未被打断): P1连续执行完自己的代码块。它先设置x=1，然后判断x>=1为真，执行y=y+1使y变为1，最后z=y，所以 z 的最终值为1。
  - 情况2 (P1被打断):
    - P1执行 x=1;。
    - 此时发生进程切换，P2开始运行。
    - P2执行 x=0;。
    - 再次切换回P1，P1继续执行 if(x>=1)。
    - 此时，x的值已经是0了。判断 0>=1 为假。
    - P1跳过y=y+1，直接执行z=y。由于y的初值是0，所以 z 的最终值为0。
  - 结论： z 的值可能是0或1，不确定。
4. 分析P2中 u 的可能值：
  - P2的逻辑是 x=0; t=0; if(x<=1) t=t+2; u=t;
  - 情况1 (P2未被打断): P2连续执行。它先设置x=0，然后判断x<=1为真，执行t=t+2使t变为2，最后u=t，所以 u 的最终值为2。
  - 情况2 (P2被打断):
    - P2执行 x=0;。
    - 此时发生进程切换，P1开始运行。
    - P1执行 x=1;。
    - 再次切换回P2，P2继续执行 if(x<=1)。
    - 此时，x的值是1。判断 1<=1 仍为真。
    - P2执行t=t+2，t变为2，u=t，u的最终值仍然是2。
  - 结论： 在这个特定的逻辑下，无论如何交错，u的值似乎总是2。但是，由于z的值是不确定的，整个程序的最终状态（由所有变量的值定义）就是不确定的。
5. 综合判断：
  - “程序不能正确运行”： 是的，因为它的结果依赖于不可预测的执行时序，这在并发编程中被认为是错误的。
  - “结果不确定”： 是的，我们已经证明了变量z的值可能是0或1，因此整个程序的结果是不确定的。
  - “可能会死锁”： 程序中没有使用任何会产生阻塞的同步原语（如锁或信号量），只是对变量进行读写，不会发生死锁。
最终结论： 选项C“程序不能正确运行,结果不确定”最准确地描述了这种情况。

25) 一个进程在获得资源后, 只能在使用完资源后由自己释放, 这属于死锁必要条件的 ( C )

题目原文
25) 一个进程在获得资源后, 只能在使用完资源后由自己释放, 这属于死锁必要条件的 ( )
A. 互斥条件
B. 请求和释放条件
C. 不剥夺条件
D. 防止系统进入不安全状态

正确答案：C

题目解析

考点分析： 本题考察对死锁四个必要条件的精确定义。
正确选项分析 (C. 不剥夺条件, No Preemption)：
- 不剥夺条件的定义是：已经分配给一个进程的资源，不能被系统或其他进程强制性地剥夺（抢占）。
- 该资源只能由持有它的进程在使用完毕后主动释放。
- 题目的描述“只能在使用完资源后由自己释放”正是对“不剥夺”条件的完美诠释。
错误选项分析：
- A. 互斥条件： 指的是资源一次只能被一个进程使用。
- B. 请求和释放条件： 这个术语不标准，应该是“请求和保持/占有并等待 (Hold and Wait)”条件，指的是一个进程在持有至少一个资源的同时，又去请求新的资源。
- D. 防止系统进入不安全状态： 这是死锁避免的一种策略，不是死锁发生的必要条件。

(26) 假设具有5个进程的进程集合 P = {P₀,P₁,P₂,P₃,P₄}, 系统中有三类资源 A,B,C…系统是处于安全状态的,则 x,y,z 的取值可能是（ C ）

题目原文
(26) 假设具有5个进程的进程集合 P = {P₀,P₁,P₂,P₃,P₄}, 系统中有三类资源 A,B,C, 假设在某时刻有如下状态, 见下表。系统是处于安全状态的, 则 x,y,z 的取值可能是（）

进程名	Allocation (已分配)	Max (最大需求)	Available (可用)
	A B C	A B C	A B C
P₀	0 0 3	0 0 4	x y z
P₁	1 0 0	1 7 5
P₂	1 3 5	2 3 5
P₃	0 0 2	0 6 4
P₄	0 0 1	0 6 5

I. 1,4,0 II. 0,6,2 III. 1,1,1 IV. 0,4,7

A. I、II、IV
B. I、II
C. 仅 I
D. I、III

正确答案：C

题目解析

考点分析： 本题考察死锁避免中的银行家算法，核心是判断一个系统状态是否为安全状态。
背景知识：
- Need (尚需) 矩阵： Need = Max - Allocation。表示每个进程要完成任务，还需要的资源数量。
- 安全状态定义： 系统存在一个安全序列 <P_i, P_j, ...>，使得对于序列中的每一个进程 P_k，它所需要的资源 Need[k] 能够被当前可用的资源 Available 加上所有在它前面已完成的进程释放的资源所满足。
- 安全性算法：
  1. 初始化 Work = Available, Finish[i] = false。
  2. 寻找一个 i，满足 Finish[i] == false 且 Need[i] <= Work。
  3. 如果找不到，则系统不安全。
  4. 如果找到了，则 Work = Work + Allocation[i], Finish[i] = true，然后返回第2步。
  5. 如果所有进程的 Finish[i] 都为 true，则系统安全。
分析过程：
1. 首先，计算Need矩阵：
  进程名 Need (Max - Allocation)
  A B C
  P₀ 0 0 1
  P₁ 0 7 5
  P₂ 1 0 0
  P₃ 0 6 2
  P₄ 0 6 4
2. 逐个检验给出的Available向量 (x, y, z) 是否能找到一个安全序列：
  - 检验 I: Available = (1, 4, 0)
    - Work = (1, 4, 0). Finish = {F, F, F, F, F}
    - 找P₀? Need(0,0,1) ≤ Work(1,4,0)。满足。
      - P₀运行结束，释放资源。
      - Work = (1,4,0) + Allocation(0,0,3) = (1,4,3). Finish = {T, F, F, F, F}
    - 找P₂? Need(1,0,0) ≤ Work(1,4,3)。满足。
      - P₂运行结束，释放资源。
      - Work = (1,4,3) + Allocation(1,3,5) = (2,7,8). Finish = {T, F, T, F, F}
    - 找P₁? Need(0,7,5) ≤ Work(2,7,8)。满足。
      - P₁运行结束。
      - Work = (2,7,8) + Allocation(1,0,0) = (3,7,8). Finish = {T, T, T, F, F}
    - 找P₃? Need(0,6,2) ≤ Work(3,7,8)。满足。
      - P₃运行结束。
      - Work = (3,7,8) + Allocation(0,0,2) = (3,7,10). Finish = {T, T, T, T, F}
    - 找P₄? Need(0,6,4) ≤ Work(3,7,10)。满足。
      - P₄运行结束。
    - 所有进程都能完成，找到了一个安全序列 <P₀, P₂, P₁, P₃, P₄>。因此，I是安全的。
  - 检验 II: Available = (0, 6, 2)
    - Work = (0, 6, 2).
    - 找P₀? Need(0,0,1) ≤ Work(0,6,2)。满足。Work = (0,6,2) + (0,0,3) = (0,6,5)。
    - 找P₂? Need(1,0,0) ≤ Work(0,6,5)。不满足 (A资源不够)。
    - 找P₃? Need(0,6,2) ≤ Work(0,6,5)。满足。Work = (0,6,5) + (0,0,2) = (0,6,7)。
    - 找P₄? Need(0,6,4) ≤ Work(0,6,7)。满足。Work = (0,6,7) + (0,0,1) = (0,6,8)。
    - 此时，Work=(0,6,8)，可以满足P₂ (Need 1,0,0, 不满足)。也可以满足P₁ (Need 0,7,5, 不满足)。
    - 我们找不到一个能让所有进程都完成的序列。因此，II是不安全的。
  - 检验 III: Available = (1, 1, 1)
    - Work = (1, 1, 1).
    - 找P₀? Need(0,0,1) ≤ Work(1,1,1)。满足。Work = (1,1,1) + (0,0,3) = (1,1,4)。
    - 找P₂? Need(1,0,0) ≤ Work(1,1,4)。满足。Work = (1,1,4) + (1,3,5) = (2,4,9)。
    - 此时Work=(2,4,9)，剩下的P₁, P₃, P₄的Need分别是(0,7,5), (0,6,2), (0,6,4)。都不满足。
    - 我们换个起始顺序。
    - Work = (1, 1, 1).
    - 找P₂? Need(1,0,0) ≤ Work(1,1,1)。满足。Work = (1,1,1) + (1,3,5) = (2,4,6)。
    - 找P₀? Need(0,0,1) ≤ Work(2,4,6)。满足。Work = (2,4,6) + (0,0,3) = (2,4,9)。
    - 此时Work=(2,4,9)，仍然无法满足P₁, P₃, P₄。
    - 【答案校对与分析】 您提供的答案是D (I, III)，这意味着III也应该是安全的。我的两次模拟都显示不安全。让我们再试一次。
    - Work = (1, 1, 1).
    - 唯一能启动的进程是P₀或P₂。
    - 启动P₀ -> Work=(1,1,4). 剩下的Need: (0,7,5), (1,0,0), (0,6,2), (0,6,4). 只有P₂的Need(1,0,0)能被满足。
      - Work=(1,1,4)+(1,3,5)=(2,4,9). 剩下的Need: (0,7,5), (0,6,2), (0,6,4). 依然无法满足。
    - 启动P₂ -> Work=(2,4,6). 剩下的Need: (0,0,1), (0,7,5), (0,6,2), (0,6,4). 只有P₀, P₃, P₄能满足。
      - 先满足P₀: Work=(2,4,6)+(0,0,3)=(2,4,9). 剩下的Need: (0,7,5), (0,6,2), (0,6,4). 无法满足。
      - 先满足P₃: Work=(2,4,6)+(0,0,2)=(2,4,8). 剩下的Need: (0,0,1), (0,7,5), (0,6,4). 可以满足P₀, P₄。
        再满足P₀: Work=(2,4,8)+(0,0,3)=(2,4,11). 剩下Need: (0,7,5), (0,6,4). 无法满足P₁。
        再满足P₄: Work=(2,4,8)+(0,0,1)=(2,4,9). 剩下Need: (0,0,1), (0,7,5). 无法满足P₁。
    - 结论： 经过 exhaustive search，III是不安全的。此题答案D是错误的。
  - 检验 IV: Available = (0, 4, 7)
    - Work = (0, 4, 7).
    - 找P₀? Need(0,0,1) ≤ Work(0,4,7)。满足。Work = (0,4,7)+(0,0,3)=(0,4,10).
    - 此时，Work=(0,4,10)，无法满足P₂(1,0,0), P₁(0,7,5), P₃(0,6,2), P₄(0,6,4)。
    - IV是不安全的。
最终结论：
- 只有 I. (1,4,0) 是安全状态。
- 因此，正确的选项应为 C. 仅I。您提供的答案D是错误的。

进程名	Need (Max - Allocation)
	A B C
P₀	0 0 1
P₁	0 7 5
P₂	1 0 0
P₃	0 6 2
P₄	0 6 4

27. 死锁定理是用于处理死锁的 ( C ) 方法。

题目原文
27. 死锁定理是用于处理死锁的 ( ) 方法。
A. 预防死锁 B. 避免死锁 C. 检测死锁 D. 解除死锁

正确答案：C

题目解析

考点分析： 本题考察“死锁定理”的应用范畴。
正确选项分析 (C. 检测死锁, Deadlock Detection)：
- 死锁定理通常指的是通过资源分配图来判断系统是否发生死锁的理论。
- 定理内容： 系统处于死锁状态的充要条件是，资源分配图是不可完全化简的。
- 资源分配图的化简过程，就是模拟一个安全序列的查找过程。如果最终所有进程节点都能被消去（成为孤立点），则图是可完全化简的，系统无死锁。反之，则存在死锁。
- 这个过程是在系统运行的某个时刻，对当前状态进行分析，以检测是否存在死锁，因此它属于死锁检测方法。
错误选项分析：
- A. 预防死锁：通过破坏死锁必要条件实现。
- B. 避免死锁：通过银行家算法等，在分配前进行安全性检查。
- D. 解除死锁：在检测到死锁后采取的措施。

28. 某系统有 m 个同类资源供 n 个进程共享…则各进程的最大需求量之和应 ( C )

(该题题干存在笔误，应为“不会发生死锁的条件”)

题目原文
28. 某系统有 m 个同类资源供 n 个进程共享, 若每个进程最多申请 k 个资源 (k≥1), 采用银行家算法分配资源, 为保证系统不发生死锁, 则各进程的最大需求量之和应 ( )
A. 等于 m B. 等于 m + n C. 小于 m + n D. 大于 m + n

正确答案：C

题目解析

考点分析： 本题考察一个推论，即在什么条件下，一个系统即使不运行银行家算法也永远是安全的。
分析过程：
- 设每个进程 P_i 的最大需求量为 Max_i。
- 最坏的情况是，所有进程都同时请求到了它们的最大需求量。
- 如果所有进程的最大需求量之和都小于系统可用资源总数与进程数之和，即 Σ Max_i < m + n，那么系统永远不会进入不安全状态，也就不会发生死锁。
- 推导：
  - 一个状态是安全的，如果 Σ Need_i < m。
  - Need_i = Max_i - Allocation_i。
  - Σ (Max_i - Allocation_i) < m
  - Σ Max_i - Σ Allocation_i < m
  - Σ Max_i < m + Σ Allocation_i。
  - 由于Σ Allocation_i最多为n-1？这个推导不直观。
- 换个角度（死锁定理）：
  - 不会死锁的条件是 m > Σ (Max_i - 1)
  - m > Σ Max_i - n
  - m + n > Σ Max_i
结论： 为保证系统不发生死锁，所有进程的最大需求量之和应小于 m+n。

29. 采用银行家算法可以避免死锁的发生,这是因为该算法 ( D )

题目原文
29. 采用银行家算法可以避免死锁的发生,这是因为该算法 ( )
A. 可以抢夺已分配的资源
B. 能及时为各进程分配资源
C. 任何时刻都能保证每个进程能得到所需的资源
D. 任何时刻都能保证至少有一个进程可以得到所需的全部资源

正确答案：D

题目解析

考点分析： 本题考察银行家算法避免死锁的核心思想。
正确选项分析 (D. 任何时刻都能保证至少有一个进程可以得到所需的全部资源)：
- 【答案校对与分析】 您提供的答案是D。
- 银行家算法的核心是安全性检查。它在分配资源前，会检查分配后的状态是否为安全状态。
- 安全状态的定义是：存在一个安全序列，系统可以按照这个序列逐个满足每个进程的资源需求，使它们都能顺利完成。
- 这意味着，在任何一个安全状态下，至少存在一个进程，其尚需（Need）的资源数量小于等于当前系统**可用（Available）**的资源数量。这个进程就可以被首先满足，然后它会执行完毕并释放其所有资源，从而增加系统的Available资源，再去满足下一个进程。
- 选项D“…至少有一个进程可以得到所需的全部资源”是对这个安全状态定义的通俗化描述。
错误选项分析：
- A: 银行家算法不涉及资源抢夺。
- B, C: 算法可能会因为安全性检查而延迟分配资源，并不能保证“及时”或“每个进程”都能得到。

30. 用银行家算法避免死锁时, 检测到 ( C ) 时才分配资源。

(该题题干存在笔误，选项描述的是分配前的检查条件)

题目原文（修正逻辑）：
30. 用银行家算法避免死锁时, 系统在收到一个资源请求后，会进行一系列检查，只有在满足（）条件时，才会尝试进行分配并做安全性检查。
A. …最大需求量超过系统现存的资源量
B. …已占有+本次申请 > 最大需求
C. …已占有+本次申请 ≤ 最大需求, 且现存资源 ≥ 本次申请
D. …现存资源 < 尚需最大资源

正确答案：C

题目解析

考点分析： 本题考察银行家算法在收到请求后的前两步合法性检查。
银行家算法流程： 当进程 P_i 发出请求 Request_i 时：
1. 检查请求是否越界： Request_i ≤ Need_i ? （Need_i = Max_i - Allocation_i）。这等价于 Allocation_i + Request_i ≤ Max_i。如果不满足，则请求出错。
2. 检查系统是否有足够资源： Request_i ≤ Available ? 如果不满足，则进程必须等待。
3. 尝试分配并检查安全性： 如果前两步都通过，系统假装将资源分配给P_i，更新Available, Allocation_i, Need_i 的值，然后运行安全性算法。
4. 最终决策： 如果安全性检查通过（新状态是安全的），则正式分配；否则，撤销假装的分配，让进程P_i等待。
正确选项分析 (C. …已占有的资源数与本次申请的资源数之和不超过对资源的最大需求量,且现存资源量能满足本次申请量)：
- 这准确地描述了上述流程的第1步和第2步，这是进行安全性检查的前提条件。
错误选项分析：
- A, B: 描述的是请求非法的两种情况。
- D: “不能满足尚需的最大资源量”不影响对“本次申请”的满足。

31. 下列各种方法中, 可用于解除已发生死锁的是 ( D )

题目原文
31. 下列各种方法中, 可用于解除已发生死-锁的是 ( )
A. 撤销部分或全部死锁进程 B. 剥夺部分或全部死锁进程的资源
C. 降低部分或全部死锁进程的优先级 D. A 和 B 都可以

正确答案：D

题目解析

考点分析： 本题与第13题类似，考察死锁解除的两大类方法。
正确选项分析 (D. A 和 B 都可以)：
- 死锁解除（Recovery） 是在死锁被检测到之后采取的强制性措施。
- 主要方法有两大类：
  1. 进程终止 (Process Termination):
    - 终止（撤销）所有死锁进程。（简单粗暴）
    - 逐个终止死-锁进程，直到死锁环被打破。（代价较小）
  2. 资源剥夺 (Resource Preemption):
    - 从一个或多个死锁进程中抢占资源，分配给其他死锁进程。
    - 需要考虑如何选择“牺牲品”以及如何处理被剥夺进程（通常需要回滚到安全状态）。
- 选项A和B正好对应这两大类方法。
错误选项分析：
- C: 降低优先级对已经发生的死锁没有解除作用。

32. 假定某计算机系统有 R1和 R2两类可使用资源…则在系统运行过程中,( B )

题目原文
32. 假定某计算机系统有 R1和 R2两类可使用资源 (其中 R1有两个单位, R2有一个单位), 它们被进程 P1和 P2所共享, 且已知两个进程均按下列顺序使用两类资源: 申请 R1→ 申请 R2→ 申请 R1→ 释放 R1→ 释放 R2→ 释放 R1, 则在系统运行过程中,( )
A. 不可能产生死锁 B. 有可能产生死锁, 因为 R1资源不足
C. 有可能产生死锁, 因为 R2资源不足 D. 只有一种进程执行序列可能导致死锁

正确答案：B

题目解析

考点分析： 本题是通过模拟并发进程的资源申请序列，来判断是否可能发生死锁。
分析过程（寻找导致死锁的交错序列）：
1. 资源状态： R1=2, R2=1
2. 进程行为：
  - P1: req R1 -> req R2 -> req R1 -> …
  - P2: req R1 -> req R2 -> req R1 -> …
3. 模拟死锁场景：
  - t1: P1执行 申请R1 -> P1获得1个R1。 (系统剩余 R1=1, R2=1)
  - t2: P2执行 申请R1 -> P2获得1个R1。 (系统剩余 R1=0, R2=1)
  - t3: P1执行 申请R2 -> P1获得1个R2。 (系统剩余 R1=0, R2=0)
  - t4: P2执行 申请R2 -> R2资源不足，P2阻塞，等待P1释放R2。
  - t5: P1执行 申请R1 -> R1资源不足，P1阻塞，等待P2释放R1。
4. 判断死锁：
  - 此时，P1占有{R1, R2}，等待R1。P2占有{R1}，等待R2。
  - 【修正】 P1在t3占有{1个R1}，在t3请求R2。P2在t2占有{1个R1}。
  - 重新模拟：
    - t1: P1 申请R1 -> P1 get R1_a. (Available: R1=1, R2=1)
    - t2: 发生切换，P2 申请R1 -> P2 get R1_b. (Available: R1=0, R2=1)
    - t3: 发生切换，P1 申请R2 -> P1 get R2. (Available: R1=0, R2=0)
    - t4: 发生切换，P2 申请R2 -> R2不足，P2阻塞等待R2。
    - t5: P1继续，申请R1 -> R1不足（P2还占着一个），P1阻塞等待R1。
5. 判断死锁：
  - P1持有R2，等待R1。
  - P2持有R1，等待R2。
  - 形成了循环等待，发生死锁。
6. 分析原因：
  - 死锁的根源在于R1和R2资源都不足以同时满足两个进程的第一轮申请。但题目选项只让选一个。
  - 如果R1有3个，t1,t2后还剩1个R1，t5时P1就能拿到第2个R1。
  - 如果R2有2个，t3,t4后P1和P2都能拿到R2。
  - 从模拟过程看，是R1和R2都不足。但B和C只能选一个。
结论： 这道题的选项设计不佳。B和C都是死锁的可能原因。

33. 某计算机系统中有 8 台打印机…该系统可能会发生死锁的 K 的最小值是 ( C )

题目原文
33. 某计算机系统中有 8 台打印机, 由 K 个进程竞争使用, 每个进程最多需要 3 台打印机。该系统可能会发生死锁的 K 的最小值是 ( )
A. 2 B. 3 C. 4 D. 5

正确答案：C

题目解析

考点分析： 本题是死锁定理的逆向应用，求可能发生死锁的最小进程数。
分析过程：
1. 确定参数：
  - 资源总数 R = 8。
  - 进程数 n = K (待求)。
  - 每个进程最多需要 m = 3。
2. 分析死锁发生的临界条件：
  - 死锁发生的最坏情况是，每个进程都获得了**m-1个资源**，并且都在等待最后一个资源。
  - 此时，它们占用的总资源数为 K * (m - 1)。
  - 如果这个占用的总资源数小于系统总资源数 R，那么至少还有一个空闲资源，就不会死锁。
  - 如果这个占用的总资源数大于等于系统总资源数 R，那么就可能发生死锁（因为所有资源可能都被占满了，无法满足任何一个进程的最后一个请求）。
3. 建立不等式：
  - K * (m - 1) ≥ R
  - K * (3 - 1) ≥ 8
  - K * 2 ≥ 8
  - K ≥ 4
结论： K的最小值是4。
验算：
- 当K=4时，最坏情况是4个进程都申请到2台打印机，共用掉4*2=8台。此时所有资源耗尽，4个进程都等待第3台，发生死锁。
- 当K=3时，最坏情况是3个进程都申请到2台，共用掉3*2=6台。还剩2台，可以满足其中两个进程的需求，不会死锁。

(34) 【2011统考真题】某时刻进程的资源使用情况见下表,此时的安全序列是（ D ）

题目原文
(34) 【2011统考真题】某时刻进程的资源使用情况见下表,此时的安全序列是（）

进程名	已分配资源	尚需分配	可用资源
	R₁ R₂ R₃	R₁ R₂ R₃	R₁ R₂ R₃
P₁	2 0 0	0 0 1
P₂	1 2 0	1 3 2	0 2 1
P₃	0 1 1	1 3 1
P₄	0 0 1	2 0 0

A. P₁,P₂,P₃,P₄
B. P₁,P₃,P₂,P₄
C. P₁,P₄,P₃,P₂
D. 不存在

正确答案：D

题目解析

考点分析： 本题是银行家算法中安全性算法的直接应用，要求判断当前系统状态是否安全，如果安全则找出一个安全序列。
安全性算法步骤：
1. 初始化工作向量 Work = Available，Finish 数组全为 false。
2. 从头开始查找一个未完成的进程 P_i，满足 Need[i] <= Work。
3. 如果找不到这样的进程，则系统不安全，算法结束。
4. 如果找到了，则假装执行该进程，释放其资源：Work = Work + Allocation[i], Finish[i] = true。
5. 返回第2步，继续寻找下一个可满足的进程。
6. 如果所有进程的 Finish 标志都变为 true，则系统安全，查找过程中的进程顺序就是一个安全序列。
模拟过程：
1. 初始状态：
  - Available = (0, 2, 1)
  - Work = (0, 2, 1)
  - Finish = {F, F, F, F}
2. 第一轮查找：
  - 检查 P₁: Need₁ = (0, 0, 1).
    (0, 0, 1) <= (0, 2, 1)? 是 (0≤0, 0≤2, 1≤1)。
    - 找到一个可执行的进程 P₁。
    - 假装执行 P₁:
    - Work = Work + Allocation₁ = (0, 2, 1) + (2, 0, 0) = (2, 2, 1)
    - Finish = {T, F, F, F}
    - 安全序列目前是 <P₁,...>
3. 第二轮查找：
  - Work = (2, 2, 1)。
  - 检查 P₂: Need₂ = (1, 3, 2).
    (1, 3, 2) <= (2, 2, 1)? 否 (因为 3 > 2)。
  - 检查 P₃: Need₃ = (1, 3, 1).
    (1, 3, 1) <= (2, 2, 1)? 否 (因为 3 > 2)。
  - 检查 P₄: Need₄ = (2, 0, 0).
    (2, 0, 0) <= (2, 2, 1)? 是 (2≤2, 0≤2, 0≤1)。
    - 找到一个可执行的进程 P₄。
    - 假装执行 P₄:
    - Work = Work + Allocation₄ = (2, 2, 1) + (0, 0, 1) = (2, 2, 2)
    - Finish = {T, F, F, T}
    - 安全序列目前是 <P₁, P₄,...>
4. 第三轮查找：
  - Work = (2, 2, 2)。
  - 检查 P₂: Need₂ = (1, 3, 2).
    (1, 3, 2) <= (2, 2, 2)? 否 (因为 3 > 2)。
  - 检查 P₃: Need₃ = (1, 3, 1).
    (1, 3, 1) <= (2, 2, 2)? 否 (因为 3 > 2)。
5. 最终判断：
  - 在第三轮查找中，我们已经无法找到任何一个未完成的进程（P₂和P₃）能够被当前的 Work 向量所满足。
  - 根据安全性算法，这意味着系统无法保证所有进程都能顺利完成。
  - 因此，当前系统状态是不安全的，不存在安全序列。
结论： 不存在安全序列。

(35) 【2012统考真题】假设5个进程 P₀,P₁,P₂,P₃,P₄ 共享三类资源 R₁,R₂,R₃, 这些资源总数分别为 18,6,22。T₀时刻的资源分配情况如下表所示,此时存在的一个安全序列是（ D ）

题目原文
(35) 【2012统考真题】假设5个进程 P₀,P₁,P₂,P₃,P₄ 共享三类资源 R₁,R₂,R₃, 这些资源总数分别为 18,6,22。T₀时刻的资源分配情况如下表所示,此时存在的一个安全序列是（）

进程名	已分配资源	资源最大需求
	R₁ R₂ R₃	R₁ R₂ R₃
P₀	3 2 3	5 5 10
P₁	4 0 3	5 3 6
P₂	4 0 5	4 0 11
P₃	2 0 4	4 2 5
P₄	3 1 4	4 2 4

A. P₀,P₂,P₄,P₁,P₃
B. P₁,P₀,P₃,P₄,P₂
C. P₂,P₁,P₀,P₃,P₄
D. P₃,P₄,P₂,P₁,P₀

正确答案：D

题目解析

考点分析： 本题是银行家算法中安全性算法的直接应用，要求在给定状态下找出一个安全序列。
安全性算法步骤回顾：
1. 计算 Need (尚需) 矩阵和 Available (可用) 向量。
2. 初始化 Work = Available, Finish 数组全为 false。
3. 循环查找满足 Need[i] <= Work 的未完成进程 P_i。
4. 若找到，则 Work = Work + Allocation[i], Finish[i] = true，将 P_i 加入安全序列。
5. 重复直到所有进程都完成。
分析过程：
1. 第一步：计算 Available 向量。
  - Available = 总资源 - Σ(已分配资源)
  - 计算已分配资源总和 (Allocation_Sum):
    - R₁: 3 + 4 + 4 + 2 + 3 = 16
    - R₂: 2 + 0 + 0 + 0 + 1 = 3
    - R₃: 3 + 3 + 5 + 4 + 4 = 19
    - Allocation_Sum = (16, 3, 19)
  - 计算 Available:
    - Available = (18, 6, 22) - (16, 3, 19) = (2, 3, 3)
  - 所以，当前可用资源 Available = (2, 3, 3)。
2. 第二步：计算 Need 矩阵。
  - Need = Max - Allocation
    | 进程名 | Need (尚需) |
    | :—: | :—: |
    | | R₁ R₂ R₃ |
    | P₀ | 2 3 7 |
    | P₁ | 1 3 3 |
    | P₂ | 0 0 6 |
    | P₃ | 2 2 1 |
    | P₄ | 1 1 0 |
3. 第三步：运行安全性算法，查找安全序列。
  - 初始状态： Work = (2, 3, 3), Finish = {F,F,F,F,F}, Sequence = <>
  - 第1轮查找：
    - P₀: Need(2,3,7) > Work(2,3,3) (R₃不够)
    - P₁: Need(1,3,3) ≤ Work(2,3,3)。不满足 (R₁=1, R₂=3, R₃=3，这里应该满足的)。 【修正】Need(1,3,3) vs Work(2,3,3) -> 1<=2, 3<=3, 3<=3 -> 满足
    - P₂: Need(0,0,6) > Work(2,3,3) (R₃不够)
    - P₃: Need(2,2,1) ≤ Work(2,3,3)。满足。
    - P₄: Need(1,1,0) ≤ Work(2,3,3)。满足。
    - 我们找到了多个可以开始的进程（P₁, P₃, P₄）。安全序列不唯一，我们只需找到一个即可。
    - 让我们按照选项D的开头来尝试： 假设我们选择 P₃。
  - 执行 P₃：
    - Work = Work + Allocation₃ = (2,3,3) + (2,0,4) = (4,3,7)
    - Finish = {F,F,F,T,F}, Sequence = <P₃>
  - 第2轮查找 (Work=(4,3,7))：
    - P₀: Need(2,3,7) ≤ Work(4,3,7)。满足。
    - P₁: Need(1,3,3) ≤ Work(4,3,7)。满足。
    - P₂: Need(0,0,6) ≤ Work(4,3,7)。满足。
    - P₄: Need(1,1,0) ≤ Work(4,3,7)。满足。
    - 继续按选项D的顺序，选择 P₄。
  - 执行 P₄：
    - Work = Work + Allocation₄ = (4,3,7) + (3,1,4) = (7,4,11)
    - Finish = {F,F,F,T,T}, Sequence = <P₃, P₄>
  - 第3轮查找 (Work=(7,4,11))：
    - P₀: Need(2,3,7) ≤ Work(7,4,11)。满足。
    - P₁: Need(1,3,3) ≤ Work(7,4,11)。满足。
    - P₂: Need(0,0,6) ≤ Work(7,4,11)。满足。
    - 继续按选项D的顺序，选择 P₂。
  - 执行 P₂：
    - Work = Work + Allocation₂ = (7,4,11) + (4,0,5) = (11,4,16)
    - Finish = {F,F,T,T,T}, Sequence = <P₃, P₄, P₂>
  - 第4轮查找 (Work=(11,4,16))：
    - P₀: Need(2,3,7) ≤ Work(11,4,16)。满足。
    - P₁: Need(1,3,3) ≤ Work(11,4,16)。满足。
    - 继续按选项D的顺序，选择 P₁。
  - 执行 P₁：
    - Work = Work + Allocation₁ = (11,4,16) + (4,0,3) = (15,4,19)
    - Finish = {F,T,T,T,T}, Sequence = <P₃, P₄, P₂, P₁>
  - 第5轮查找 (Work=(15,4,19))：
    - 只剩下 P₀ 未完成。
    - P₀: Need(2,3,7) ≤ Work(15,4,19)。满足。
  - 执行 P₀：
    - Work = Work + Allocation₀ = (15,4,19) + (3,2,3) = (18,6,22) (等于总资源，正确！)
    - Finish = {T,T,T,T,T}, Sequence = <P₃, P₄, P₂, P₁, P₀>
结论：
- 我们成功找到了一个安全序列 <P₃, P₄, P₂, P₁, P₀>。
- 这个序列与选项D完全匹配。因此，系统是安全的，并且D是一个存在的安全序列。

36. 【2013统考真题】下列关于银行家算法的叙述中, 正确的是 ( B )

题目原文
36. 【2013统考真题】下列关于银行家算法的叙述中, 正确的是 ( )
A. 银行家算法可以预防死锁
B. 当系统处于安全状态时, 系统中一定无死锁进程
C. 当系统处于不安全状态时,系统中一定会出现死锁进程
D. 银行家算法破坏了死锁必要条件中的“请求和保持”条件

正确答案：B

题目解析

考点分析： 本题考察对死锁避免（银行家算法） 以及安全/不安全/死锁状态三者关系的精确理解。
正确选项分析 (B. 当系统处于安全状态时, 系统中一定无死锁进程)：
- 安全状态的定义是：存在一个安全序列，系统可以按照这个序列为每个进程分配其所需的最大资源，使所有进程都能顺利完成。
- 这个定义本身就排除了死锁的可能性。如果存在死锁，那么死锁环中的进程都无法完成，也就不可能存在一个让所有进程都完成的安全序列。
- 因此，安全状态是无死锁的充分条件。
错误选项分析：
- A: 银行家算法属于死锁避免，而不是死锁预防。
- C: 不安全状态 ≠ 死锁状态。不安全状态只是可能会导致死锁，如果后续进程请求资源的顺序比较“幸运”，也可能避免死锁。
- D: 银行家算法没有破坏任何一个死锁必要条件。它允许互斥、占有并等待、非剥夺、循环等待这些条件存在，但通过安全性检查来规避进入会导致死锁的危险区域。

37. 【2014统考真题】某系统有 n 台互斥使用的同类设备, 三个并发进程分别需要 3,4,5 台设备, 可确保系统不发生死锁的设备数 n 最小为 ( B )

题目原文
37. 【2014统考真题】某系统有 n 台互斥使用的同类设备, 三个并发进程分别需要 3,4,5 台设备, 可确保系统不发生死锁的设备数 n 最小为 ( )
A. 9 B. 10 C. 11 D. 12

正确答案：B

题目解析

考点分析： 本题是死锁定理的应用题，但各个进程的最大需求量不同。
分析过程：
1. 确定参数：
  - 进程P1: Max = 3
  - 进程P2: Max = 4
  - 进程P3: Max = 5
2. 分析死锁发生的最坏情况：
  - 死锁发生在每个进程都占有了一部分资源，且它们尚需的资源之和大于系统当前可用的资源。
  - 最坏的情况是，每个进程都只差最后一个资源就能完成任务。
  - 此时，它们各自占有的资源数为：
    - P1占有 3 - 1 = 2 台。
    - P2占有 4 - 1 = 3 台。
    - P3占有 5 - 1 = 4 台。
3. 计算避免死锁的最小资源数：
  - 在上述最坏情况下，已分配的资源总数为 2 + 3 + 4 = 9 台。
  - 为了保证系统不发生死锁，系统总资源数 n 必须多到，即使在这种最坏情况下，也至少还剩一个资源可以分配给其中一个进程，让它完成并释放资源。
  - 因此，最小资源数 n = 9 + 1 = 10 台。
结论： 设备数n最小为10。

38. 【2015统考真题】若系统 S1采用死锁避免方法, S2采用死锁检测方法。下列叙述中, 正确的 ( B )

I. S1会限制用户申请资源的顺序, 而 S2不会
II. S1需要进程运行所需的资源总量信息, 而 S2不需要
III. S1不会给可能导致死锁的进程分配资源, 而 S2会

正确答案：B

题目解析

考点分析： 本题深入对比死锁避免和死锁检测这两种策略的异同。
逐项分析：
- I. S1(避免)会限制…顺序, 而 S2(检测)不会： 错误。
  - 限制资源申请顺序是死锁预防中破坏“循环等待”条件的方法。
  - 死锁避免（银行家算法）和死锁检测都不限制进程申请资源的顺序。
- II. S1(避免)需要…资源总量信息, 而 S2(检测)不需要： 正确。
  - 死锁避免（银行家算法） 必须在事前知道每个进程对各类资源的最大需求量 (Max)，才能进行安全性预测。
  - 死锁检测是在事后分析系统状态，它只需要知道当前每个进程**已分配（Allocation）的资源和正在请求（Request）**的资源即可，不需要知道未来的最大需求。
- III. S1(避免)不会给可能导致死锁的进程分配资源, 而 S2(检测)会： 正确。
  - 死锁避免的核心就是在分配前检查，如果发现分配会导致系统进入不安全状态（可能导致死锁），就拒绝这次分配。
  - 死锁检测则采取“先分配，后检测”的策略，它允许可能导致死锁的资源分配发生，然后通过定期运行检测算法来发现是否真的发生了死锁。
组合判断： II 和 III 是正确的。

39. 【2016统考真题】…若系统出现死锁, 则处于死锁状态的进程数至少是 ( C )

题目原文
39. 【2016统考真题】系统中有 3 个不同的临界资源 R1,R2和 R3, 被 4 个进程 P1,P2,P3,P4共享。各进程对资源的需求为:P1申请 R1和 R2,P2申请 R2和 R3,P3申请 R1和 R3,P4申请 R2。若系统出现死锁, 则处于死锁状态的进程数至少是 ( )
A. 1 B. 2 C. 3 D. 4

正确答案：C

题目解析

考点分析： 本题考察通过资源请求关系，分析形成死锁环路所需的最少进程数。
分析过程（构建资源分配图的依赖关系）：
- P1 需要 {R1, R2}
- P2 需要 {R2, R3}
- P3 需要 {R1, R3}
- P4 只需要 {R2}
寻找最小的死锁环路：
- 死锁的必要条件是循环等待。我们需要找到一个由进程和资源构成的环。
- 尝试构建环路：
  1. 假设 P1 占有 R1，请求 R2。 P1 -> R2
  2. 要形成环，需要有进程占有 R2，并请求 P1 占有的资源 (R1)。
  3. 假设 P2 占有 R2，请求 R3。 P2 -> R3
  4. 此时 P1 等待 P2 (为了R2)。
  5. 要形成环，需要有进程占有 R3，并请求 P1 占有的 R1。
  6. 进程 P3 正好满足这个条件：它需要 R3 和 R1。
- 形成死锁环：
  - P1 占有 R1, 请求 R2。
  - P2 占有 R2, 请求 R3。
  - P3 占有 R3, 请求 R1。
- 这就形成了一个 P1 -> R2 <- P2 -> R3 <- P3 -> R1 <- P1 的循环等待链。
- 这个环路涉及到了 P1, P2, P3 三个进程。
结论： 形成死锁最少需要3个进程。进程P4只请求R2，不会参与这个最小的循环等待。

40. 【2018统考真题】…则执行安全性检测算法的结果是 ( A )

题目原文
40. 【2018统考真题】假设系统中有 4 个同类资源, 进程 P1,P2和 P3需要的资源数分别为 4,3 和 1, P1,P2和 P3已申请到的资源数分别为 2,1 和 0, 则执行安全性检测算法的结果是 ( )
A. 不存在安全序列,系统处于不安全状态
B. 存在多个安全序列,系统处于安全状态
C. 存在唯一安全序列 P3,P1,P2, 系统处于安全状态
D. 存在唯一安全序列 P3,P2,P1, 系统处于安全状态

正确答案：A

题目解析

考点分析： 本题是银行家算法的安全性检查模拟。
分析过程：
1. 整理数据：
  - 总资源 R = 4。
    | 进程 | Max | Allocation | Need |
    |—|—|—|—|
    | P1 | 4 | 2 | 2 |
    | P2 | 3 | 1 | 2 |
    | P3 | 1 | 0 | 1 |
2. 计算当前可用资源 Available：
  - Available = R - Σ(Allocation) = 4 - (2+1+0) = 1。
3. 运行安全性算法：
  - 初始状态： Work = 1, Finish = {F, F, F}。
  - 第一轮查找：
    - P1: Need₁ = 2。2 > Work(1)。不满足。
    - P2: Need₂ = 2。2 > Work(1)。不满足。
    - P3: Need₃ = 1。1 <= Work(1)。满足！
  - 执行 P3：
    - Work = Work + Allocation₃ = 1 + 0 = 1。
    - Finish = {F, F, T}。
  - 第二轮查找：
    - Work = 1。
    - P1: Need₁ = 2。2 > Work(1)。不满足。
    - P2: Need₂ = 2。2 > Work(1)。不满足。
4. 最终判断：
  - 在第二轮查找中，我们已经无法找到任何一个未完成的进程（P1和P2）能够被当前的 Work 向量所满足。
  - 因此，系统不存在安全序列。
结论： 系统处于不安全状态。

41. 【2019统考真题】下列关于死锁的叙述中,正确的是 ( B )

I.可以通过剥夺进程资源解除死锁
II.死锁的预防方法能确保系统不发生死锁
III.银行家算法可以判断系统是否处于死锁状态
IV.当系统出现死锁时,必然有两个或两个以上的进程处于阻塞态

正确答案：B

题目解析

考点分析： 本题是对本章所有死锁知识的全面综合考察。
逐项分析：
- I. 可以通过剥夺进程资源解除死锁： 正确。这是死锁解除的两大方法之一。
- II. 死锁的预防方法能确保系统不发生死锁： 正确。死锁预防的定义就是通过破坏四个必要条件之一，从根本上杜绝死锁的发生可能性。
- III. 银行家算法可以判断系统是否处于死锁状态： 错误。银行家算法是死锁避免算法，它通过判断一个状态是否安全来避免未来可能发生的死锁。它不能用来检测当前是否已经处于死锁状态。死锁检测需要专门的检测算法（如图化简法）。
- IV. 当系统出现死锁时,必然有两个或两个以上的进程处于阻塞态： 正确。死锁的定义就是一组进程因循环等待资源而全体处于阻塞（等待）态，无法向前推进。这个“一组”至少包含两个进程。
组合判断： I、II、IV 是正确的。

(42) 【2020统考真题】某系统中有A、B两类资源各6个…t时刻安全性检测结果是（ B ）

题目原文
(42) 【2020统考真题】某系统中有A、B两类资源各6个,t时刻的资源分配及需求情况如下表所示。t时刻安全性检测结果是（）

进程名	A已分配数量	B已分配数量	A需求总量	B需求总量
P₁	2	3	4	4
P₂	2	1	3	1
P₃	1	2	3	4

A. 存在安全序列 P₁,P₂,P₃
B. 存在安全序列 P₂,P₁,P₃
C. 存在安全序列 P₂,P₃,P₁
D. 不存在安全序列

正确答案：B

题目解析

考点分析： 本题是银行家算法中安全性算法的直接应用，要求在给定状态下判断系统是否安全，并找出一个安全序列。
安全性算法步骤回顾：
1. 计算 Need (尚需) 矩阵和 Available (可用) 向量。
2. 初始化 Work = Available, Finish 数组全为 false。
3. 循环查找满足 Need[i] <= Work 的未完成进程 P_i。
4. 若找到，则 Work = Work + Allocation[i], Finish[i] = true，将 P_i 加入安全序列。
5. 重复直到所有进程都完成。若无法完成所有进程，则系统不安全。
分析过程：
1. 第一步：计算 Available 向量。
  - 总资源 Total = (6, 6)
  - 计算已分配资源总和 (Allocation_Sum):
    - A: 2 + 2 + 1 = 5
    - B: 3 + 1 + 2 = 6
    - Allocation_Sum = (5, 6)
  - 计算 Available:
    - Available = Total - Allocation_Sum = (6, 6) - (5, 6) = (1, 0)
  - 所以，当前可用资源 Available = (1, 0)。
2. 第二步：计算 Need 矩阵。
  - Need = Max - Allocation
    | 进程名 | Need (尚需) |
    | :—: | :—: |
    | | A B |
    | P₁ | 4-2=2 4-3=1 |
    | P₂ | 3-2=1 1-1=0 |
    | P₃ | 3-1=2 4-2=2 |
3. 第三步：运行安全性算法，查找安全序列。
  - 初始状态： Work = (1, 0), Finish = {F, F, F}, Sequence = <>
  - 第1轮查找：
    - 检查 P₁: Need₁ = (2, 1). (2, 1) <= (1, 0)? 否 (A和B都不够)。
    - 检查 P₂: Need₂ = (1, 0). (1, 0) <= (1, 0)? 是 (1≤1, 0≤0)。
    - 检查 P₃: Need₃ = (2, 2). (2, 2) <= (1, 0)? 否 (A和B都不够)。
    - 在这一轮，唯一可以被满足的进程是 P₂。
  - 执行 P₂：
    - Work = Work + Allocation₂ = (1, 0) + (2, 1) = (3, 1)
    - Finish = {F, T, F}, Sequence = <P₂>
  - 第2轮查找 (Work=(3,1))：
    - 检查 P₁: Need₁ = (2, 1). (2, 1) <= (3, 1)? 是 (2≤3, 1≤1)。
    - 检查 P₃: Need₃ = (2, 2). (2, 2) <= (3, 1)? 否 (B不够)。
    - 在这一轮，唯一可以被满足的进程是 P₁。
  - 执行 P₁：
    - Work = Work + Allocation₁ = (3, 1) + (2, 3) = (5, 4)
    - Finish = {T, T, F}, Sequence = <P₂, P₁>
  - 第3轮查找 (Work=(5,4))：
    - 只剩下 P₃ 未完成。
    - 检查 P₃: Need₃ = (2, 2). (2, 2) <= (5, 4)? 是 (2≤5, 2≤4)。
  - 执行 P₃：
    - Work = Work + Allocation₃ = (5, 4) + (1, 2) = (6, 6) (等于总资源，正确！)
    - Finish = {T, T, T}, Sequence = <P₂, P₁, P₃>
结论：
- 所有进程都完成了，所以系统是安全的。
- 找到了一个安全序列 <P₂, P₁, P₃>。
- 这个序列与选项B完全匹配。

(43) 【2021统考真题】若系统中有n, n≥2个进程, 每个进程均需要使用某类临界资源2个, 则系统不会发生死锁所需的该类资源总数至少是（ C ）

题目原文
(43) 【2021统考真题】若系统中有n, n≥2个进程, 每个进程均需要使用某类临界资源2个, 则系统不会发生死锁所需的该类资源总数至少是（）
A. 2
B. n
C. n + 1
D. 2n

正确答案：C

题目解析

考点分析： 本题是经典的利用死锁定理进行计算的题目，要求在给定进程数和各进程最大需求量的情况下，计算保证系统不发生死锁所需的最少资源数。
死锁定理（充分条件）：
- 设有 P 个进程，每个进程最多需要 M 个同类资源。
- 系统中该类资源的总数为 R。
- 必然不会发生死锁的充分条件是：R > P * (M - 1)。
- 换言之，为保证系统不发生死锁，最少资源数就是 P * (M - 1) + 1。
分析过程：
1. 确定参数：
  - 进程数 P = n。
  - 每个进程最多需要的资源数 M = 2。
2. 分析死锁发生的最坏情况：
  - 死锁发生的最坏情况是，每个进程都只差最后一个资源就能完成任务，并且都在等待这个资源。
  - 即，n个进程每个都先成功申请到了 M-1 = 2-1 = 1 个资源。
  - 此时，它们都占有1个资源，同时都在请求第2个资源，形成了资源请求僵局。
3. 计算避免死锁的最小资源数：
  - 在上述最坏情况下，已分配的资源总数为 n * (2 - 1) = n 个。
  - 为了保证系统不发生死锁，系统总资源数 R 必须多到，即使在这种最坏情况下，也至少还剩一个空闲资源可以分配给其中任意一个进程，让它完成、释放资源，从而打破僵局。
  - 因此，最少资源数 R_min = (n * (2 - 1)) + 1 = n + 1。
结论：
- 所需的该类资源总数至少是 n + 1。
- 例如，如果有3个进程，每个都需要2个资源。最坏情况是3个进程各占1个，共用掉3个资源。此时如果再有1个资源（总共4个），就可以满足其中一个进程，不会死锁。n+1 = 3+1 = 4，符合。

(44) 【2022统考真题】系统中有三个进程 P₀,P₁,P₂ 及三类资源 A、B、C。若某时刻系统分配资源的情况如下表所示,则此时系统中存在的安全序列的个数为（ B ）

题目原文
(44) 【2022统考真题】系统中有三个进程 P₀,P₁,P₂ 及三类资源 A、B、C。若某时刻系统分配资源的情况如下表所示,则此时系统中存在的安全序列的个数为（）

进程名	已分配资源数	尚需资源数	可用资源数
	A B C	A B C	A B C
P₀	2 0 1	0 2 1
P₁	0 2 0	1 2 3	1 3 2
P₂	1 0 1	0 1 3

A. 1 B. 2 C. 3 D. 4

正确答案：B

题目解析

考点分析： 本题是银行家算法中安全性算法的应用，不仅要求判断系统是否安全，还要求找出所有可能的安全序列的数量。
安全性算法步骤回顾：
1. 初始化工作向量 Work = Available，Finish 数组全为 false。
2. 循环查找所有满足 Need[i] <= Work 的未完成进程 P_i。
3. 对每个找到的进程，递归地进行下一步的查找。
4. 统计最终能够完成所有进程的路径数量。
分析过程：
1. 初始状态：
  - Available = (1, 3, 2)
  - Need 矩阵已给出：
    - Need₀ = (0, 2, 1)
    - Need₁ = (1, 2, 3)
    - Need₂ = (0, 1, 3)
  - Allocation 矩阵：
    - Allocation₀ = (2, 0, 1)
    - Allocation₁ = (0, 2, 0)
    - Allocation₂ = (1, 0, 1)
2. 第一步查找 (Work = (1, 3, 2))：
  - 检查 P₀: Need₀ = (0, 2, 1). (0, 2, 1) <= (1, 3, 2)? 是。
  - 检查 P₁: Need₁ = (1, 2, 3). (1, 2, 3) <= (1, 3, 2)? 否 (因为 C 资源 3 > 2)。
  - 检查 P₂: Need₂ = (0, 1, 3). (0, 1, 3) <= (1, 3, 2)? 否 (因为 C 资源 3 > 2)。
  - 在第一步，唯一可以被满足的进程是 P₀。
  - 因此，所有安全序列的第一个进程必然是 P₀。
3. 执行 P₀，进入下一步：
  - Work = Work + Allocation₀ = (1, 3, 2) + (2, 0, 1) = (3, 3, 3)
  - Finish = {T, F, F}, Sequence = <P₀, ...>
  - 现在需要从 P₁ 和 P₂ 中选择下一个。
4. 第二步查找 (Work = (3, 3, 3))：
  - 检查 P₁: Need₁ = (1, 2, 3). (1, 2, 3) <= (3, 3, 3)? 是。
  - 检查 P₂: Need₂ = (0, 1, 3). (0, 1, 3) <= (3, 3, 3)? 是。
  - 在这一步，P₁ 和 P₂ 都可以被满足。这意味着安全序列出现了分支。
5. 探索两个分支：
  - 分支 1：选择 P₁ 作为第二个进程
    - 执行 P₁: Work = (3, 3, 3) + Allocation₁ = (3, 3, 3) + (0, 2, 0) = (3, 5, 3)
    - Sequence = <P₀, P₁, ...>
    - 只剩下 P₂ 未完成。
    - 检查 P₂: Need₂ = (0, 1, 3) <= (3, 5, 3)? 是。
    - 可以完成 P₂。
    - 得到一个安全序列: <P₀, P₁, P₂>
  - 分支 2：选择 P₂ 作为第二个进程
    - 执行 P₂: Work = (3, 3, 3) + Allocation₂ = (3, 3, 3) + (1, 0, 1) = (4, 3, 4)
    - Sequence = <P₀, P₂, ...>
    - 只剩下 P₁ 未完成。
    - 检查 P₁: Need₁ = (1, 2, 3) <= (4, 3, 4)? 是。
    - 可以完成 P₁。
    - 得到另一个安全序列: <P₀, P₂, P₁>
结论：
- 系统是安全的。
- 共找到了 2 个不同的安全序列：<P₀, P₁, P₂> 和 <P₀, P₂, P₁>。
- 因此，存在的安全序列的个数为2。

2.4 死锁 (Deadlock) 知识体系与考法总结

死锁是操作系统并发控制部分最重要、也最经典的理论问题之一。它描述了多个进程因互相等待对方持有的资源而陷入无限期停滞的僵局。本节内容逻辑性极强，重点在于理解死锁的成因、处理策略，并能够熟练运用银行家算法进行安全性检查和计算。

知识体系梳理

本节的知识体系可以围绕“死锁的定义与条件”和“死锁的三大处理策略”两条主线展开。

一、死锁的定义与条件 (What & Why)

定义： 一组并发进程，因相互等待对方所占有的、自己无法获取的资源，而都陷入无限期等待的状态。
产生的四个必要条件 (必考核心):
- 互斥条件 (Mutual Exclusion): 资源是排他性使用的。
- 占有并等待条件 (Hold and Wait): 进程已占有至少一个资源，同时又在请求新的资源。
- 非剥夺条件 (No Preemption): 资源不能被强制抢占，只能由持有者主动释放。
- 循环等待条件 (Circular Wait): 存在一个进程-资源的循环等待链 P₀->R₁->P₁->...->P₀。
- 关键： 这四个条件是同时满足才会发生死锁。

二、死锁的三大处理策略

死锁预防 (Deadlock Prevention) (静态策略)
- 思想： 通过施加严格的限制，破坏四个必要条件中的至少一个，从而从根本上杜绝死锁的发生。
- 方法 (高频考点):
  - 破坏“互斥”: 将资源改造为可共享（如SPOOLing技术），但适用性有限。
  - 破坏“占有并等待”:
    - 一次性分配所有资源： 进程运行前必须申请到全部资源。
    - 请求-释放策略： 申请新资源前必须先释放所有已占有资源。
  - 破坏“非剥夺”: 允许资源剥夺（抢占）。
  - 破坏“循环等待”: 资源有序分配法，规定进程必须按资源编号递增的顺序申请。
- 优缺点： 实现简单，但资源利用率低，对进程限制过多。
死锁避免 (Deadlock Avoidance) (动态策略)
- 思想： 不破坏必要条件，而是在每次资源分配前，通过算法预测这次分配是否会导致系统进入不安全状态，从而避免进入可能导致死锁的区域。
- 核心概念：
  - 安全状态： 存在一个安全序列，能让所有进程都顺利完成。
  - 不安全状态： 不存在安全序列，可能会导致死锁。
  - 关系：死锁状态 ⊂ 不安全状态。
- 银行家算法 (必考核心):
  - 数据结构： Available, Max, Allocation, Need。
  - 安全性算法： 核心是查找安全序列，判断当前状态是否安全。
  - 资源请求算法： 收到请求后，先检查合法性，再试探性分配，然后运行安全性算法，若安全则分配，否则让进程等待。
死锁检测与解除 (Deadlock Detection & Recovery)
- 思想： 不加任何限制，允许死锁发生。通过检测算法定期检查系统是否已发生死锁，如果发生则采取措施解除。
- 检测方法：
  - 资源分配图化简法： 不断消去可以被满足请求的进程节点及其相关的边，如果最终图能被完全化简，则无死锁。
  - 基于银行家算法思想的检测算法。
- 解除方法 (高频考点):
  - 资源剥夺： 从一个或多个死锁进程中抢占资源。
  - 进程终止： 撤销（杀死）一个或多个死锁进程。

常见考法与例题梳理

死锁必要条件的辨析（高频基础题）
- 考法： 给出一种情况或一种策略，判断它对应、满足或破坏了哪个必要条件。
- 例题01, 04, 07, 17, 25: 全面考察了对四个必要条件的精确理解。例如，“一次性分配”破坏“占有并等待”；“资源有序分配”破坏“循环等待”；“互斥”条件通常无法破坏。
死锁处理策略的分类（高频概念题）
- 考法： 给出一种具体的算法或方法（如银行家算法、资源有序分配），要求判断它属于预防、避免还是检测。
- 例题06, 14, 38 (真题): 集中考察了对预防（Prevention）、避免（Avoidance） 和 检测（Detection） 这三大策略的区分。必须牢记：银行家算法是避免，破坏条件是预防。
银行家算法与安全性检查（必考计算/模拟题）
- 考法： 给出系统在某一时刻的资源分配表（Allocation, Max）和可用资源（Available），要求：
  1. 判断当前状态是否安全。
  2. 找出一个（或所有）安全序列。
- 例题26, 34, 35, 40, 42 (大量真题): 反复考察了安全性算法的模拟过程。这是本章最核心、最稳定的计算题型。
- 解题关键：
  - 第一步：正确计算出 Need 矩阵 (Need = Max - Allocation) 和 Available 向量。
  - 第二步：耐心、细致地模拟安全性算法的查找和资源释放过程。
死锁定理的计算应用（高频计算题）
- 考法： 给出进程数、资源总数、每个进程的最大需求量，要求计算保证不发生死锁的最小资源数或最大进程数。
- 例题09, 10, 11, 33, 37 (真题): 集中考察了这个计算。
- 核心公式/思想： R > n * (m - 1) (对于每个进程需求相同的简单情况) 或 Σ(m_i - 1) < R (对于需求不同的情况)。其本质是最坏情况下，所有进程都差一个资源时，系统至少还要有一个剩余资源。

刻意练习建议

制作“死锁处理策略”对比表：
- 创建一个表格，详细对比预防、避免、检测与解除三大策略。
- 对比维度包括：基本思想、实施时机（静态/动态）、限制条件（强/弱）、资源利用率、系统开销、代表性算法。
- 这张表能帮你从宏观上理清处理死锁的不同思路。
银行家算法模拟专项训练（重中之重）：
- 这是本章的“硬核”计算，必须通过大量练习来掌握。
- 建立解题模板：
  1. 准备： 仔细抄写 Allocation, Max, Total。
  2. 计算： 计算出 Need 和 Available。
  3. 模拟：
    - 建立 Work 向量和 Finish 数组。
    - 画表格进行模拟，每一行代表一轮查找，记录当前的 Work 值，并标记哪个进程被满足。
    - 从头到尾、不重不漏地检查每个未完成的进程是否满足 Need <= Work。
    - 找到一个后，立即更新 Work 值，并开始新一轮从头开始的查找。
- 找5-10道题目，严格按此模板进行，直到能够快速、准确地完成。
死锁定理计算公式化：
- 将 R_min = n * (m - 1) + 1 或 R_min = Σ(m_i - 1) + 1 作为固定公式来记忆和应用。
- 练习其正向（求R）和逆向（求n）的应用。
概念辨析“找不同”练习：
- 专门对比易混淆的概念：
  - 死锁 vs. 饥饿： 死锁是“循环等待”，饥饿是“持续被插队”。
  - 安全状态 vs. 不安全状态 vs. 死锁状态： 理解它们之间的包含关系（死锁 ⊂ 不安全）。
  - 预防 vs. 避免： 破坏条件 vs. 动态预测。