33. C
2026 旧版 · 非 2027 主源 · 原书检索 · 文字用于定位，公式与图表请回原页核验 · 本次导入快照
## 33. C
这类题可用到组合数学中鸽巢原理的思想。考虑最极端的情况，因为每个进程最多需要3台打印机，若每个进程已经占有了2台打印机，则只要还有多的打印机，总能满足一个进程达到3台的条件，然后顺利执行，所以将8台打印机分给 $K$ 个进程，每个进程有2台打印机，这个情况就是极端情况，$K$ 为4。或者，假设 $M$ 是打印机的数量，$K$ 是进程的数量，$R$ 是每个进程最多需要打印机的数量。根据死锁公式逆推可得，若 $M \leqslant K(R - 1)$，则系统可能发生死锁。将本题的数据代入，得到 $8 \leqslant K(3 - 1)$，即 $K \geqslant 4$，因此系统可能发生死锁的 $K$ 的最小值是4。
## 34. D
本题应采用排除法，逐个代入分析。剩余资源分配给 $\mathrm{P_1}$，待 $\mathrm{P_1}$ 执行完后，可用资源数为 $(2, 2, 1)$，此时仅能满足 $\mathrm{P_4}$ 的需求，排除选项A、B；接着分配给 $\mathrm{P_4}$，待 $\mathrm{P_4}$ 执行完后，可用资源数为 $(2, 2, 2)$，此时已无法满足任何进程的需求，排除选项C。
此外，本题还可以使用银行家算法求解（对选择题来说显得过于复杂）。
## 35. D
首先求得各进程的需求矩阵 Need 与可利用资源向量 Available:
[tbl-58.md](tbl-58.md)
[tbl-59.md](tbl-59.md)
比较 Need 和 Available 发现，初始时进程 $\mathrm{P_1}$ 与 $\mathrm{P_3}$ 可满足需求，排除选项 A、C。尝试给 $\mathrm{P_1}$ 分配资源时，$\mathrm{P_1}$ 完成后 Available 将变为 (6, 3, 6)，无法满足 $\mathrm{P_0}$ 的需求，排除选项 B。尝试给 $\mathrm{P_3}$ 分配资源时，$\mathrm{P_3}$ 完成后 Available 将变为 (4, 3, 7)，该向量能满足其他所有进程的需求。因此，以 $\mathrm{P_3}$
<!-- page: 182 -->
开头的所有序列都是安全序列。
36. B
银行家算法是避免死锁的方法，选项 A、D 错。根据下图，选项 B 对，选项 C 错。
37. B
根据死锁公式，当资源数量大于各个进程所需资源数-1的总和时，不发生死锁，三个进程分别需要3,4,5台设备，即当资源数量大于 $(3 - 1) + (4 - 1) + (5 - 1) = 9$ 时，不发生死锁。而当系统中只有9台设备时，第一个进程分配2台，第二个进程分配3台，第三个进程分配4台，这种情况下，三个进程均无法继续执行下去，发生死锁。当系统再增加1台设备，最后1台设备分配给任意一个进程都可以顺利执行完成，因此保证系统不发生死锁的最小设备数为10。
38. B
死锁的处理采用三种策略：死锁预防、死锁避免、死锁检测和解除。
死锁预防采用破坏产生死锁的4个必要条件中的一个或几个来防止发生死锁。其中之一的“破坏循环等待条件”，一般采用顺序资源分配法，即限制了用户申请资源的顺序，因此I的前半句属于死锁预防的范畴。此外，银行家算法虽然会通过检测是否存在安全序列来判断申请资源的请求是否合法，但安全序列并不是唯一的，也不是固定的，它只是一种可能的分配方案，而不是一种必须遵循的规则，银行家算法更没有给出固定的申请资源的顺序，因此I错误。
银行家算法是最著名的死锁避免算法，其中的最大需求矩阵Max定义了每个进程对 $m$ 类资源的最大需求量，系统在执行安全性算法中都会检查此次资源试分配后，系统是否处于安全状态，若不安全则将本次的试探分配作废。在死锁的检测和解除中，系统为进程分配资源时不采取任何措施，但提供死锁检测和解除的手段，一旦检测到系统发生死锁，就立即采取相应的措施来解除死锁，因此不用关心进程所需的总资源量。选项II、III正确。
39. C
对于本题，需先画出如下所示的资源分配图。若系统出现死锁，则必然出现循环等待的情况。
从图中可以看出，若出现循环等待的情况，则至少有 $\mathrm{P_1}$、$\mathrm{P_2}$、$\mathrm{P_3}$ 三个进程在循环等待环中，在该图中不可能出现两个进程发生循环等待的情况。现在考察 $\mathrm{P_1}$、$\mathrm{P_2}$、$\mathrm{P_3}$ 三个进程形成环路的情况，若此时 $\mathrm{P_1}$、$\mathrm{P_2}$、$\mathrm{P_3}$ 三个进程分别拥有 $\mathrm{R_1}$、$\mathrm{R_2}$ 和 $\mathrm{R_3}$，则会形成 $\mathrm{P_1}$ 等待 $\mathrm{P_2}$ 释放 $\mathrm{R_2}$，$\mathrm{P_2}$ 等待 $\mathrm{P_3}$ 释放 $\mathrm{R_3}$，$\mathrm{P_3}$ 等待 $\mathrm{P_1}$ 释放 $\mathrm{R_1}$ 的循环等待情况。$\mathrm{P_1}$、$\mathrm{P_2}$、$\mathrm{P_3}$ 三个进程分别拥有 $\mathrm{R_2}$、$\mathrm{R_3}$ 和 $\mathrm{R_1}$ 的情况的分析类似。以上两种情况都会形成循环等待情况，至少有三个进程陷入死锁状态。若 $\mathrm{P_4}$ 事先已获取 $\mathrm{R_2}$，成功运行，则死锁进程数为3；若 $\mathrm{P_4}$ 尚未获取 $\mathrm{R_2}$，未运行，则死锁进程数为4。因此，若系统出现死
<!-- page: 183 -->
锁，则处于死锁状态的进程至少是3个。
## 40. A
由题意可知，仅剩最后一个同类资源，若将其分给 $\mathrm{P}_1$ 或 $\mathrm{P}_2$，则均无法正常执行；若分给 $\mathrm{P}_3$，则 $\mathrm{P}_3$ 正常执行完成后，释放的这一个资源仍无法使 $\mathrm{P}_1, \mathrm{P}_2$ 正常执行，因此不存在安全序列。
## 41. B
剥夺进程资源，将其分配给其他死锁进程，可以解除死锁，选项I正确。死锁预防是死锁处理策略（死锁预防、死锁避免、死锁检测）中最为严苛的一种策略，破坏死锁产生的4个必要条件之一，可以确保系统不发生死锁，选项II正确。银行家算法是一种死锁避免算法，用于计算动态资源分配的安全性以避免系统进入死锁状态，不能用于判断系统是否处于死锁，选项III错误。通过简化资源分配图可以检测系统是否为死锁状态，当系统出现死锁时，资源分配图不可完全简化，只有两个或两个以上的进程才会出现“坏”而不能被简化，选项IV正确。
## 42. B
首先求出需求矩阵：
$$
\mathrm {N e e d} = \mathrm {M a x} - \mathrm {A l l o c a t i o n} = \left[ \begin{array}{l l} 4 & 4 \\ 3 & 1 \\ 3 & 4 \end{array} \right] - \left[ \begin{array}{l l} 2 & 3 \\ 2 & 1 \\ 1 & 2 \end{array} \right] = \left[ \begin{array}{l l} 2 & 1 \\ 1 & 0 \\ 2 & 2 \end{array} \right]
$$
由Allocation得知当前Available为(1,0)。由需求矩阵可知，初始只能满足 $\mathrm{P}_2$ 的需求，选项A错误。$\mathrm{P}_2$ 释放资源后Available变为(3,1)，此时仅能满足 $\mathrm{P}_1$ 的需求，选项C错误。$\mathrm{P}_1$ 释放资源后Available变为(5,4)，可以满足 $\mathrm{P}_3$ 的需求，得到的安全序列为 $\mathrm{P}_2, \mathrm{P}_1, \mathrm{P}_3$，B正确，选项D错误。
## 43. C
考虑极端情况，当临界资源数为 $n$ 时，每个进程都拥有1个临界资源并等待另一个资源，会发生死锁。当临界资源数为 $n + 1$ 时，则 $n$ 个进程中至少有一个进程可以获得2个临界资源，顺利运行完后释放自己的临界资源，使得其他进程也能顺利运行，不会产生死锁。或者，根据死锁公式 $m > n(r - 1)$，其中 $m$ 是系统中临界资源的总数，$n$ 是并发进程的个数，$r$ 是每个进程所需临界资源的个数。若这个不等式成立，则系统不发生死锁。将本题的数据代入，得到 $m > n(2 - 1)$，即只要系统中临界资源的总数至少是 $n + 1$，就可避免死锁。
## 44. B
初始时系统中的可用资源数为 $< 1,3,2>$，只能满足 $\mathrm{P_0}$ 的需求 $< 0,2,1>$，所以安全序列第一个只能是 $\mathrm{P_0}$，将资源分配给 $\mathrm{P_0}$ 后，$\mathrm{P_0}$ 执行完释放所占资源，可用资源数变为 $< 1,3,2> + < 2,0,1> = < 3,3,3>$，此时可用资源数既能满足 $\mathrm{P_1}$，又能满足 $\mathrm{P_2}$，可以先分配给 $\mathrm{P_1}$，$\mathrm{P_1}$ 执行完释放资源再分配给 $\mathrm{P_2}$；也可以先分配给 $\mathrm{P_2}$，$\mathrm{P_2}$ 执行完释放资源再分配给 $\mathrm{P_1}$。所以安全序列可以是① $\mathrm{P_0}$、$\mathrm{P_1}$、$\mathrm{P_2}$ 或② $\mathrm{P_0}$、$\mathrm{P_2}$、$\mathrm{P_1}$。
## 二、综合应用题
### 01.【解答】
死锁在系统中不可能完全消灭，但我们要尽可能地减少死锁的发生。对死锁的处理有4种方法：忽略、检测与恢复、避免和预防，每种方法对死锁的处理从宽到严，同时系统并发性由大到小。这里银行家算法属于避免死锁，资源预分配属于预防死锁。
死锁检测方法可以获得最大的并发性。并发性排序：死锁检测方法、银行家算法、资源预分配法。
### 02.【解答】
系统会死锁。因为对两个账户进行加锁操作是可以分割进行的，若此时有两个用户同时进行转账，$\mathrm{P}_1$ 先对账户A进行加锁，再申请账户B；$\mathrm{P}_2$ 先对账户B进行加锁，再申请账户A，此时产生
<!-- page: 184 -->
死锁。解决的办法是：可以采用资源顺序分配法对A、B账户进行编号，用户转账时只能按照编号由小到大进行加锁；也可采用资源预分配法，要求用户在使用资源前将所有资源一次性申请到。
## 03.【解答】
这段程序在不同的运行推进速度下，可能产生死锁。例如，进程 $\mathrm{P}_{1}$ 先申请资源 $\mathbf{R}_1$，得到资源 $\mathbf{R}_1$，然后进程 $\mathrm{P}_{2}$ 申请资源 $\mathbf{R}_2$，得到资源 $\mathbf{R}_2$，进程 $\mathrm{P}_{1}$ 又申请资源 $\mathbf{R}_2$，因资源 $\mathbf{R}_2$ 已分配，使得进程 $\mathrm{P}_{1}$ 阻塞。进程 $\mathrm{P}_{1}$ 和进程 $\mathrm{P}_{2}$ 都因申请不到资源而形成死锁。若改变进程的运行顺序，则这两个进程就不会出现死锁现象。
产生死锁的原因可归结为两点：
1）竞争资源。
2）进程推进顺序非法。
产生死锁的必要条件：
1）互斥条件。
2）请求并保持条件。
3）不剥夺条件。
4）环路等待条件。
## 04.【解答】
不发生死锁要求，必须保证至少有一个进程得到所需的全部资源并执行完毕，$m \geqslant n(k - 1) + 1$ 时，一定不会发生死锁。
[tbl-60.md](tbl-60.md)
## 05.【解答】
1）可能发生死锁。满足发生死锁的4大条件，例如，$\mathrm{P}_{1}$ 占有 $\mathrm{S}_{1}$ 申请 $\mathrm{S}_{3}$，$\mathrm{P}_{2}$ 占有 $\mathrm{S}_{2}$ 申请 $\mathrm{S}_{1}$，$\mathrm{P}_{3}$ 占有 $\mathrm{S}_{3}$ 申请 $\mathrm{S}_{2}$。
2）可有以下几种答案：
A. 采用静态分配：因为执行前已获得所需的全部资源，所以不会出现占有资源又等待别的资源的现象（或不会出现循环等待资源的现象）。
B. 采用按序分配：不会出现循环等待资源的现象。
C. 采用银行家算法：因为在分配时，保证了系统处于安全状态。
## 06.【解答】
1）利用安全性算法对 $T_{0}$ 时刻的资源分配情况进行分析，可得到如下表所示的安全性检测情况。可以看出，此时存在一个安全序列 $\{\mathrm{P}_2, \mathrm{P}_3, \mathrm{P}_4, \mathrm{P}_1\}$，所以该系统是安全的。
[tbl-61.md](tbl-61.md)
此处要注意，一般大多数题目中的安全序列并不唯一。
<!-- page: 185 -->
2）若此时 $\mathrm{P_1}$ 发出资源请求 $\mathrm{Request}_1(1,0,1)$，则按银行家算法进行检查：
$\mathrm{Request}_1(1,0,1)\leqslant \mathrm{Need}_1(2,2,2)$
$\mathrm{Request}_1(1,0,1)\leqslant \mathrm{Available}(2,1,2)$
试分配并修改相应数据结构，由此形成的进程 $\mathrm{P_1}$ 请求资源后的资源分配情况见下表。
[tbl-62.md](tbl-62.md)
再利用安全性算法检查系统是否安全，可用资源Available(1, 1, 1)已不能满足任何进程，系统进入不安全状态，此时系统不能将资源分配给进程 $\mathrm{P_1}$。
若此时进程 $\mathrm{P_2}$ 发出资源请求 $\mathrm{Request}_2(1,0,1)$，则按银行家算法进行检查：
$\mathrm{Request}_2(1,0,1)\leqslant \mathrm{Need}_2(2,0,2)$
$\mathrm{Request}_2(1,0,1)\leqslant \mathrm{Available}(2,1,2)$
试分配并修改相应数据结构，由此形成的进程 $\mathrm{P_2}$ 请求资源后的资源分配情况下表：
[tbl-63.md](tbl-63.md)
再利用安全性算法检查系统是否安全，可得到如下表中所示的安全性检测情况。注意表中各个进程对应的 Work + Allocation 向量表示在该进程释放资源之后更新的 Work 向量。
[tbl-64.md](tbl-64.md)
从上表中可以看出，此时存在一个安全序列 $\{\mathrm{P}_2, \mathrm{P}_3, \mathrm{P}_4, \mathrm{P}_1\}$，因此该状态是安全的，可以立即将进程 $\mathrm{P}_2$ 所申请的资源分配给它。
3）若2）中的两个请求立即得到满足，则此刻系统并未立即进入死锁状态，因为这时所有的进程未提出新的资源申请，全部进程均未因资源请求没有得到满足而进入阻塞态。只有当进程提出资源申请且全部进程都进入阻塞态时，系统才处于死锁状态。
07. 【解答】
1）
$$
\mathrm{Need} = \mathrm{Max} - \mathrm{Allocation} = \left[ \begin{array}{cccc} 0 & 0 & 1 & 2 \\ 1 & 7 & 5 & 0 \\ 2 & 3 & 5 & 6 \\ 0 & 6 & 5 & 6 \end{array} \right] - \left[ \begin{array}{cccc} 0 & 0 & 1 & 2 \\ 1 & 0 & 0 & 0 \\ 1 & 3 & 5 & 4 \\ 0 & 0 & 1 & 4 \end{array} \right] = \left[ \begin{array}{cccc} 0 & 0 & 0 & 0 \\ 0 & 7 & 5 & 0 \\ 1 & 0 & 0 & 2 \\ 0 & 6 & 4 & 2 \end{array} \right]
$$
<!-- page: 186 -->
2）Work 向量初始化值 = Available(1, 5, 2, 0)。
系统安全性分析：
[tbl-65.md](tbl-65.md)
因为存在一个安全序列 $<\mathrm{P}_0, \mathrm{P}_2, \mathrm{P}_1, \mathrm{P}_3>$，所以系统处于安全状态。
3）$\operatorname{Request}_1(0,4,2,0) < \operatorname{Need}_1(0,7,5,0)$
$\operatorname{Request}_1(0,4,2,0) < \operatorname{Available}(1,5,2,0)$
假设先试着满足进程 $\mathrm{P}_1$ 的这个请求，则 Available 变为(1, 1, 0, 0)。
系统状态变化见下表：
[tbl-66.md](tbl-66.md)
再对系统进行安全性分析，见下表：
[tbl-67.md](tbl-67.md)
因为存在一个安全序列 $<\mathrm{P}_0, \mathrm{P}_2, \mathrm{P}_1, \mathrm{P}_3>$，所以系统仍处于安全状态。所以进程 $\mathrm{P}_1$ 的这个请求应该马上被满足。
08. 【解答】
1）根据 Need 矩阵可知，初始 Work 等于 Available 为(1, 4, 0)，可以满足进程 $\mathrm{P}_2$ 的需求；进程 $\mathrm{P}_2$ 结束后释放资源，Work 为(2, 7, 5)，可以满足 $\mathrm{P}_0, \mathrm{P}_1, \mathrm{P}_3$ 和 $\mathrm{P}_4$ 中任意一个进程的需求，所以系统不会出现死锁，当前处于安全状态。
$$
\mathrm{Need} = \mathrm{Max} - \mathrm{Allocation} = \left[ \begin{array}{lll} 0 & 0 & 4 \\ 1 & 7 & 5 \\ 2 & 3 & 5 \\ 0 & 6 & 4 \\ 0 & 6 & 5 \end{array} \right] - \left[ \begin{array}{lll} 0 & 0 & 3 \\ 1 & 0 & 0 \\ 1 & 3 & 5 \\ 0 & 0 & 2 \\ 0 & 0 & 1 \end{array} \right] = \left[ \begin{array}{lll} 0 & 0 & 1 \\ 0 & 7 & 5 \\ 1 & 0 & 0 \\ 0 & 6 & 2 \\ 0 & 6 & 4 \end{array} \right]
$$
2）若初始 Work = Available 为(0, 6, 2)，可满足进程 $\mathrm{P}_0, \mathrm{P}_3$ 的需求；这两个进程结束后释放资源，Work 为(0, 6, 7)，仅可满足进程 $\mathrm{P}_4$ 的需求；$\mathrm{P}_4$ 结束后释放资源，Work 为(0, 6, 8)，此时不能满足余下任意一个进程的需求，系统出现死锁，因此当前系统处在非安全状态。
<!-- page: 187 -->
## 注意
在银行家算法中，当实际计算分析系统安全状态时，并不需要逐个进程进行。如本题中，在情况1）下，当计算到进程 $\mathrm{P}_2$ 结束并释放资源时，系统当前空闲资源可满足余下任意一个进程的最大需求量，这时已经不需要考虑进程的执行顺序。系统分配任意一个进程所需的最大需求资源，在其执行结束释放资源后，系统当前空闲资源会增加，所以余下的进程仍然可以满足最大需求量。因此，在这里可以直接判断系统处于安全状态。在情况2）下，系统当前可满足进程 $\mathrm{P}_0, \mathrm{P}_3$ 的需求，所以可以直接让系统推进到 $\mathrm{P}_0, \mathrm{P}_3$ 执行完并释放资源后的情形，这时系统出现死锁；因为此时是系统空闲资源所能达到的最大值，所以按照其他方式推进，系统必然还是出现死锁。因此，在计算过程中，将每步中可满足需求的进程作为一个集合，同时执行并释放资源，可以简化银行家算法的计算。