🏷️ 知识点：进程和线程

相对采用单一内核结构，采用微内核结构设计和实现操作系统有诸多好处，但是（ ）不是微内核的优势。

A. 使系统更高效 B. 想添加新任务时，不必修改内核 C. 使系统更安全 D. 使系统更可靠

操作系统概念 进程和线程

[tag_link]

正确答案：A

微内核结构通过最小化内核功能，仅保留进程调度、内存管理等核心服务，而将文件系统、设备驱动等其他服务置于用户空间。 这种设计提升了系统的安全性和可靠性：用户空间服务的故障不易蔓延至内核，从而增强了隔离性（对应选项 C 和 D）。 同时，微内核支持模块化扩展，添加新任务时只需在用户空间实现，无需修改内核，提高了灵活性（对应选项 B）。 然而，微内核的劣势在于效率：由于服务分布在用户空间，需要频繁的进程间通信和上下文切换，这引入了额外开销，导致性能通常不如单一内核结构高效。 因此，选项 A“使系统更高效”并非微内核的优势，反而是其常见缺点。

多用户系统有必要保证进程的独立性，保证操作系统本身的安全，但为了向用户提供更大的灵活性，应尽可能地限制用户进程。下面列出的各操作中，（ ）是必须加以保护的。

A. 从用户模式切换到特权模式 B. 从内存中读取自己的数据 C. 打开自己的用户文件 D. 执行自己的程序代码

进程和线程 进程概念

[tag_link]

正确答案：A

在操作系统中，从用户模式切换到特权模式（通常通过系统调用或中断实现）是一个关键且敏感的操作。 如果允许用户进程随意切换到特权模式，它将获得对系统资源的完全控制权，从而严重破坏系统的安全性和进程的独立性。 因此，这个操作必须受到严格的保护和控制。 其他选项（B、C、D）描述的是进程在自身权限范围内的常规操作，通常不需要额外的特殊保护。

下列关于进程和线程的叙述中，正确的是（ ）。 I. 一个进程可包含多个线程，各线程共享进程的虚拟地址空间 II. 一个进程可包含多个线程，各线程共享栈 III. 当一个多线程进程（采用一对一线程模型）中某个线程被阻塞后，其他线程将继续工作 IV. 当一个多线程进程中某个线程被阻塞后，该阻塞进程将被撤销

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

进程和线程

[tag_link]

正确答案：B

I 正确，因为一个进程可以拥有多个线程，这些线程共享进程的虚拟地址空间，包括代码段、数据段和堆等，但每个线程有独立的栈和寄存器状态。 II 错误，线程虽然共享进程的虚拟地址空间，但每个线程都拥有自己独立的栈，用于存储局部变量和函数调用信息，因此栈并不被所有线程共享。 III 正确，在一对一线程模型（即每个用户线程映射到一个内核线程）中，如果某个线程因等待 I/O 等操作被阻塞，其他线程作为独立的执行流仍可被调度执行，不会全部阻塞。 IV 错误，当多线程进程中某个线程被阻塞时，并不会导致整个进程被撤销； 进程可能继续运行，其他线程仍可工作，进程的撤销通常由操作系统基于资源或错误决定，与单个线程阻塞无关。 综上，只有 I 和 III 正确，对应选项 B。

以下描述中，哪个不是多线程系统的特长，（ ）。

A. 利用线程并行地执行矩阵乘法运算 B. Web 服务器利用线程请求 HTTP 服务 C. 键盘驱动程序为每一个正在运行的应用配备一个线程，用来响应相应的键盘输入 D. 基于 GUI 的 debugger 用不同线程处理用户的输入、计算、跟踪等操作。

进程和线程

[tag_link]

正确答案：C

多线程系统的特长主要包括提高并发性、有效利用多核处理器、改善程序响应时间以及优化资源共享等，适用于并行计算、高并发服务和任务分离等场景。

A选项描述利用线程并行执行矩阵乘法运算，这属于计算密集型任务的并行化，能够充分利用多核CPU加速运算，是多线程在提升性能方面的典型应用。

B选项描述Web服务器利用线程处理HTTP请求，这是多线程在I/O密集型服务中的常见用法，通过为每个请求分配线程来提高并发处理能力，增强服务器效率。

C选项描述键盘驱动程序为每个正在运行的应用配备一个线程来响应键盘输入，这种做法并不符合多线程系统的特长。 键盘输入通常由操作系统统一管理（如通过中断或事件驱动机制），驱动层应集中处理输入事件再分发给相关应用。 为每个应用单独配备线程会导致线程数量过多，增加上下文切换开销和系统复杂度，反而降低效率，因此这不是多线程的优势所在。

D选项描述基于GUI的debugger使用不同线程处理用户输入、计算和跟踪等操作，这体现了多线程在改善响应性方面的特长。 通过将耗时任务与用户界面分离，可以避免界面冻结，提升用户体验，是多线程在交互式应用中的合理运用。

综上所述，C选项中的方法并非多线程系统的特长，因为它可能引入不必要的资源消耗和设计低效。

系统中有 n（n>2）个进程，并且当前没有执行进程调度程序，则（ ）不可能发生。

A. 有一个运行进程，没有就绪进程，剩下的 n-1 个进程处于等待状态 B. 有一个运行进程和 n-1 个就绪进程，但没有进程处于等待状态 C. 有一个运行进程和 1 个就绪进程，剩下的 n-2 个进程处于等待状态 D. 没有运行进程但有 2 个就绪进程，剩下的 n-2 个进程处于等待状态

进程和线程 进程概念

[tag_link]

正确答案：D

系统中有 n（n>2）个进程，当前没有执行进程调度程序，意味着调度程序未被调用或未运行，进程状态处于某个稳定时刻。 在操作系统中，进程状态包括运行、就绪和等待。 运行进程占用 CPU，调度程序通常只在进程切换时（如时间片用完、阻塞或终止）被触发执行。

选项 A、B、C 中均存在一个运行进程。 此时 CPU 正被占用，调度程序可能因运行进程未主动放弃 CPU（如未发生 I/O 请求或时间片未耗尽）而未执行，因此这些状态可能成立。 例如，A 中运行进程执行时其他进程均等待； B 中运行进程执行时所有其他进程就绪； C 中运行进程执行时一个就绪、其他等待。

选项 D 描述没有运行进程但有 2 个就绪进程。 若没有运行进程，CPU 空闲，但就绪进程存在，系统必须通过调度程序选择一个进程投入运行。 当前没有执行调度程序，则无法完成从就绪到运行的转换，该状态在逻辑上不可能稳定存在。 因此，D 不可能发生。

支持多道程序设计的操作系统在运行过程中，会不断选择新进程来运行，共享 CPU 资源，但是下面哪个不是操作系统选择新进程的直接原因，（ ）。

A. 运行进程的时间片用完 B. 运行进程出错 C. 运行进程等待某个事件的发生 D. 有新的进程被创建进入就绪队列

进程和线程 进程概念

[tag_link]

正确答案：D

在支持多道程序设计的操作系统中，进程调度是共享 CPU 资源的核心机制。

操作系统选择新进程来运行通常由特定事件直接触发，这些事件导致当前运行的进程无法继续使用 CPU，从而需要调度程序从就绪队列中选择另一个进程。

选项 A、B 和 C 描述的情况都会直接导致当前进程停止运行：时间片用完时进程被剥夺 CPU； 进程出错时可能终止或进入异常状态； 进程等待事件时会主动阻塞并释放 CPU。 这些事件都意味着 CPU 立即空闲，因此操作系统必须选择新进程来运行，它们都是调度的直接原因。

选项 D 描述的是有新进程被创建并进入就绪队列。 这种情况本身并不直接迫使操作系统中断当前进程的运行。 除非采用抢占式调度且新进程优先级更高，否则新进程只是加入就绪队列等待，当前进程可能继续执行直到主动放弃 CPU 或时间片用完。 因此，新进程创建不是选择新进程的直接原因，而是可能影响后续调度决策的一个条件。

在多对一的线程模型中，当一个多线程进程中的某一个线程执行一个需阻塞的系统调用时，（ ）。

A. 该进程的其他线程仍将继续运行 B. 整个进程都将阻塞 C. 该阻塞线程将被撤销 D. 该进程将被撤销

进程和线程

[tag_link]

正确答案：B

在多对一的线程模型中，多个用户级线程映射到单个内核级线程。

这意味着所有用户级线程都由同一个内核线程管理，内核线程是操作系统进行调度和执行的基本单位。

当一个用户级线程执行了一个需阻塞的系统调用（例如等待 I/O 操作完成）时，控制权会转移到内核。 由于只有一个内核线程，该内核线程会因为系统调用而进入阻塞状态。 操作系统内核会将该内核线程（从而整个进程）置于阻塞队列，并切换到其他就绪进程执行。

因此，尽管进程内部有多个用户级线程，但由于它们共享同一个内核线程，一旦这个内核线程阻塞，整个进程就无法继续运行，所有用户级线程都会被阻塞。 其他选项不正确：A 错误，因为其他线程无法运行； C 和 D 错误，因为线程和进程通常不会被撤销，只是状态改变。

（ ）调度算法有利于 CPU 繁忙型的进程，而不利于 I/O 繁忙型的进程。

A. 时间片轮转 B. 先来先服务 C. 短进程优先 D. 优先级调度

进程和线程 进程概念

[tag_link]

正确答案：B

先来先服务（FCFS）调度算法是一种非抢占式算法，进程按到达顺序运行，直到完成。 CPU 繁忙型进程通常需要长时间连续使用 CPU 进行计算，FCFS 允许它们一旦开始运行便独占 CPU 直至结束，减少了上下文切换的开销，因此有利于这类进程。 相反，I/O 繁忙型进程频繁进行 I/O 操作，运行时间较短，但在 FCFS 中，如果它们排在 CPU 繁忙型进程之后，必须等待长时间才能获得 CPU，导致响应延迟； 同时，即使 I/O 操作释放了 CPU，FCFS 的非抢占特性也可能让 CPU 空闲或由长进程占用，不利于 I/O 繁忙型进程的快速切换。 因此，FCFS 有利于 CPU 繁忙型进程，而不利于 I/O 繁忙型进程。

其他算法分析：时间片轮转通过分时共享促进公平，利于 I/O 繁忙型进程在 I/O 等待后快速重获 CPU； 短进程优先优先运行短进程，I/O 繁忙型进程通常受益，而 CPU 繁忙型进程被推迟； 优先级调度的效果取决于优先级设置，不直接针对进程类型，故不明确符合题意。

对计型信号量 S 执行 V 操作后，下列选项中错误的是（ ）。 Ⅰ. 当 S.value≤0 时，唤醒一个阻塞队列进程 Ⅱ. 只有当 S.value<0 时，唤醒一个阻塞队列进程 Ⅲ. 当 S.value<=0 时，唤醒一个就绪队列进程；当 S.value>0 时，系统不做额外操作

A. Ⅰ、Ⅲ B. Ⅰ、Ⅳ C. Ⅰ、Ⅱ、Ⅲ D. Ⅱ、Ⅲ

进程和线程 进程概念

[tag_link]

正确答案：D

在计型信号量的V操作中，首先将S.value加1，然后判断S.value的值。

若S.value小于等于0，说明之前有进程因资源不足而阻塞，此时应从阻塞队列中唤醒一个进程，并将其移至就绪队列； 若S.value大于0，则无需进行唤醒操作。

对于选项Ⅰ：当S.value≤0时，确实需要唤醒一个阻塞队列进程，因此该选项正确。 对于选项Ⅱ：它强调“只有”当S.value<0时才唤醒，但标准V操作在S.value=0时同样会唤醒进程（因为加1前S.value为-1，表示有进程阻塞），因此该选项错误。 对于选项Ⅲ：V操作唤醒的是阻塞队列中的进程，而非就绪队列中的进程。 就绪队列中的进程已处于就绪状态，无需唤醒，因此该选项错误。

综上，错误的选项是Ⅱ和Ⅲ，对应答案D。

系统拥有一个 CPU、IO1 和 IO2 为两个不同步的输入/输出装置，它们能够同时工作。当使用 CPU 之后控制转向 IO1、IO2 时，或者使用 IO1、IO2 之后控制转向 CPU 时，由控制程序执行中断处理，但这段处理时间忽略不计。有 A、B 两个进程同时被创建，进程 B 的调度优先权比进程 A 高，但是，当进程 A 正在占用 CPU 时，即使进程 B 需要占用 CPU，也不能打断进程 A 的执行。若在同一系统中分别单独执行，则需要占用 CPU、IO1、IO2 的时间如下图所示：

A. 进程 A B. 进程 B C. 进程 A 和进程 B 同时 D. 不一定

进程和线程 进程概念

[tag_link]

正确答案：A

由于进程 B 的调度优先级高于进程 A，且 CPU 非抢占（进程 A 占用 CPU 时不可被打断），初始时两进程同时就绪，CPU 优先分配给进程 B。

通过模拟并发执行的时间线：

• 进程 B 首先运行 CPU 20ms（0–20ms），随后进程 A 运行 CPU 25ms（20–45ms）。 >
• 进程 A 请求 IO1 时需等待至 50ms（因 IO1 被 B 占用），之后 A 使用 IO1 30ms（50–80ms），同时 B 运行 CPU 20ms（50–70ms）后使用 IO2 20ms（70–90ms）。 >
• A 在 80ms 就绪后运行 CPU 20ms（80–100ms），期间 B 在 90ms 就绪但因 A 占用 CPU 而等待。 >
• A 随后使用 IO2 20ms（100–120ms），B 运行 CPU 10ms（100–110ms）后等待 IO2 至 120ms。 >
• B 使用 IO2 20ms（120–140ms），A 运行 CPU 20ms（120–140ms）。 >
• 最后 A 使用 IO1 30ms（140–170ms）结束，B 运行 CPU 45ms（140–185ms）结束。 >

因此进程 A 在 170ms 结束，进程 B 在 185ms 结束，进程 A 先结束。 >

进程从运行状态到等待状态可能是（ ）。

A. 运行进程执行了 P 操作 B. 进程调度程序的调度 C. 运行进程的时间片用完 D. 运行进程执行了 V 操作

进程和线程 进程概念

[tag_link]

正确答案：A

进程从运行状态进入等待状态通常是由于进程请求某个资源或等待某个事件，但该资源暂时不可用或事件尚未发生。 P 操作（即 wait 操作）是同步机制中的一种，用于申请资源。 当运行进程执行 P 操作时，如果信号量值小于等于 0，表示资源不足，该进程会被阻塞并进入等待状态，因此选项 A 正确。

其他选项中，B 和 C 通常导致进程从运行状态转为就绪状态：进程调度程序的调度可能将运行进程切换为就绪状态以让其他进程运行； 时间片用完也会触发调度，使进程从运行转为就绪。 D 选项的 V 操作（即 signal 操作）用于释放资源，可能唤醒等待中的进程，但执行 V 操作的进程本身不会进入等待状态。

因此，只有 A 选项描述了进程从运行状态到等待状态的可能情况。

并发进程运行时，其推进的相对速度是（ ）。

A. 由进程的程序结构决定 B. 由进程自己的代码控制 C. 与进程调度策略有关 D. 在进程创建时确定的

进程和线程 进程概念

[tag_link]

正确答案：C

并发进程的推进相对速度主要与操作系统的进程调度策略有关。 在并发环境中，多个进程交替或并行执行，其执行顺序和获得 CPU 时间的频率由调度器根据策略（如时间片轮转、优先级调度等）动态决定。 进程的程序结构或代码虽可能影响其计算需求，但无法直接控制调度器的分配行为； 进程创建时可能设定初始属性，但推进速度在运行时会随系统负载和调度决策变化，并非固定不变。 因此，推进速度的关键因素是调度策略。

在支持多线程的系统中，进程 P 创建的若干线程不能共享的是（ ）。

进程和线程

A. 进程 P 的代码段

B. 进程 P 中打开的文件

C. 进程 P 的全局变量

D. 进程 P 中某线程的栈指针

[tag_link]

正确答案：D

进程是资源分配的基本单位， 线程 是处理机调度的基本单位。因此，进程的代码段、进程打开的文件、进程的全局变量等都是进程的资源，唯有进程中某线程的栈指针是属于线程的，属于进程的资源可以共享，属于线程的栈是独享的，对其他线程透明。

属于同一进程的两个线程 thread1 和 thread2 并发执行，共享初值为 0 的全局变量 x。thread1 和 thread2 实现对全局变量 x 加 1 的机器级代码描述如下：

thread1

mov R1, x   // (x) → R1
inc R1      // (R1) + 1 → R1
mov x, R1   // (R1) → x

thread2

mov R2, x   // (x) → R2
inc R2      // (R2) + 1 → R2
mov x, R2   // (R2) → x

在所有可能的指令执行序列中，使 x 的值为 2 的序列个数是（）。

进程和线程

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

[tag_link]

正确答案：B

仔细阅读两个线程代码可知，threadl 和 thread2 均是对 x 进行加 1 操作，x 初始值为 0，若要使得最终 x = 2，只有先执行 thread1 再执行 thread2，或先执行 thread2 再执行 threadl，故只有 2 种可能，选 B。

对于两个并发进程，设互斥信号量为 mutex，若 mutex=0，则表示（　）。

A. 没有进程进入临界区 B. 有一个进程进入临界区 C. 有一个进程进入临界区，另一个进程等待进入 D. 有一个进程在等待进入

进程和线程 进程概念

[tag_link]

正确答案：B

互斥信号量 mutex 用于控制进程对临界区的访问，其初始值通常为 1，表示没有进程进入临界区。 当 mutex=0 时，表示有一个进程已经成功执行了 P(mutex) 操作（即 wait 操作），将 mutex 减 1 后变为 0，这意味着该进程进入了临界区，且当前没有其他进程在等待进入临界区（因为等待时 mutex 会变为负值）。 因此，选项 B 正确。 选项 A 错误，因为 mutex=0 表示有进程在临界区内； 选项 C 和 D 错误，因为 mutex=0 时没有进程等待，等待发生时 mutex 值会小于 0。

某系统有 3 台打印机，N 个进程共享使用。每个进程需先申请 1 台打印机，使用完毕后再释放。用 PV 操作管理时，设置信号量 S 的初值为 3，以下关于信号量 S 的叙述中，正确的是（）

A. 当前 S 的值表示系统中当前可用的打印机台数 B. 当前 S 的值表示系统中当前被占用的打印机台数 C. 当前 S 的值表示系统中当前阻塞等待打印机的进程数 D. 若当前 S 的值为 0，则一定没有进程正在使用打印机

信号量 进程和线程

[tag_link]

正确答案：A

• 信号量 S 用于表示资源（打印机）的数量，采用**资源信号量**（或称记录型信号量）的典型用法。 > 初始时 S = 3，表示 3 台打印机都可用。 >
• 进程申请打印机时执行 P(S)：若 S > 0，则 S 减 1 并分配一台打印机； > 若 S = 0，则进程阻塞等待。 > 因此 **S 的当前值表示系统中当前可用的打印机数量**，A 正确。 >
• B 错误，被占用的打印机数 = 3 − S。 >
• C 错误，阻塞进程数由另一个等待队列记录，并不等于 S 的值（S 可能为负数，其绝对值表示阻塞进程数，但题目是记录型信号量的常规描述，一般 S 值不直接表示阻塞进程数，且通常教材中 S 的值可以小于 0，其绝对值为等待进程数，但本题强调“当前 S 的值”直接含义，应选 A）。 >
• D 错误，S = 0 表示打印机已全部分配出去，可能正有多个进程在使用打印机。 >

关于临界区问题（critical section problem）的一个算法（假设只有进程 P0 和 P1 可能会进入该临界区）如下（i 为 0 或 1），该算法（ ）。

A. 不能保证进程互斥进入临界区，且会出现“饥饿” B. 不能保证进程互斥进入临界区，但不会出现“饥饿” C. 保证进程互斥进入临界区，但会出现“饥饿” D. 保证进程互斥进入临界区，不会出现“饥饿”

临界资源 进程和线程

[tag_link]

正确答案：B

该算法不能保证进程互斥进入临界区。 > 分析两个进程 P0 和 P1 的执行流程：假设初始时共享变量 turn=0，P0 首先执行，检查 turn!=0 为假，跳过 turn=0 的设置，再检查 turn!=0 为假，不跳转，然后设置 turn=1 并进入临界区。 > 此时 P1 也开始执行，检查 turn!=1 为假，跳过 turn=1 的设置，再检查 turn!=1 为假，不跳转，设置 turn=0 并进入临界区。 > 这样，P0 和 P1 同时处于临界区，违反了互斥条件。 >

虽然互斥无法保证，但算法不会导致“饥饿”（即某个进程永远无法进入临界区）。 > 因为每个进程在尝试进入时，都会通过循环检查 turn 是否等于自己的标识 i。 > 无论 turn 初始值如何，进程在执行中总会将 turn 设置为对方或 0，使得另一个进程在后续尝试中能够通过检查并进入临界区。 > 例如，P0 退出临界区时设置 turn=0，之后 P1 尝试时可能先设置 turn=1 再检查通过，从而进入临界区。 > 两个进程在竞争中有机会交替进入，没有进程会被永久阻塞。 >

因此，该算法不能保证互斥，但不会出现饥饿。 >

设有 $n$ 个进程共用一个相同的程序段，假设每次最多允许 $m$ 个进程（ $m\le n$ ）同时进入临界区，则信号量 $S$ 的初值为（ ）。

A. $m$ B. $n$ C. $m-n$ D. $-m$

进程和线程 进程概念

[tag_link]

正确答案：A

在操作系统中，信号量用于管理对共享资源的访问，其初值通常表示系统中可用资源的数量。 本题中，临界区允许最多 $m$ 个进程同时进入，因此初始时可用资源数为 $m$ 。 信号量 $S$ 的初值应设置为 $m$ ，这样当进程执行 P 操作（wait）时， $S$ 减 1，若 $S$ 仍为非负则进程可进入临界区； 当进程执行 V 操作（signal）时， $S$ 加 1，释放资源。 若初值设为其他选项，如 $n$ （进程总数）会导致超过 $m$ 个进程同时进入，不符合限制； $m-n$ 或 $-m$ 为负数，不符合资源数量的初始状态。 因此，正确初值为 $m$ 。

关于优先级大小的论述中，错误的是（ ）。 I. 计算型作业的优先级，应高于 I/O 型作业的优先级 II. 短作业的优先级，应高于长作业的优先级 III. 用户进程的优先级，应高于系统进程的优先级 IV. 资源要求多的作业的优先级应高于对资源要求少的优先级

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

进程和线程 进程概念

[tag_link]

正确答案：C

优先级调度需要综合考虑系统效率和资源利用率。

对于论述 I，计算型作业主要占用 CPU，而 I/O 型作业频繁进行输入输出操作，若计算型作业优先级更高，可能导致 I/O 设备闲置，降低系统整体吞吐量，因此通常 I/O 型作业优先级更高，I 错误。

对于论述 II，短作业优先调度可减少平均等待时间，提高系统响应性，因此短作业优先级高于长作业是合理的，II 正确。

对于论述 III，系统进程（如内核进程）负责关键系统功能，必须优先运行以确保系统稳定，用户进程优先级一般较低，III 错误。

对于论述 IV，资源要求多的作业若优先级高，可能长期占用资源导致其他作业饥饿，不利于资源均衡利用，通常资源要求少的作业优先级更高，IV 错误。

因此，错误的论述是 I、III 和 IV，对应选项 C。

利用死锁定理简化下列进程资源图，则处于死锁状态的是（ ）。

A. I B. II C. I 和 II D. 都不处于死锁状态

进程和线程 进程概念

[tag_link]

正确答案：B

【解析】根据死锁定理，首先需要找出既不阻塞又不是孤点的进程。 对于Ⅰ图，由于 R2 资源已经分配了 2 个，还剩余一个空闲 R2，可以满足进程 P2 的需求，所以 P2 是这样的进程。 P2 运行结束后，释放一个 R1 资源和两个 R2 资源，可以满足 P1 进程的需求，从而系统的资源分配图可以完全简化，不是处于死锁状态。 而对于Ⅱ图，P1 需要 R1 资源，但是唯一的一个 R1 资源已经分配给 P2； 同样，P2 需要 R4 资源，而 R4 资源也只有一个且已经分配给了 P3； 而 P3 还需要一个 R2 资源，但是两个 R2 资源都已经分配完毕了，所以 P1，P2，P3 都处于阻塞状态，系统中不存在既不阻塞又不是孤点的进程，所以系统Ⅱ处于死锁状态。

注意：在进程资源图中，P->R 表示进程正在请求资源，若 R->P，表示资源已被分配给进程（资源只能是被动的）

设 $m$ 为同类资源数， $n$ 为系统中并发进程数。当 $n$ 个进程共享 $m$ 个互斥资源时，每个进程的最大需求是 $w$ ，则下列情况会出现系统死锁的是（ ）。

A. $m=2,n=1,w=2$ B. $m=2,n=2,w=1$ C. $m=4,n=3,w=2$ D. $m=4,n=2,w=3$

进程和线程 进程概念

[tag_link]

正确答案：D

系统死锁的一个常见条件是当所有进程都持有部分资源并等待更多资源时，资源总数不足以满足任何进程的剩余需求。

具体来说，如果每个进程的最大需求为 w，那么在最坏情况下，每个进程都已获得 w-1 个资源并等待最后一个资源。 此时，已分配资源总数为 n(w-1)，如果资源总数 m 不超过 n(w-1)，即 m ≤ n(w-1)，则系统可能陷入死锁。

分析各个选项：

A. m=2, n=1, w=2：计算 n(w-1)=1×(2-1)=1，m=2>1，不会死锁。

B. m=2, n=2, w=1：计算 n(w-1)=2×(1-1)=0，m=2>0，不会死锁。 C. m=4, n=3, w=2：计算 n(w-1)=3×(2-1)=3，m=4>3，不会死锁。 D. m=4, n=2, w=3：计算 n(w-1)=2×(3-1)=4，m=4 恰好等于 n(w-1)，此时两个进程各获得 2 个资源后，所有资源被占用，每个进程还需 1 个资源才能完成，但无可用资源，因此系统会出现死锁。

假设系统有 5 个进程，A、B、C 三类资源。某时刻进程和资源状态如下：

A. 系统不安全 B. 该时刻，系统安全，安全序列为<P1,P2,P3,P4,P5> C. 该时刻，系统安全，安全序列为<P2,P3,P4,P5,P1> D. 该时刻，系统安全，安全序列为<P4,P5,P1,P2,P3>

进程和线程 进程概念

[tag_link]

正确答案：D

首先，根据给定的分配矩阵和最大需求矩阵，计算每个进程的需求矩阵，需求 = 最大需求 - 分配。 计算如下：

进程 P1 需求 = $(5-2,5-1,9-2)=(3,4,7)$ ；

进程 P2 需求 = $(5-4,3-0,6-2)=(1,3,4)$ ； 进程 P3 需求 = $(4-4,0-0,11-5)=(0,0,6)$ ； 进程 P4 需求 = $(4-2,2-0,5-4)=(2,2,1)$ ； 进程 P5 需求 = $(4-3,2-1,4-4)=(1,1,0)$ 。

初始可用资源向量为

$(2,3,3)$ 。

接下来，检查各选项的安全序列。

• 选项 B 序列为

$⟨P1,P2,P3,P4,P5⟩$ ，但进程 P1 需求 $(3,4,7)$ 大于初始可用资源 $(2,3,3)$ ，不满足条件，因此无效。

选项 C 序列为

$⟨P2,P3,P4,P5,P1⟩$ ，进程 P2 需求 $(1,3,4)$ 中资源 C 的需求 $4$ 大于初始可用资源中的 $3$ ，不满足，因此无效。

选项 D 序列为

$⟨P4,P5,P1,P2,P3⟩$ ，逐步检查：

1. 进程 P4 需求 $(2,2,1)\le$ 当前可用资源 $(2,3,3)$ ，运行后可用资源更新为 $(4,3,7)$ ；

2. 进程 P5 需求

   $(1,1,0)\le (4,3,7)$ ，运行后可用资源更新为 $(7,4,11)$ ；

3. 进程 P1 需求

   $(3,4,7)\le (7,4,11)$ ，运行后可用资源更新为 $(9,5,13)$ ；

4. 进程 P2 需求

   $(1,3,4)\le (9,5,13)$ ，运行后可用资源更新为 $(13,5,15)$ ；

5. 进程 P3 需求

   $(0,0,6)\le (13,5,15)$ ，所有进程可完成。

   因此序列 D 是有效的安全序列，系统安全。

选项 A 声称系统不安全，但存在安全序列，故错误。 综上所述，正确答案为 D。

下列说法中，正确的是（ ）。 Ⅰ. 先进先出（FIFO）页面置换算法可能会产生 Belady 现象。 Ⅱ. 最近最少使用（LRU）页面置换算法可能会产生 Belady 现象。 Ⅲ. 在进程运行时，如果它的工作集页面都在虚拟存储器内，能够使该进程有效地运行，否则会出现频繁的页面调入/调出现象。 Ⅳ. 在进程运行时，如果它的工作集页面都在主存储器内，能够使该进程有效地运行，否则会出现频繁的页面调入/调出现象。

A. Ⅰ和Ⅲ B. Ⅰ和Ⅳ C. Ⅱ和Ⅲ D. Ⅱ和Ⅳ

页面置换算法 进程和线程

[tag_link]

正确答案：B

说法Ⅰ正确：先进先出（FIFO）页面置换算法在增加内存页面帧数时，可能导致缺页次数反而增加，这种现象称为 Belady 异常，因此 FIFO 确实可能产生 Belady 现象。

说法Ⅱ错误：最近最少使用（LRU）页面置换算法属于栈算法，对于任何页面访问序列，增加页面帧数不会增加缺页次数，因此 LRU 不会产生 Belady 现象。

说法Ⅲ错误：工作集是指进程在最近一段时间内访问的页面集合。 若工作集页面仅位于虚拟存储器（如磁盘交换区），进程访问时需频繁调入主存，会导致缺页中断和页面调入/调出，无法有效运行； 有效运行需要工作集页面位于主存储器中。

说法Ⅳ正确：当进程的工作集页面都在主存储器内时，进程可快速访问所需页面，减少缺页中断，从而有效运行； 否则，会因页面缺失而出现频繁的页面调入/调出现象。

综上，正确说法为Ⅰ和Ⅳ，对应选项 B。

若进程 P 中有一个线程 T，打开文件后获得 fd，再创建线程 Ta、Tb，则线程 Ta、Tb 可共享的资源是（）。

I. 进程 P 的地址空间II. 线程 T 的栈III. fd

进程和线程

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

[tag_link]

正确答案：B

I. 进程 P 的地址空间：在同一进程中的所有线程共享该进程的地址空间。这意味着，线程 Ta 和 Tb 可以访问进程 P 的全局变量，因为这些变量存储在进程的地址空间中。此外，如果线程 T 在堆上分配了内存，那么线程 T 和 Tb 也可以访问这些内存，因为堆是存储在进程的地址空间中的。II. 线程 T 的栈：每个线程都有自己的栈，这是线程的私有资源，不会被其他线程共享。栈用于存储函数调用的局部变量和返回地址。由于每个线程可能有不同的函数调用序列，因此每个线程需要由自己的栈，因此，线程 Ta 和 Tb 不能访问线程 T 的栈。III. 文件描述符 fd：同进程中的所有线程共享该进程打开的文件描述符。文件描述符是一个整数，用于表示进程打开的文件。当线程打开一个文件时，操作系统会返回一个文件描述符，然后线程 T、T 和 Tb 都可以使用这个文件描述符来读写该文件，这是因为，尽管每个线程有自己的栈，但是它们共享其余的进程资源，包括文件描述符。

下列关于进程和线程的叙述中，正确的是（ ）。

进程和线程

A. 不管系统是否支持线程，进程都是资源分配的基本单位

B. 线程是资源分配的基本单位，进程是调度的基本单位

C. 系统级线程和用户级线程的切换都需要内核的支持

D. 同一进程中的各个线程拥有各自不同的地址空间

[tag_link]

正确答案：A

在引入 线程 后，进程依然还是资源分配的基本单位，线程是调度的基本单位，同一进程中的各个线程共享进程的地址空间。在用户级线程中，有关线程管理的所有工作都由应用程序完成，无须内核的干预，内核意识不到线程的存在。

有两个并发执行的进程 P1 和 P2，共享初值为 1 的变量 x。P1 对 x 加 1，P2 对 x 减 1。加 1 和减 1 操作的指令序列分别如下所示。

P1 // 加 1 操作
load R1, x // 取 x 到寄存器 R1 中
inc R1
store x, R1 // 将 R1 的内容存入 x
P2 // 减 1 操作
load R2, x // 取 x 到寄存器 R2 中
dec R2
store x, R2 // 将 R2 的内容存入 x

两个操作完成后，x 的值（ ）。

进程和线程

A. 可能为 -1 或 3

B. 只能为 1

C. 可能为 0、1 或 2

D. 可能为 -1、0、1 或 2

[tag_link]

正确答案：C

将P1中 3 条语句依次编号为 1,2,3；P2中 3 条语句依次编号为 4,5,6。依次执行 1,2,3,4,5,6 得结果 1，依次执行 1,2,4,5,6,3 得结果 2，执行 4,5,1,2,3,6 得结果 0。因此结果 -1 不可能得出。

（7 分）兄弟俩共同使用一个账号，每次限存或取 10 元，存钱与取钱的进程分别如下所示：

由于兄弟俩可能同时存钱和取钱，因此这两个进程是并发的。若哥哥先存了两次钱，但在第三次存钱时，弟弟在取钱。请问：

（1）最后账号 amount 上面可能出现的值？ （2）如何用 P、V 操作实现两并发进程的互斥执行？

进程和线程 进程概念

[tag_link]

**【答案】** （1）最后账号 `amount` 可能出现的值为 10、20 或 30。 （2）使用 P、V 操作实现互斥：定义一个信号量 `mutex` 并初始化为 1。在存钱进程 `SAVE()` 和取钱进程 `TAKE()` 中，在访问共享变量 `amount` 的代码段前后分别执行 `P(mutex)` 和 `V(mutex)`，确保同一时刻只有一个进程进入临界区。

**【解析】** 假设存钱进程 `SAVE()` 和取钱进程 `TAKE()` 的正确逻辑为：

• `SAVE()`：读取 `amount` 到局部变量，加 10，再写回 `amount`。
• `TAKE()`：读取 `amount` 到局部变量，减 10，再写回 `amount`。 哥哥先存了两次钱，`amount` 从 0 增加到 20。第三次存钱时，弟弟同时取钱，两个进程并发执行，由于没有互斥保护，它们的操作可能交错执行，导致竞态条件。

考虑第三次存钱和取钱的交错情况：

• 若存钱先完整执行，再取钱执行：存钱后 `amount=30`，取钱后 `amount=20`，最终为 20。
• 若取钱先完整执行，再存钱执行：取钱后 `amount=10`，存钱后 `amount=20`，最终为 20。
• 若操作交错：例如存钱读取 20 后，取钱也读取 20，然后存钱写入 30，取钱写入 10，最终为 10；或类似交错导致存钱写入覆盖取钱结果，最终为 30。 因此，`amount` 可能为 10、20 或 30。

为实现互斥，引入信号量 `mutex` 并初始化为 1。在 `SAVE()` 和 `TAKE()` 中，将访问 `amount` 的代码段作为临界区，在进入前执行 `P(mutex)`（申请资源），退出后执行 `V(mutex)`（释放资源）。这样，任何时刻只有一个进程能执行临界区代码，避免数据不一致。修改后的代码示例如下：

semaphore mutex = 1;

SAVE() {
    P(mutex);
    int m1 = amount;
    m1 = m1 + 10;
    amount = m1;
    V(mutex);
}

TAKE() {
    P(mutex);
    int m2 = amount;
    m2 = m2 - 10;
    amount = m2;
    V(mutex);
}
`

通过 P、V 操作确保进程互斥执行，保证 `amount` 操作的原子性。