10 操作系统

这道题考操作系统的层次地位和每层软件对应的使用者。先看（23）：题干说"其他系统软件（如 （23） 等）"——教材把系统软件分成两块，紧贴硬件的是操作系统，它之上、应用软件之下的那层叫"其他系统软件"，典型成员就是语言处理程序：汇编程序、编译程序、解释器。B 的三个成员全部属于这一层，正确。A 里的财务软件是典型的应用软件，混进来了；C 里的汽车防盗程序是嵌在设备里的应用软件；D 里的办公管理软件、气象预报软件也都是应用软件，只有"语言处理程序"一个词沾边。

再看（24）：图是一张金字塔，从下往上依次是计算机硬件、操作系统、其他系统软件、应用软件。①画在应用软件上方，是站在塔尖直接使用软件的人，即最终用户；②画在应用软件与其他系统软件交界处，是编写应用软件的人，即应用软件开发者；③画在操作系统和硬件交界处，是开发操作系统、编译器这类底层软件的人，即系统软件开发者。所以顺序是最终用户、应用软件开发者、系统软件开发者，选 D。A、B、C 三个选项都是这三个人名的不同排列，只要认清①在塔尖（用户）、③在塔底（系统软件开发者），就能排除所有把系统软件开发者放在第一位的选项。

考的还是"操作系统紧贴硬件"这条层次铁律。图中金字塔从下往上四层：计算机硬件、c、b、a，最终用户在塔尖使用 a 层软件。判定的锚点是：操作系统是裸机上的第一层软件，必须直接建立在硬件之上，所以 c 只能是操作系统；a 直接面向最终用户，是应用软件；夹在中间的 b 是其他系统软件（编译程序、数据库管理系统这类）。三者合起来：a=应用软件、b=系统软件、c=操作系统，选 C。

A 把 a 说成操作系统——操作系统在塔尖，用户就得以硬件方式直接操作计算机了，层次颠倒；B 把 a、b 都说成操作系统、系统软件，等于把 c（真正该是操作系统的一层）留给了应用软件，同样颠倒；D 的问题在 c：把 c 说成系统软件，那紧贴硬件的就不是操作系统了，违背"第一层软件"的定义。这道题和 2009 年下半年那道层次题是同一考点的两次命题，记住"硬件—操作系统—系统软件—应用软件—用户"这条链，两个方向考都不怕。

操作系统的职能边界题。操作系统管理计算机系统的硬件资源（处理机、存储器、设备）与软件资源（文件、信息），并向用户提供接口，A、B、C 都是其本职工作。D 的"语言编译器的设计实现"属于语言处理程序的范畴——编译器是系统软件，但它是独立开发的软件产品，不是操作系统设计时要考虑的问题，选 D。

这道题反向考"操作系统是什么"：A 的硬件资源管理对应处理机管理、存储管理、设备管理四大职能中的三个；B 的软件资源管理对应文件管理；C 的"用户与计算机之间的接口"对应命令接口、程序接口（系统调用）与图形界面。四个选项里只有 D 是"另一个系统软件的内部设计问题"。类似的边界题还有"数据库管理系统是不是操作系统的一部分"（不是，是其他系统软件）——判断标准就一条：操作系统的职能清单里有没有这一项，清单外的一律不属于。

嵌入式系统初始化的三级流程。（27）问自底向上（从硬件到软件）的次序：片级初始化→板级初始化→系统级初始化，选 B。片级初始化最底层，完成微处理器内部（寄存器、核心状态）的设置；板级初始化在片级之上，初始化处理器以外的其他硬件设备（存储器、外设接口等）；系统级初始化最顶层，以软件为主。A 的顺序把系统级插在片级与板级之间，违背"从硬件到软件"的方向；C、D 以系统级开头，完全倒置。

（28）问系统级初始化的主要任务：以软件初始化为主，主要进行操作系统的初始化，选 C。A 的"微处理器初始化"是片级初始化的任务；B 的"其他硬件设备初始化"是板级初始化的任务；D 的"设置核心寄存器和控制寄存器工作状态"同样属于片级。三级各自干什么，用一句话绑定记忆：片级=CPU 自己，板级=板卡上的其他硬件，系统级=操作系统与软件环境——顺序自底向上，任务自硬向软。这道题与 2015 年上官方答案一致，属于结论固定的送分题。

中断机制与输入的关系题。用户敲键盘或动鼠标时，硬件产生的是中断信号，最先获得输入信息的是中断处理程序——它响应硬件中断、从设备控制器读出数据、把事件转交给相应的驱动程序和系统软件，选 B。

A 的命令解释程序：是操作系统接收用户命令（如 shell 里的命令行）后进行解释执行的组件，工作在输入信息被层层递交之后，离硬件很远；C 的用户登录程序：管的是身份认证，与输入事件的实时处理无关；D 的系统调用：是用户程序主动请求操作系统服务的接口，方向是"程序→系统"，而键盘鼠标输入是"设备→系统"的被动事件，走的是中断路径而非系统调用路径。这道题的关键在"最先"两个字：硬件事件的第一站永远是中断处理程序，之后才按"I/O 软件 4 层结构"逐层上传（中断处理→设备驱动→与设备无关的系统软件→用户层）。它也与题 91 的 I/O 层次图互为表里，两题连着复习效果最好。

Windows 文件关联机制题。双击 IMG_20160122_103.jpg 时，系统并不"认识"这个文件本身，而是根据扩展名 .jpg 查一张注册表维护的映射表——文件关联（扩展名→打开程序），决定用哪个应用程序打开它，选 B。

A 的"文件"：泛指，没有机制含义；C 的文件目录：管的是文件的组织与按名存取（路径解析），与"用什么程序打开"无关；D 的临时文件：是程序运行中暂存数据的文件，与此场景无关。文件关联是 Windows 图形界面体验的基础：改动默认打开方式、右键"打开方式"菜单，背后维护的都是这张关联表。顺带区分三个"文件系统基础概念"：文件目录管查找、文件关联管打开方式、文件属性管只读/隐藏等控制（题 79 的文件级安全）——三个概念三道题，各自成对出现，混淆任何一对都会丢分。

实时操作系统的定义题。实时系统的核心特征：对外部事件的响应与处理必须在被控对象规定的时间内完成——这个截止期由外部物理过程决定，而不是由系统自身的调度参数（时间片、机器周期）决定，选 D。

A 的"一个时间片内"：时间片是分时系统的概念，实时系统甚至常采用可抢占的优先级调度而不依赖固定时间片；B 的"一个周转时间内"：周转时间是批处理系统衡量作业从提交到完成的总时间指标，属于吞吐量视角，与实时性无关；C 的"一个机器周期内"：机器周期是 CPU 内部的时序单位（纳秒级），绝大多数实时响应远达不到这个量级，且实时性关注的是"满足规定期限"，不是"越快越好"。实时系统进一步分硬实时（期限错过即灾难，如飞控）与软实时（偶尔超时可用，如视频播放），这个延伸概念也曾在上午题出现。记定义的抓手：实时 = 在规定时间内响应并处理，期限由外部被控对象规定。

嵌入式操作系统特性题。题干给出两个需求：能运行在不同的微处理器平台上（可移植），能针对硬件变化进行结构与功能上的配置（可定制）。对照选项：A 的可定制性直接对应"针对硬件变化进行结构与功能上的配置"——嵌入式 OS 常以组件/模块方式裁剪组装，按需删减文件系统、网络协议栈等，选 A。

B 的实时性：指在规定时间内完成响应与处理，题干只字未提时限；C 的可靠性：指稳定运行、故障恢复能力，同样与题干描述无关；D 的易移植性：它对应的是前半句"能运行在不同的微处理器平台上"——但题干把两个要求并列成一个整体特征问"该要求体现了什么"，官方口径取"可配置/可定制"这半句为主导。这里有个辨析点：如果题干只问"运行在不同处理器平台上"，答案应为易移植性；加上"结构与功能上可配置"后，考点落在嵌入式 OS 区别于通用 OS 的标志性能力——可定制（可裁剪）性上。嵌入式 OS 四大特性（实时性、可裁剪/定制、可靠性、易移植性）各自对应一句场景描述，背场景比背名词有效。

云计算部署模型题。四种部署模型的划分标准是"云基础设施由谁使用"：私有云——为某个客户（组织）单独使用而构建，可以是自建机房也可以是托管，但使用权独占，题干描述完全吻合，选 B。

A 的公有云：基础设施面向不特定公众开放使用（如阿里云、AWS 的公共资源池），与"单独使用"矛盾；C 的社区云：由若干有共同关切（使命、安全要求、政策、合规考虑）的组织共建共享，使用主体是"一群"而非"一个"；D 的混合云：两种及以上独立云（私有+公有等）通过标准或专有技术绑定而成，题干没有提及组合。四模型的一句话判别法：公众用=公有，一家用=私有，一群组织共用=社区，混着用=混合。这道题属于 2021 年上杂题选讲部分，操作系统章节里出现云计算题是命题范围的自然延伸（系统软件与基础设施的边界），考点本身只是名词辨析，送分性质。

三态模型与调度算法结合的题。四个进程：P1 运行、P2 就绪、P3 等打印机（等待态）、P4 等扫描仪（等待态），采用先来先服务。（23）问"P1 怎么了"才能让四进程状态重新排列。看（24）的答案反推：目标状态是"就绪、运行、等待和等待"，即 P1 从运行变就绪、P2 从就绪变运行、P3 P4 不动。能让运行态进程变成就绪的只有两种事：时间片到（被剥夺 CPU）或有更高优先级进程到达；FCFS 非抢占式下只有时间片到这一种（本题按时间片轮转的运行/就绪切换理解）。所以（23）选 A（时间片到）。B"释放了扫描仪"——P1 自己持有扫描仪才谈得上释放，释放扫描仪只会唤醒 P4，与 P1 自己的状态无关；C"释放了打印机"同理；D"P1 已完成"会让 P1 消失而非变就绪，且完成后被唤醒的是 P4（它等的是扫描仪）。

（24）问变化后四个进程的状态。P1 时间片到→就绪；调度器从就绪队列选中 P2→运行；P3 仍在等打印机、P4 仍在等扫描仪，都是等待。即"就绪、运行、等待和等待"，选 C。A 把 P1 说成等待——时间片到是"运行→就绪"，不是"运行→等待"，这是三态模型最容易混的一条边：等待态是进程主动等 I/O 或事件，被剥夺 CPU 是被动进就绪；B 把 P3 说成运行，P3 的打印机还没等到，不可能运行；D 把 P4 说成运行同理。

上一题的姊妹题：条件改成"P1 释放了扫描仪"，问四个进程的新状态。扫描仪正是 P4 在等的东西——P1 释放扫描仪（V 操作的效果），P4 从等待态被唤醒进入就绪队列；P1 自己没有放弃 CPU，仍是运行态；P2 本来就绪，没人动它，还是就绪；P3 等的打印机没动静，继续等待。所以四个进程依次是"运行、就绪、等待、就绪"，选 B。

A 把 P1 说成等待——释放资源是发出 V 操作，进程本身继续运行，不会转入等待态，这是最常见的误区；C 把 P1 说成就绪，剥夺 CPU 的只有时间片到或抢占，释放外设不引起状态下降；D 把 P2 说成运行——单处理机同一时刻只能有一个运行态进程，P1 还在跑，P2 不可能同时运行，这个选项直接违背"单处理机"前提。这道题配上上一题，把三态模型的全部迁移边都覆盖了：运行→就绪（时间片到）、等待→就绪（事件发生）、就绪→运行（被调度），剩下两条是运行→等待（主动申请 I/O）和就绪/等待→…的终态迁移，考试翻来覆去就考这几条边的触发条件。

线程共享资源的边界题。线程是进程内的执行单元，同一进程内的线程共享进程级的资源：代码段、全局变量、打开的文件、堆内存、信号量等；而线程私有的只有运行时必须独立的东西：栈（存放局部变量和函数调用现场）、寄存器组（含程序计数器）、线程控制块 TCB、栈指针。D 的"该进程中某线程的栈指针"是线程 T3 自己的调用现场信息，别的线程既不需要也不应该访问，属于私有资源，选 D。

A 的代码段：线程本来就是"共享地址空间并发执行同一段程序"，代码必然共享；B 的打开文件：文件表挂在进程上，进程里所有线程都能读写，这是线程模型的标准结论；C 的全局变量：全局变量在数据段，地址空间共享，天然共享——也正因为如此，多线程改全局变量才需要互斥锁。A、B、C 全是"能共享"的正确叙述。这道题 2013 年、2015 年各考了一次（答案分别是 D 和 C，两题选项顺序不同、正确项都是"栈指针"），2020 年又变体成"错误叙述"（见下文线程题），可见"线程共享什么、私有什么"是三年两头考的高频点，一句话记住：共享的是地址空间里的东西，私有的是执行现场里的东西。

与 2013 年那道题同考点换序：进程 P 创建若干线程，问哪个不能被共享。四个选项里 A 的打开文件、B 的代码段、D 的全局变量都属于进程的地址空间与资源清单，线程间天然共享；C 的"该进程中某线程的栈指针"是那个线程私有的执行现场——栈指针指向自己的函数调用栈顶，换一个线程上下文就要换一套栈指针，这是线程切换必须保存/恢复的核心寄存器内容，不可能跨线程共享，选 C。

这道题的干扰项设置和 2013 年完全一样，只是排列顺序变了：2013 年正确项在 D，2015 年挪到 C。命题人反复用同一个知识点、同一组选项，说明它就是教材原文级别的结论。复习时把线程私有的四件套背下来——栈、栈指针、寄存器组（程序计数器）、线程控制块——选项里出现其中任何一个，它就是"不能共享"的答案；其余凡是挂在进程上的资源（内存、文件、信号量、端口）统统可以共享。

问法反转：以下叙述中错误的是哪个。A 的"线程 T1、T2 和 T3 可以共享进程 P 的代码"——代码段在进程地址空间里，正确；C 的"可以共享进程 P 打开的文件"——文件表属于进程，正确；D 的"可以共享进程 P 的全局变量"——全局变量在数据段，正确。B 的"线程 T1、T2 可以共享 P 进程中 T3 的栈指针"——栈指针是 T3 线程私有的执行现场，指向 T3 自己的函数调用栈，T1、T2 各有各的栈和栈指针，谁也共享不了谁的，错误叙述，选 B。

这道题的陷阱在于把"共享进程的资源"与"共享某个线程的私有资源"混为一谈：前三项的主语都是"进程 P 的 XX"（进程级资源，线程共享天经地义），只有 B 的主语是"T3 的栈指针"（线程级私有物）。三道线程共享题连读，教材想让你刻进脑子的边界就是那条线：进程拥有的东西大家用，线程执行时自己的现场自己用——栈、栈指针、寄存器、TCB 永远私有，其余共享。

PCB 组织方式识图题。（24）问图中 PCB 的组织方式：图中有"运行指针"直接指向一个 PCB，另有"就绪索引表"和"阻塞索引表"各自持有若干指向 PCB 的指针——按索引表组织 PCB 队列，这是索引方式，选 B。链接方式是把同状态 PCB 用指针串成链表（就绪链表、阻塞链表），图中给的是"索引表+散列指针"结构而非链；顺序方式把 PCB 连续存放在数组区，靠下标定位；Hash 方式按 PCB 标识散列定位——图里既没有链式指针串，也没有连续表结构，排除 A、C、D。

（25）问图中进程状态统计：运行指针指向 PCB1，运行进程 1 个；就绪索引表有 3 项，指向 PCB2、PCB3、PCB4？对照图与选项，就绪 3 个；阻塞索引表 3 项，阻塞 3 个。合计"1 个运行、3 个就绪、3 个阻塞"，选 C。A 的"2 就绪 4 阻塞"、B 的"2 运行"（单处理机不可能两个运行）、D 的"4 就绪 2 阻塞"都是数错指针项数的结果。这道题的读图要点：数指针条目数，而不是数 PCB 框数——图里画了 7 个 PCB，但挂在各表上的只有 1+3+3=7 个？恰好全挂上了，那就要看每张表实际指向了几个：按官方答案 C 的口径，就绪 3、阻塞 3、运行 1，共 7 个进程，全部 PCB 各有归属，读图时逐条指针数清楚即可。

前趋图配 PV 操作的标准套路：每条有向边分配一个信号量，边的起点进程做完就 V，边的终点进程开做前先 P。图中边有四条：P1→P2、P1→P3、P2→P3、P3→P4，对应 S1、S2、S3、S4（初值均为 0）。

（25）问 a、b。a 是 P1 执行完之后的位置：P1 有两条出边（通知 P2 和 P3），所以要连做两个 V 操作，即 V(S1)、V(S2)；b 是 P2 执行之前的位置：P2 只有一条入边（等 P1），做一个 P(S1) 即可。合起来是"V(S1)V(S2) 和 P(S1)"，选 C。A 把 a 写成 P 操作——P1 是整个图里唯一的源点，没有任何前驱，不需要等待，P 操作放这里语义就错了；B 的 b 处写成 V(S1)，把"等待"写成了"通知"，方向反了；D 同样错在 b。

（26）问 c、d。c 是 P3 之前：P3 有两条入边（等 P1 和等 P2），必须连续做 P(S2)、P(S3)；d 是 P4 之前：P4 只等 P3，做 P(S4)。合起来"P(S2)P(S3) 和 P(S4)"，选 B。A、C 的 c 处出现 V 操作，进程还没开始执行就"通知别人"，显然不合理；D 的 d 处写了两个 P，等于让 P4 去等一个根本不存在的第二条前驱边。这类题做完可以数一下：全图 V 的次数应等于 P 的次数、都等于边数（4），对不上就是漏了或多了。

图里有六条边：P1→P3、P1→P4、P2→P3、P2→P5、P3→P4、P3→P5，所以需要六个信号量 S1～S6（初值全为 0），一一挂到六条边上。判断口诀不变：入边上做 P，出边上做 V。

（23）问 a、b，即 P1 和 P2 执行完的位置。P1 有两条出边（到 P3、P4），要 V(S1) 和 V(S2)；P2 也有两条出边（到 P3、P5），要 V(S3) 和 V(S4)。四个 V 连用，选 C。A、B、D 都在源点进程的位置放 P 操作——P1、P2 是前趋图的源点，没有前驱可言，放 P 就是死等一个永远不会到来的信号，方向性错误。

（24）问 c、d，即 P3 的头和尾。P3 有两条入边（等 P1、P2），开头做 P(S1)P(S3)；两条出边（通知 P4、P5），结尾做 V(S5)V(S6)，选 B。A 的开头少了 P(S3)，P3 就可能抢在 P2 之前跑；C 结尾写成 P(S3)P(S4)，通知又变成了等待。

（25）问 e、f，即 P4、P5 开头。P4 等两条边（来自 P1 的 S2 和来自 P3 的 S5），做 P(S2)P(S5)；P5 等两条边（来自 P2 的 S4 和来自 P3 的 S6），做 P(S4)P(S6)，选 C。A、B、D 的信号量组合对应不上各自进程的入边，比如 D 给 P4 配的是 S4、S6，那是 P5 的入边。这类题最稳的做法是先把每条边标注信号量编号，再逐进程"数入边做 P、数出边做 V"。

五条边、五个信号量：P1→P2 用 S1，P2→P3 用 S2，P2→P4 用 S3，P3→P5 用 S4，P4→P5 用 S5，初值均为 0。老规矩：进程开头对着入边做 P，结尾对着出边做 V。

（23）问 a、b、c 三处。a 是 P1 末尾：P1 只有一条出边，做 V(S1)；b 是 P2 开头：P2 只有一条入边（等 P1），做 P(S1)；c 是 P2 末尾：P2 有两条出边（到 P3、P4），连做 V(S2)V(S3)。三段合起来"V(S1)、P(S1) 和 V(S2)V(S3)"，选 A。B 把 a、b 两处对调（源点做 P、后继做 V，方向全反）；C 的 b 处写成 V(S2)，等于 P2 还没开始就通知 P3；D 的 c 处混入了 P 操作。

（24）问 d、e，对应 P3 的头和尾。P3 开头等 P2，做 P(S2)；结尾通知 P5，做 V(S4)，选 B。A 开头写成 V(S2) 方向反了；C 结尾改成 P(S4)，P3 做完了反而去等自己通知出去的信号量，会造成互相等待。

（25）问 f、g，对应 P4 的头和 P5 的头。P4 开头等 P2，做 P(S3)；P5 有两条入边（等 P3 的 S4 和等 P4 的 S5），开头做 P(S4)P(S5)，选 C。A 的 f 处 V(S3) 方向反；B 的 g 处只有一个 P，漏等了 P4；D 的 f 处写成 V(S3) 同样方向反。做完可以复核：每个进程的 P 数等于它的入边数、V 数等于出边数，五条边共五 P 五 V，数目闭合。

2016 年上半年的这道题把信号量的位置直接标在了进程框里，解题思路仍然是"边头 P、边尾 V"。图中五条边：P1→P2 用 S1，P1→P3 用 S2，P2→P4 用 S3，P3→P5 用 S4，P4→P5 用 S5。

（26）问 a、b。a 在 P1 末尾：P1 有两条出边（通知 P2、P3），做 V(S1)V(S2)；b 在 P2 末尾：P2 有一条出边（到 P4），做 V(S3)。合起来"V(S1)V(S2) 和 V(S3)"，选 C。A 把 b 写成 P(S2)？注意 A 选项是"V(S1)P(S2) 和 V(S3)"，b 处的 P(S2) 等的是 P1→P3 那条边，但 P2 与这条边毫无关系，P2 等的应该是 S1——而 P(S1) 已经标在 P2 的开头了，再 P 一次就重复等待；B、D 的 a 处出现 P 操作，P1 是源点不该等任何人。

（27）问 c、d，即 P3 的头尾。P3 开头等 P1，做 P(S2)；结尾通知 P5，做 V(S4)，选 B。A 的 d 处 P(S4) 方向反；C 的 c 处 V(S2) 方向反；D 两处都是 V，整个 P3 既不等也不通知，明显不对。

（28）问 e、f，即 P4 的尾和 P5 的头。P4 结尾通知 P5，做 V(S5)；P5 有两条入边（等 P3 的 S4、等 P4 的 S5），开头做 P(S4)P(S5)，选 B。A 的 f 处写成 V(S4)V(S5)，让 P5 开头就做两个 V，方向全反；C 的 e 处是 V(S3)，那是 P2 末尾的活；D 的 e 处 P(S3) 等错了信号量。

这张前趋图的五条边是：P1→P2 用 S1，P2→P3 用 S2，P2→P4 用 S3，P3→P4 用 S4，P4→P5 用 S5。注意这张图与 2016 年上半年那道（上一题）骨架相似但边不同——P3 与 P4 之间是 P3→P4 而不是 P4→P5 直连，信号量分配必须重推，不能凭印象套答案。

（26）问 a、b，即 P2 的头和尾。P2 开头等 P1，做 P(S1)；结尾有两条出边（通知 P3、P4），做 V(S2)V(S3)，选 B。A 的 b 处只有 V(S2)V(S3)？看错——A 是"P(S1) 和 V(S2)V(S3)"里的 P 开头，对照原选项 A 为"V(S1) 和 P(S2)V(S3)"，a 处做成 V、b 处开头又去 P(S2)，等于 P2 先通知后等待，顺序错乱；C、D 的 a 处都有 P(S1)，但 P2 开头的 P(S1) 题面已标出，a、b 是图中剩下的空位，把已标内容再填一遍属于重复。

（27）问 c、d，即 P3 的头尾。P3 开头等 P2，做 P(S2)；结尾通知 P4，做 V(S4)，选 C。A 的 c 处 P(S2)？A 是"P(S2) 和 P(S4)"，d 处把通知写成了等待；B 的 c 处 V(S2) 方向反；D 两处全是 V。

（28）问 e、f，即 P4 的头尾之外还需注意：P4 开头已标 P(S3)，e 是 P4 末尾前的等待位（等 P3 的 S4），f 是 P4 末尾（通知 P5 的 V(S5)）。合起来"P(S4) 和 V(S5)"，选 A。B 把两个位置对调；C、D 的信号量配对关系与 P4 的入出边不符。复核数目：五条边、五个 P、五个 V，各进程对号入座后无剩余。

这道题把前趋图和伪代码合在一起考，图里六条边：P1→P2 用 S1，P1→P3 用 S2，P2→P3 用 S3，P2→P4 用 S4，P3→P5 用 S5，P4→P5 用 S6。伪代码里已写出的 P(S1)、V(S1)、P(S2)、P(S4)、V(S3)、V(S4) 是提示，六个空 ①～⑥ 要补齐剩下的操作。

（24）问空①②。空①在 P1 的 V(S1) 之后：P1 还有第二条出边（到 P3），所以再补一个 V(S2)；空②在 P2 开头：P2 等待 P1，做 P(S1)。合起来"V(S2) 和 P(S1)"，选 D。A 的空①写成 P(S2)，P1 是源点不该等待；B 空①写成 V(S1)，与已标出的 V(S1) 重复，等于 P1 通知了 P2 两次；C 空②写成 V(S2)，方向反了。

（25）问空③④。空③在 P3 的 P(S2) 之后：P3 还有第二条入边（等 P2），补 P(S3)；空④在 P3 结尾：P3 有一条出边（到 P5），做 V(S5)。合起来"P(S3) 和 V(S5)"，选 B。A 的空③ V(S3) 方向反；C 空④写成 P(S5)，P3 做完反去等待自己该发的信号；D 空③少了一次等待、空④方向又反。

（26）问空⑤⑥。空⑤在 P4 结尾：P4 有一条出边（到 P5），做 V(S6)；空⑥在 P5 开头：P5 有两条入边（等 P3 的 S5、等 P4 的 S6），连做 P(S5)P(S6)。合起来"V(S6) 和 P(S5)P(S6)"，选 C。A 空⑥只有 P(S5)，漏等 P4；B 空⑤ V(S5) 与 P3 的收尾重复、空⑥ V 开头方向反；D 空⑤写成 P(S6)，P4 自己等自己发的信号，直接死锁。最后清点：六条边对应六个 P、六个 V，伪代码与答案合并后恰好各六个，闭合无误。

2019 年下半年的这道题与 2018 年下半年那道（上一题）同构，但图不同：六条边是 P1→P2 用 S1，P2→P3 用 S2，P2→P4 用 S3，P3→P4 用 S4，P3→P5 用 S5，P4→P5 用 S6。注意 P3→P4 这条边是上一题没有的，信号量编号也随之整体变化，必须按图重推。

（23）问空①②。空①在 P1 结尾：P1 只有一条出边（到 P2），做 V(S1)；空②在 P2 结尾：P2 有两条出边（到 P3、P4），做 V(S2)V(S3)。合起来"V(S1) 和 V(S2)V(S3)"，选 C。A 的空②是 P(S2)P(S3)，把通知写成了等待；B 空②只有一个 V，漏了通知 P4；D 空②混入 P 操作。

（24）问空③④。空③在 P3 结尾：P3 有两条出边（到 P4、P5），做 V(S4)V(S5)；空④在 P4 开头：P4 有两条入边，其中 P(S4)（等 P3）已标出，剩下等 P2 的那条边做 P(S3)。合起来"V(S4)V(S5) 和 P(S3)"，选 A。B 的空③只有一个 V，漏通知 P5；C 空④写成 V(S5)，P4 还没做就替 P3 发信号；D 空③④各少或多了一个操作且方向有误。

（25）问空⑤⑥。空⑤在 P4 结尾：P4 有一条出边（到 P5），做 V(S6)；空⑥在 P5 开头：P5 有两条入边（等 P3 的 S5、等 P4 的 S6），连做 P(S5)P(S6)。合起来"V(S6) 和 P(S5)P(S6)"，选 D。A 空⑥写成 P(S4)，等错了边；B 空⑤是 V(S5)，与 P3 结尾重复；C 空⑥少了一个 P。合并校验：六个空填入后，全图恰好六个 P、六个 V，与六条边一一对应。

六个进程的前趋图，六条边：P1→P2 用 S1，P2→P3 用 S2，P2→P4 用 S3，P3→P5 用 S4，P4→P5 用 S5，P5→P6 用 S6。这张图的特点是链条更长（到 P6），但方法完全一样：入边做 P、出边做 V，边数决定信号量个数。

（26）问 a、b，即 P2 的头和尾。P2 开头等 P1，做 P(S1)；结尾有两条出边（通知 P3、P4），做 V(S2)V(S3)。合起来"P(S1) 和 V(S2)V(S3)"，选 D。A 的 a 处是 V(S1)，源点进程先发通知，方向反；B 的 b 处是 P(S2)V(S3)，P2 自己等 P3 执行的结果，而图里 P3 明明排在 P2 之后，构成倒因果；C 的 b 处只有单个 V(S3)，漏通知 P3。

（27）问 c、d。c 在 P3 的 P(S2) 之后、P3 执行之前？注意图中 P3 的开头已标 P(S2)，c 是 P3 结尾的位置：P3 有一条出边（到 P5），做 V(S4)；d 是 P4 开头：P4 等待 P2，做 P(S3)。合起来"V(S4) 和 P(S3)"，选 B。A、C、D 或把 c 写成 P、或把 d 写成 V，都是把"等待"与"通知"两件事对调。

（28）问 e、f。e 是 P5 开头：P5 有两条入边（等 P3 的 S4、等 P4 的 S5），做 P(S4)P(S5)；f 是 P5 结尾：P5 有一条出边（到 P6），做 V(S6)。合起来"P(S4)P(S5) 和 V(S6)"，选 C。A 的 e 处只有单个 P，漏等 P4；B 的 f 处 P(S6) 方向反；D 的 e 处 V 开头同样方向反。全图复核：六条边、六 P、六 V，闭合。

2021 年下半年的这道题延续"前趋图＋伪代码"的组合：六条边 P1→P2 用 S1，P2→P3 用 S2，P2→P4 用 S3，P3→P5 用 S4，P4→P6 用 S5，P5→P6 用 S6。伪代码中已标出 P(S1)、V(S1)、P(S2)、V(S5)、P(S4)、P(S6)，六个空补齐剩余操作。

（24）问空①②。空①在 P2 开头：P2 等 P1，做 P(S1)；空②在 P2 结尾：P2 有两条出边（通知 P3、P4），做 V(S2)V(S3)。合起来"P(S1) 和 V(S2)V(S3)"，选 D。A 的空①是 V(S1)——V(S1) 已由 P1 在结尾发出，P2 再发一次等于重复通知；B 空②只通知了一个后继；C 空①处虽是 P(S1) 但题面已标，空②又混入 P。

（25）问空③④。空③在 P3 结尾：P3 有一条出边（到 P5），做 V(S4)；空④在 P4 开头：P4 等 P2，做 P(S3)。合起来"V(S4) 和 P(S3)"，选 B。A 的空③ P(S3) 方向反；C 空④ V(S3) 同样反；D 两处信号量都不是 P3、P4 各自对应的边。

（26）问空⑤⑥。空⑤在 P5 结尾：P5 有一条出边（到 P6），做 V(S6)；空⑥在 P6 开头：P6 有两条入边，P(S6)（等 P5）已标，还差等 P4 的那条，补 P(S5)。合起来"V(S6) 和 P(S5)"，选 A。B 空⑥写成 P(S6) 与已标内容重复；C 空⑤ V(S5) 与 P4 结尾已标的 V(S5) 冲突；D 的空⑤是 P 操作，P5 做完反去等待。校验：填完后六个 P、六个 V，与六条边闭合。

这道题考多个作业共享"输入—计算—输出"三段设备时的前趋图。系统只有一个 CPU、一台输入设备、一台输出设备，作业 T1、T2、T3 依次排队使用输入设备，所以输入段之间有先后：I1→I2→I3；同理计算段 C1→C2→C3（单 CPU 分时接力）、输出段 P1→P2→P3。同时每个作业内部要守 Ii→Ci→Pi 的顺序，于是还有 I1→C1、I2→C2、I3→C3、C1→P1、C2→P2、C3→P3 六条斜边。对照图：上行 I1→①→②，所以①是 I2、②是 I3，选 B（I2、I3）。A 把①说成 I2、②说成 C2，C2 在中行不在上行；C、D 把①②当成计算或输出段，位置完全对不上。

（25）问③④，在中行：③→④→C3，即③是 C1、④是 C2，选 A（C1、C2）。B 把③说成 I2，I2 在上行；C 的 I3 在上行；D 的 C1 是③自己、P2 在下行，都对不上号。

（26）问⑤⑥，在下行：P1→⑤→⑥，即⑤是 P2、⑥是 P3，选 C（P2、P3）。A 的 I3、C2 分别在上行和中行；B 的 I2、C1 也是上行中行的元素；D 的 C1 在中行。这类流水线前驱图有一个快速验算法：把 9 个节点按 I1、I2、I3、C1、C2、C3、P1、P2、P3 代入，每个节点检查"入边数=前驱数、出边数=后继数"，全部吻合即为正确答案。

这是上一题（2012 年下、三个作业）的四作业版本：T1～T4 的输入段 I1→I2→I3→I4 依次用输入设备，计算段 C1→C2→C3→C4 依次用 CPU，输出段 P1→P2→P3→P4 依次用输出设备，再加上每个作业内部的 Ii→Ci→Pi 约束。对照图：上行 I1→I2→③→I4，所以③是 I3；中行①→C2→C3→④，所以①是 C1、④是 C4；下行 P1→②→P3→⑤，所以②是 P2、⑤是 P4。

（24）问①、②，即 C1 和 P2，选 C。A 的 I2 在上行，而①在中行行首；B 的 I2、C2 分别是上行第二节点和中行第二节点，位置不对；D 的 C1 是①本身、P3 是下行第三节点，⑤②都对不上。

（25）问③、④、⑤，即 I3、C4、P4，选 D。A 的 C2 是中行第二个节点，不在待填位置上；B 的 I2 同样是上行已标出的节点；C 的 P3 在下行已标出。这道题的实用价值在于记住"同种设备段串行、单个作业内三段串行"两条规则，作业数换成几个都能直接把图画出来，而不必背图。

考信号量负值的物理含义。信号量 S 的值有明确解释：S>0 时表示当前还可用的资源数量；S=0 表示资源刚好用完且无人等待；S<0 时，绝对值表示正在等待该资源的进程数。n 个进程共享一台扫描仪（资源数 1），当 S=-3 时，表示资源早已耗尽，且有 3 个进程阻塞在 S 的等待队列上，所以有 3 个进程在等待使用扫描仪，选 C。

A 说 0 个——若无人等待，S 不会是负值，直接与题干矛盾；B 说 n-3 个——把"共享进程总数减去等待数"当等待数，恰好弄反：等待的正是 3 个，未参与的才是 n-3 个，而且扫描仪只有一台，最多一个进程在使用，n-3 个进程"正在使用"在数量上也不成立；D 说 n 个——只有资源数为 0 且全部 n 个进程都阻塞时 S 才会等于 -n，与 S=-3 不符（除非 n=3，题目没有这个条件）。这个知识点再延伸一步就是取值范围题：资源数 m、进程数 n 时，S 的范围是 [-(n-m), m]，下一题就考这个。

考信号量取值范围的两个端点怎么定。n 个进程共享两台打印机，信号量 S 初值设为资源数 2——这是上限：S 最大到 2，再多不会有更多打印机，就算所有进程都执行 V 也只能回到 2（初值就是所有 V 都执行、无任何 P 时的值）。下限出现在最坏情况：n 个进程全都执行 P(S)，前 2 个各自拿走一台打印机，剩下 n-2 个进程阻塞等待，S 被减到 2-n=-(n-2)。所以范围是 -(n-2) 到 2，选 D。

A 的 -2 到 n：下限 2-n 与 n 无关的"-2"只在 n=4 时碰巧成立，上限 n 更是把"进程数"当成了"资源数"；B 的 -(n-1) 到 1：两个端点都按"一台打印机"算的，漏了一台——这是没分清资源数是 2 还是 1 的典型错法；C 的 -(n-1) 到 2：上限对了但下限少算了一台打印机能多满足一个进程，即下限应为 -(n-2)。判断口诀：上限=资源数，下限=资源数−进程数，两个数字一代入，四个选项立刻只剩一个。

信号量的连续运算题。当前 S=-1——负值本身就有信息量：绝对值 1 表示已有 1 个进程在等待队列里，资源（3 台扫描仪）全部被占用。接着 P1、P2 各执行一次 P(S)：每执行一次 P，S 减 1。S = -1-1-1 = -3，选 B。

A 的 3：这是信号量初值（资源数）的方向——只有连做 4 次 V 才可能从 -1 回到 3，与两次 P 的题设完全相反；C 的 1：把"当前值 -1"误当成"+1"再减 2？即便如此得 -1 也不是 1，这个选项对应的是"扫描仪还有空余"的错误印象；D 的 -1：只减了一次 P 或者以为 P 操作不减负值，漏掉 P1、P2 是两次独立的 P。这类题的稳定套路：P 减 V 加，负值绝对值=等待进程数，逐次累加即可，不需要考虑具体哪个进程拿到资源——P 操作执行本身就减 1，与是否获得资源无关（没获得就阻塞，但 S 照样减）。

考 PV 操作的功能定位。PV 操作是执行期间不可打断的原语，P 申请资源（不满足则阻塞），V 释放资源（有等待者则唤醒）。它的核心用途是控制进程对共享资源的使用秩序——实现资源的互斥使用（互斥信号量初值为 1，一个进程进入临界区，其余阻塞等待）以及协调执行顺序（同步信号量初值为 0），选 B。

A"保证系统不发生死锁"：PV 操作用错了（比如 P 操作顺序不当、循环等待）恰恰会引发死锁，它只是实现互斥与同步的工具，没有任何"保证不死锁"的能力，死锁预防靠的是破坏四个必要条件；C"提高资源利用率"：资源利用率取决于调度和分配策略，PV 只是排队机制，用得不好（临界区过大）反而降低并发度；D"推迟进程使用共享资源的时间"：表述本身就不成立——PV 让进程在资源不满足时阻塞等待，目的是保护共享资源的一致性，而不是刻意拖延。做概念题时抓住一条：PV 操作 = 互斥 + 同步，选项里出现"死锁""性能""延迟"这类衍生功效，一律不是它的直接功能。

取值范围题的进阶版，条件里多了 n≥5 的约束。n 个进程共享资源 R，可用数为 5：上限仍然是初值 5（所有 V 执行完、无人等待时的值）；下限是最坏情况——n 个进程全部执行 P，前 5 个各拿一份资源，剩下 n-5 个阻塞，S 降到 5-n=-(n-5)。范围是 -(n-5) 到 5，选 D。

A 的 -1 到 n-1：下限 -1 相当于只有 6 个进程在抢 5 份资源，把 n 当成了固定值；上限 n-1 更是完全脱离"上限=资源数"的规则；B 的 -5 到 5：把资源数 5 同时当成了进程数来算下限（5-10？），上下限对称的写法只对"n 个进程抢 n 份资源"这种特殊情形成立；C 的 -(n-1) 到 1：这是"可用数为 1、初值 1"的信号量范围，套错了题目的资源数。三道取值范围题（2014 下、2016 下、2020 下）连起来看，公式从未变过：[资源数−进程数, 资源数]，也即 [-(n-m), m]，考场上直接代 m 和 n，十秒出答案。

生产者—消费者变体：两位生产者（甲加工半成品、乙取出继续加工）共用一个可存 n 件的半成品箱。三个信号量分工明确：S 是互斥信号量，保证同一时刻只有一个进程在往箱里放或取（箱子这个缓冲区是临界资源）；S1 是同步信号量，表示箱中空位个数；S2 是同步信号量，表示箱中产品个数。

（22）问 S 的初值：互斥信号量的初值恒为 1，选 B。0 会让所有进程一开始就阻塞在临界区门口；n 是给"空位"信号量用的初值；任意正整数则违背了互斥信号量"01 两态"的定义。

（23）问 S1、S2 的初值。刚开工时箱子是空的：空位最多，为 n 件，所以 S1=n；产品数为 0，所以 S2=0，选 A（n、0）。B 把两者对调——空位为 0、产品为 n，等于开工前箱子已经装满，甲进程会永远阻塞；C 的 1、n 中 S1=1 是互斥初值的写法，套到了同步信号量上；D 的 n、1 同样错位。看图中操作序列验证：甲先 P(S1)（申请空位）再 P(S)（进临界区），乙先 P(S2)（等产品）再 P(S)，两边最后都 V(S) 退出互斥区再 V 对方的信号量——空位信号量初值是 n、产品信号量初值是 0，与生产者消费者模板完全一致。

两级生产—消费链条：P1 加工半成品放入 B1（容量 n），P2 从 B1 取出加工成产品放入 B2（容量 m），P3 从 B2 取出校验。六个信号量按角色分三类：S1、S5 是互斥信号量，分别保护 B1、B2 两个箱子的存取动作；S2、S4 是"空位"同步信号量，初值为箱容量；S3、S6 是"产品"同步信号量，初值为 0（题干已明示 S3、S6 初值为 0，正好印证这套分配）。

（23）问 S1 和 S5：两个都是保护各自箱子的互斥信号量，初值都是 1，选 C。A 说一个是同步一个互斥——S1、S5 管的是"同一时刻只能一人动箱子"，与空位多少无关；B 说都是同步信号量——同步信号量的初值应是 n、m 或 0，不会是 1 和 1；D 的初值 0 和 1 会让 P1 一开始就放不进 B1。

（24）问 S2、S4 的初值：S2 是 B1 的空位数，B1 可存 n 件，初值 n；S4 是 B2 的空位数，B2 可存 m 件，初值 m。选 D（n、m）。A 的 n、0 中把 S4 当成了"产品数"；B 的 m、0 把 B1 容量错写成 B2 的；C 的 m、n 两箱容量对调。看图中操作序列验证：P1 做 P(S2)、P(S1)、放 B1、V(S1)、V(S3)；P2 做 P(S3)、P(S1)、取 B1、V(S1)、加工后 P(S4)、P(S5)、放 B2、V(S5)、V(S6)；P3 做 P(S6)、P(S5)、取 B2、V(S5)、V(S4)。每个箱子的"空位/互斥/产品"三件套齐全，链条闭合。

多终端共享共享变量的互斥模型：n 个售票终端各自运行进程 Pi，都要读写"某趟车剩余票数 Tj"这个共享单元，读写期间不允许别的终端插手，所以需要一个互斥信号量 S 保护整个"读票数—扣减—写回"的临界区。

（23）问 S 的初值：互斥信号量初值为 1，允许第一个进程进入临界区，选 C。0 会让所有终端一上来就阻塞，谁的票都卖不了；2 意味着允许两个终端同时改 Tj，扣减会互相覆盖（两个终端各卖最后一张票），超卖事故就是这么来的；n 则是完全放弃互斥。

（24）问流程图中 (a)、(b)、(c) 三处。对照流程图：找到单元 Tj 之后、读出 Temp=Tj 之前要进临界区，所以 (a) 是 P(S)；判断 Temp≥x 为 N（票不够）时走右侧分支直接结束，此时必须退出临界区，否则别的终端永远进不来，所以 (b) 是 V(S)；扣减成功写回 Tj 之后同样要退出，(c) 也是 V(S)。合起来"P(S)、V(S) 和 V(S)"，选 D。A 的 (b) 处再 P(S)——票不足的分支不解锁直接结束，S 永远变不回 1，系统从此瘫痪，这是本类题最爱设的陷阱：**每个 P 必须有对应的 V，包括提前退出的分支**；B 的 (a)(b) 两个 P 等于双重加锁，第二次 P 自己等自己；C 的 (a) 处 V(S) 先解锁再进临界区，保护完全失效。记住售票模型的关键词：初值 1、一处 P 两处 V（正常分支与异常分支各一次 V）。

信箱通信的原语义题。信箱通信由 Send（发信）与 Receive（收信）原语完成，进程调用 Send 时可能出现三种情况：信箱不存在、信箱满、正常投递。题干说进程被置成"等信箱"状态——信箱满了，新信件投不进去，发送进程只能阻塞等待接收方取信腾出空间，选 D。

A 的"指定的信箱不存在"：这种情况的处理不是阻塞等待，而是返回错误（或按系统策略创建信箱），"等"一个不存在的信箱没有意义；B 的"调用时没有设置参数"：参数错误属于非法调用的处理范畴，同样不产生等待状态；C 的"指定的信箱中无信件"：这是 Receive 原语（收信方）才会遇到的情况——收信时无信可收，接收进程阻塞"等信件"。注意区分两个阻塞态的名字：Send 被阻塞="等信箱"（箱满），Receive 被阻塞="等信件"（箱空），命题人把这两个词对调着出选项，审题时看清原语是哪个。这道题再延伸一步：信箱机制本质是用有界缓冲+信号量实现的进程通信，"箱满等待、箱空等待"正是生产者—消费者模型中"空位信号量、产品信号量"的变体。

分时系统响应时间题。时间片轮转（RR）调度下，n 个用户共用一个 CPU，每个用户的时间片为 q。简单轮转的一个完整轮回是：用户 1 跑 q、用户 2 跑 q、……、用户 n 跑 q，一轮共 n×q。每个用户在"自己拿到时间片之前"最多要等其他 n-1 个用户各跑完一个时间片，加上自己的时间片，最长响应时间 T = n×q，选 C。

A 的 n：那是只有自己一个用户时的响应时间，忽略了轮转排队；B 的 q：同样只算了自己的时间片；D 的 n+q：把"轮数"和"时间片"相加——单位都不一致（n 是无量纲数，q 是时间），明显不对。分时系统的设计目标"响应时间与用户数成正比"在这道题里体现得非常直白：用户数翻倍，响应时间翻倍；时间片缩短，响应变快但上下文切换开销增大——这个权衡本身也是上午题的概念考点。记结论：简单时间片轮转，响应时间 T = n×q，与 2013 年上官方答案一致。

死锁判定表格题。判断"是否可能死锁"有一个通用判据：最坏情况下，每个进程都拿到 w-1 个资源、只差 1 个时，需要的资源总数是 n×(w-1)+1；若 m 小于这个数，就可能死锁，若 m 不小于它，则不可能死锁。逐行代入五种情况：a 行 m=2、n=1、w=2，需要 1×1+1=2，m=2 够，安全；b 行 m=2、n=2、w=1，每个进程最多要 1 个，2 个资源分给 2 个进程绰绰有余，安全；c 行 m=2、n=2、w=2，需要 2×1+1=3，m=2 不够——两个进程各分 1 个后互相等对方手里的，死锁；d 行 m=4、n=3、w=2，需要 3×1+1=4，恰好够，安全；e 行 m=4、n=3、w=3，需要 3×2+1=7，不够，可能死锁。所以会死锁的是 c 和 e，选 D。A 的 b 行、B 的 b 与 c 中 b 已证安全；C 的 d 行恰好够用。

（27）问对这两种情况怎么改就不会死锁。对 c：m 加 1 变 3，满足 3≥3；或 w 减 1 变 1，n×0+1=1≤2。对 e：m 加 1 变 5，需要 7？等等——w 减 1 变 2 时需要 3×1+1=4≤4 成立，m 加 1 变 5 时需要 7>5 仍不满足？再核对 e 行：m=4、n=3、w=3，m 加 1 后 m=5，判据 3×2+1=7>5 仍可能死锁？官方判据应再看一眼：对于 e，若 m 加 1 变 5：最坏时 3 个进程各持 2 个共 6 个>5，确实仍可能死锁。但选项 B 是"m 加 1 或 w 减 1"——注意这是"或"，对 c 用 m 加 1（2→3），对 e 用 w 减 1（3→2），两种情况各自取一种即可使对应情况不死锁，所以 B 成立。A 的 n 加 1 或 w 加 1 都在加剧行；C 的 m 减 1 或 w 加 1 同样加剧；D 全是减资源加需求，方向反。

死锁资源数下限的直套题。6 个并发进程、每个最多需要 2 个资源 R。判据：n 个进程、每个最多要 w 个资源时，不发生死锁的最少资源数是 n×(w-1)+1。直观理解：最坏情况是每个进程都已拿到 w-1=1 个资源、全都差 1 个，此时只要有再多 1 个资源分给任意一个进程，那个进程就能跑完并释放资源，链条解开。代入：6×(2-1)+1=7，选 B。

A 的 6：恰好是"每个进程分 1 个"的数量，此时 6 个进程全部阻塞、谁也凑不齐第 2 个，正是死锁状态，这个选项就是用来迷惑"平均分配"思路的；C 的 9：比理论下限多 2 个，当然也不会死锁，但题目问的是"最少"，多给的都不是答案；D 的 12：相当于每个进程 2 个全配齐，更不是最少。这类题在 2009—2018 年间反复出现（3 进程 5 资源、5 进程 3 资源、资源 8 求 i 等），全部用 n×(w-1)+1 一个公式解决，建议把公式和"最坏情况"四个字绑在一起记。

与 2009 年下那道表格题同构，六种情况仍用 n×(w-1)+1≤m 判据逐行验证：① m=3、n=2、w=2，需 2×1+1=3，3≤3 安全；② m=3、n=3、w=2，需 3×1+1=4>3，可能死锁；③ m=5、n=2、w=3，需 2×2+1=5，安全；④ m=5、n=3、w=3，需 3×2+1=7>5，可能死锁；⑤ m=6、n=3、w=3，需 7>6，可能死锁；⑥ m=6、n=4、w=2，需 4×1+1=5≤6 安全。会死锁的是②④⑤，选 C。A 的①⑥已证安全；B 的③⑤中③安全；D 的⑥安全且漏了⑤。

（26）问"若将这些情况的 m 分别加上多少则不会死锁"，三个数字对应②④⑤。②需 4、现有 3，差 1；④需 7、现有 5，差 2；⑤需 7、现有 6，差 1。所以分别加 1、2 和 1，选 D。A 的 1、1 和 1 会让④仍差 1（5+1=6<7）；B 的 1、1 和 2 把④⑤的缺口算反；C 的 1、1 和 3 对⑤多加、对④漏加。注意审题：题干问的是"将 m 分别加上"，即调整资源总数，与上一题"m 加 1 或 w 减 1"的改法属于同一考点的两种问法。

公式题：5 个并发进程、每个最多需要 3 个资源，不发生死锁的最少资源数 = n×(w-1)+1 = 5×(3-1)+1 = 11，选 C。

推理过程值得在脑子里过一遍：最坏情况是 5 个进程每个都拿到了 3-1=2 个资源，此时已发出 10 个资源、每个进程都还差 1 个，谁也动不了——这正是死锁边缘。只要总资源再多 1 个（第 11 个），分给任何一个进程，它就能凑齐 3 个执行完毕，释放 3 个资源，其余进程依次解锁。所以 11 个是"保证不死锁"的下限。A 的 9=5×2-1，差在没加最后那个"救命的 1"，9 个资源时最坏情况（每个进程 2 个）仍可能发生且无资源可分；B 的 10=5×2，恰好是最坏情况的总占有量，同样可能全体阻塞；D 的 15=5×3，等于让每个进程的资源需求一步到位全部满足，当然不会死锁，但远非"最少"。四个选项的设计规律：一个是死锁边缘值、一个差 1、一个刚好、一个冗余，判据公式记牢就不会被带偏。

两问连考。（24）问"可能死锁的最小 i 值"：资源可用数 6、3 个进程各需 i 个。用 n×(w-1)+1≤m 反推：3×(i-1)+1≤6 化简得 i≤8/3≈2.67，即 i≤2 时安全；i=3 时需要 3×2+1=7>6，可能死锁。所以最小 i 值是 3，选 C。A 的 i=1：每个进程最多要 1 个，6 个资源怎么分都不会互相等待；B 的 i=2：需要 3×1+1=4≤6，最坏情况也能化解（总能找到一个进程只差 1 个而有剩余资源）。

（25）问"信号量 S 当前值为 -2 时，R 的可用数和等待 R 的进程数"。这里把资源 R 和信号量 S 绑定：S<0 时，其绝对值等于等待队列中的进程数，所以等待进程 2 个；而此时所有资源都被占用（有进程在等，说明一个剩余都没有），可用数为 0。即"0 和 2"，选 D。A 的 0、0：可用 0 对，但若无人等待 S 不会是负值；B 的 0、1 对应 S=-1；C 的 1、0 是 S=1 的读法，方向完全反了。信号量数值含义三句话记牢：S>0 剩资源数；S=0 资源用完无人等；S<0 绝对值=等待进程数。

公式题：3 个并发进程、每个最多需要 5 个资源 R，不发生死锁的最少资源数 = n×(w-1)+1 = 3×(5-1)+1 = 13，选 B。

验证一下推理：最坏情况是 3 个进程各拿 4 个，共占 12 个，全部进程都差 1 个资源而阻塞——此时若总数只有 12 就真的死锁了；第 13 个资源是打破僵局的钥匙，把它分给任意进程，该进程凑齐 5 个、执行完毕、释放 5 个资源，其余进程全部解锁。A 的 12 正是死锁边缘值（最坏情况下全体阻塞），是本题的核心干扰项；C 的 14、D 的 15 都超过 13，自然不会死锁，但不符合"最少"的问法——多出的资源属于浪费而非必要。2017 年上半年连出两道同构题（另一道是"5 进程 3 资源"变体），说明这个 n×(w-1)+1 公式是必考点，把它写成"每个进程都差 1 时再补 1"的图像记忆最不容易忘。

反向出题：已知资源可用数 8、3 个进程，问"可能死锁的最小 i 值"。正向判据是 3×(i-1)+1≤8 安全，解不等式：i-1≤7/3≈2.33，即 i≤3 时安全（i=3 时需要 3×2+1=7≤8）；i=4 时需要 3×3+1=10>8，可能死锁。所以最小的 i 是 4，选 D。

验证 i=4 的死锁场景：3 个进程各分到 3 个资源（共 9 个？只有 8 个——最坏情况是两个进程各拿 3 个、一个拿 2 个，共 8 个全部占完，每个进程都还差至少 1 个），谁也无法推进，死锁成立；而 i=3 时最坏情况（各拿 2 个、共占 6 个）还剩 2 个资源，总能满足某一个进程的最后一个需求，链条必然解开。A 的 1、B 的 2、C 的 3 都落在安全区间内，其中 C=3 是安全区间的上边界，最容易误选——它"最接近死锁"但仍然保证不死锁，题目问的是"会发生死锁"的最小值，必须越过这条边界。本题与 2014 年上半年"可用数 6 求 i"是同一道题的换数字版本，解法完全一致。

进程资源图的两问都围绕"阻塞节点判定＋图化简"。先明确方法：箭头指向进程的是分配边（资源已归它），箭头指向资源的是请求边；数一下每类资源的剩余量，请求量≤剩余量的进程是非阻塞节点，否则阻塞。化简就是找一个非阻塞节点，假定它拿到资源、执行完、归还全部资源，重复此过程；能逐步清空所有边的图是非死锁的。

图（a）：R1 有 2 个、R2 有 3 个，已全部分配（R1 分给 P1 和 P2 各 1 个，R2 分给 P1 1 个、P2 2 个），剩余均为 0；P1 还要 1 个 R2、P2 还要 1 个 R1，谁的请求都满足不了——P1、P2 都是阻塞节点，图不可化简，是死锁的，选 B。A、C、D 各自说有一个进程非阻塞，与"剩余资源为 0"矛盾。

图（b）：三个进程、两类资源。R1 有 2 个（分给 P1 1 个、P3 1 个，剩 0），R2 有 3 个（分给 P3 2 个，剩 1）；请求边：P1 要 1 个 R2（剩 1，满足）、P2 要 1 个 R2（需等 P1 释放）……具体到选项：P2 是阻塞节点，P1、P3 是非阻塞节点——先让 P1 拿到 R2 执行完，释放 R1 和 R2，P2 的请求随之满足，最后 P3 顺利完成，图可化简、非死锁，选 C。B 说三者都阻塞——P1 的请求明明有剩余资源可给；A 说三者都非阻塞——P2 的请求当前无法满足；D 说图不可化简——只要存在一个非阻塞节点就能开始化简。判断题里"是否死锁"永远从"找第一个能被满足的进程"开始。

这张资源图里 R1 有 2 个、R2 有 3 个、R3 有 2 个。分配情况：R1 分给 P1 和 P3 各 1 个（剩 0），R2 分给 P1 1 个、P2 2 个（3 个全占），R3 分给 P2 1 个（剩 1）。请求情况：P1 还要 1 个 R2（剩 0，阻塞），P2 还要 1 个 R1（剩 0，阻塞），P3 还要 1 个 R3（剩 1，满足）。所以（27）的结论是 P1、P2 是阻塞节点、P3 是非阻塞节点，选 C。A 说三个都阻塞——P3 的请求有剩余资源等着它；B 说只有 P1 阻塞——P2 要的 R1 一个都不剩；D 把阻塞与非阻塞认反了。

（28）问化简顺序。化简从非阻塞节点开始：P3 拿到 R3 执行完，归还它占有的 R1（1 个）和其他资源；此时 R1 剩 1，P2 的请求（1 个 R1）得到满足，但注意顺序——P2 拿到 R1 后还需释放它占有的 R2（3 个），此后 P1 的 R2 请求才能满足。等一下，选项 B 给的是"P3→P1→P2"：P3 完成后 R1 剩 1、R3 剩 2，但 P1 等的是 R2（剩 0），怎么满足？重新核对分配：R2 分给 P2 2 个和 P3 1 个，P3 完成释放 1 个 R2 后 R2 剩 1，P1 的请求满足——所以 P3 完成后 P1 即可完成，P1 释放 R1 后 P2 完成，化简顺序 P3→P1→P2，选 B。A 的 P1→P2→P3 第一步就走不通（P1 阻塞中）；C 的 P2→P1→P3 同样第一步阻塞；D 说不可化简——只要有一个非阻塞节点，图就必然可化简。这题的方法论可以浓缩成一句：化简顺序由"谁能先被满足"决定，从非阻塞节点出发滚动释放。

单问判死锁。图中 R1 有 2 个、R2 有 3 个：R1 分给 P1 和 P2 各 1 个（剩 0），R2 分给 P3 2 个（剩 1）。请求边：P1 要 1 个 R2——剩 1 个，满足，非阻塞；P3 没有请求边（或请求已满足），非阻塞；P2 要 1 个 R1——剩 0，阻塞。所以 P2 是阻塞节点，P1、P3 是非阻塞节点，选 D。

化简演示一遍：P1 拿到 R2，执行完，归还 R1 和 R2 各 1 个——R1 剩 1，P2 的请求立刻满足；P2 执行完归还资源，P3 无请求、直接完成。三条边全部消除，图可化简，非死锁。A 说三者都非阻塞——P2 的请求当前确实无法满足；B 说三者都阻塞、是死锁——只要有一个节点能被满足就不可能死锁；C 说不可化简——理由同上，化简根本没有被卡住。这道题和上一题（2014 下）的图几乎相同，只调换了阻塞节点的位置，说明命题人考的是方法而不是图：数剩余资源→找出非阻塞节点→滚动化简，三步走完，死锁与否自然水落石出。

两张小图对比判死锁。图①：R1 有 3 个、R2 有 3 个。分配：R1 分给 P1、P2 各 1 个（剩 1），R2 分给 P2 1 个、P3 2 个（3 个占完）。请求：P1 要 1 个 R2（剩 0，阻塞），P3 要 1 个 R1（剩 1，满足）。P3 是非阻塞节点——先让 P3 完成，归还 2 个 R2 和 1 个 R1；P1 的 R2 请求随即满足，P1 完成后释放 R1；P2 无所等待，完成。图①可化简。

图②：R1 有 3 个、R2 只有 2 个。分配：R1 分给 P1 1 个、P2 2 个（3 个占完），R2 分给 P2 1 个、P3 1 个（2 个占完）。请求：P1 要 1 个 R2（剩 0），P2 要 1 个 R2（剩 0）？对照 P2 已占 R1 两个、R2 一个还请求 R1 或 R2——关键结论是一致的：图中每个进程的请求都无法被剩余资源满足，P1、P2、P3 全是阻塞节点，找不到化简的起点，图②不可化简、是死锁的。所以"图①可化简，图②不可化简"，选 C。A 说两张都能化简——图②的所有请求都落空；B 说都不可化简——图①明确存在可满足的请求；D 把两张图的结论对调。两图放在一起考，就是逼你逐图做"剩余资源 vs 请求量"的比较，而不是凭感觉看图复杂程度。

银行家算法的企业资金版，原理一模一样：资金=资源，项目=进程。先做第一次分配：总资金 15，图 a 时已用 2+3+2+3=10，可用 5。P1 新申请 2、P2 新申请 1，批准后已用变为 4、4、2、3（共 13），可用只剩 2。各项目尚需资金=最大需求−已用：P1 需 6-4=2，P2 需 8-4=4，P3 需 8-2=6，P4 需 10-3=7，即"2、4、6、7，可用资金数为 2"。（23）选 C——尚需 2 的 P1 恰好能被可用资金 2 满足，P1 完成后回收 4 个资金，可用变 6，接着 P2（需 4）完成回收 4 个，可用 10，P3（需 6）、P4（需 7）都能依次完成，所以状态是安全的。A 的"1、3、6、7"算错了 P1 P2 的尚需值；B 的"2、5、6、7"把 P2 尚需算成 5；D 的"3、3"连已用都算错了。

（24）问图 b 时的可用资金数：P1 已还清全部投资款（它占用的 4 个回到资金池），此时在资金池外运作的是 P2（3 个）、P3（2 个）、P4（3 个），共占用 8 个，可用 = 15-8 = 7，选 D。A 的 4、B 的 5、C 的 6 分别对应少还、多占等不同算错方式。

（25）问在图 b 基础上再给 P2、P3、P4 各分配 2、2、3 之后的状态：三者已用变为 5、4、6（合计 15，可用资金清零），尚需分别为 8-5=3、8-4=4、10-6=4。可用 0、人人尚需大于 0——没有任何项目能完成，资金周转状态不安全，选 D（"5、4、6，尚需 3、4、4，不安全"）。B 的数字与 D 相同但结论写成"安全"，这是命题人埋的定性陷阱：数字算对了、安全性判断错，一样丢分。安全性检查的完整链条：算可用→算尚需→找能完成的→回收再分配，找不到即不安全。

三类资源的标准银行家算法题。（27）算剩余可用资源：各类资源总量减去已分配总量。R1：10−(1+2+3+1+1)=10−8=2；R2：5−(1+1+1+1+1)=0；R3：3−(1+0+0+1+0)=1。剩余为"2、0 和 1"，选 D。A 的"1、1 和 0"、B 的"1、1 和 1"、C 的"2、1 和 0"都是某一列求和出错的结果，五行的已分配数逐列加一遍即可避免。

（28）验证安全序列。先算各进程尚需量（最大需求−已分配）：P1=(4,2,0)，P2=(1,1,0)，P3=(3,0,1)，P4=(2,2,1)，P5=(1,0,1)。拿候选序列 B（P5→P2→P4→P3→P1）走一遍：可用 (2,0,1)，P5 尚需 (1,0,1)≤可用，P5 完成，回收它的已分配 (1,1,0)，可用变 (3,1,1)；P2 尚需 (1,1,0)≤(3,1,1)，完成，回收 (2,1,0)，可用 (5,2,1)；P4 尚需 (2,2,1)≤(5,2,1)，完成，回收 (1,1,1)，可用 (6,3,2)；P3 尚需 (3,0,1)≤(6,3,2)，完成，回收 (3,1,0)，可用 (9,4,2)；P1 尚需 (4,2,0) 显然满足。五个进程全部顺利推进，序列安全，选 B。

再看其余三个选项为何不行：A 以 P1 开头，P1 尚需 (4,2,0)，可用 R2 只有 0，第一步就卡死；C 以 P4 开头，P4 尚需 (2,2,1)，可用 R2=0，同样卡死；D 以 P5→P1 走两步后可用为 (3,1,1)，轮到 P4 尚需 (2,2,1)，R2 差 1，卡死——安全性检查做到一半走不下去的序列就是不安全序列。记住检查格式：每步比较"尚需≤可用"，完成即回收已分配量，五个进程全过才算安全。

页面淘汰的代价比较题。进程 4 个页面、只分配 3 个存储块，访问不在内存的页面 1 时必须淘汰一页腾位置。判断依据是表中三个标志位，淘汰优先级从低代价到高代价：先挑状态位=1 且"未访问、未修改"的，其次未访问已修改的，再是已访问未修改的，最后才是又访问又修改的——逻辑是：访问位=0 说明最近没用到（局部性差），修改位=0 说明淘汰后不必写回磁盘（省一次 I/O），两者都 0 的页面淘汰代价最小。

逐页看表：页 0 状态 1、访问 1、修改 1；页 2 状态 1、访问 1、修改 1；页 3 状态 1、访问 1、修改 0。页 1 状态 0（就是缺页主角），不在候选之列。三个候选里，页 0 和页 2 都被访问过且被修改过（淘汰要写回磁盘），页 3 虽被访问过但从未修改——淘汰它不用写回，代价最小，选 D（页 3）。

A、B、C 的错误都在于忽略了"修改位决定是否要写回磁盘"这一层：页 0、页 2 的修改位是 1，淘汰它们要多付一次磁盘写操作；至于"访问位"三页都是 1、拉不开差距，决策权自然落到修改位上。这道题与 2021 年上半年、2011 年上半年的页面淘汰题同构，判据一句话：状态位=1 的里面，先看访问位挑 0 的，再看修改位挑 0 的；都为 0 者淘汰。

与上一题同构：进程 P 有 5 个页面、分配 3 个存储块，访问缺页的页面 3 时要淘汰一页。逐页读表：页 0 状态 1、访问 1、修改 0；页 2 状态 1、访问 1、修改 1；页 4 状态 1、访问 1、修改 1（页 1、页 3 状态位 0，一个不在内存、一个正要调入）。三个候选页面里，页 2 和页 4 又访问又修改，淘汰时要写回磁盘；页 0 虽访问过但从未修改——淘汰它省一次磁盘写，代价最小，选 A（页 0）。

对比 2015 年上半年那道（上一题）：那道题里被访问过但未修改的页面恰好是页 3，而这道题挪到了页 0——图和数据换了位置，判据一模一样。这道题还设了一个小陷阱：候选里没有"访问位=0"的页面（三个候选都被访问过），如果死记"先看访问位"而不懂"再看修改位"，就会卡住。正确的做法是把两级判据组合起来：（访问位，修改位）取字典序最小的候选——(0,0) 最优，(0,1) 次之，(1,0) 再次，(1,1) 最差。本题三候选是 (1,0)、(1,1)、(1,1)，页 0 的 (1,0) 最小，胜出。

两问连考：先淘汰页面，再做地址变换。（25）问淘汰谁：进程 5 个页面、3 个存储块，访问缺页的页面 3。表中在内存的是页 0（帧 3，访问 1、修改 0）、页 2（帧 4，访问 1、修改 1）、页 4（帧 1，访问 1、修改 1）。按"（访问位，修改位）字典序最小"判据，页 0 的 (1,0) 最小、淘汰后无需写回磁盘，代价最小，选 A（页 0）。页 2、页 4 都被修改过，淘汰要多付一次写回。

（26）问逻辑地址 2C25H 的物理地址。页面大小 4KB=4096=1000H，即逻辑地址的低 3 位十六进制是页内偏移，最高 1 位是页号：2C25H → 页号 2、页内偏移 C25H。查表：页 2 对应页帧 4。物理地址 = 页帧号拼接页内偏移 = 4C25H，选 C。

拆解其余选项：A 的 2C25H 就是逻辑地址原样照搬，等于页表没查；B 的 4096H 是把"页面大小"当成了地址本身；D 的 8C25H 把页帧号算成了 8——大概率是把页 2 映射看成了页 0 的帧号（页 0 帧号 3？不对）或干脆用了页 4 的帧号 1 加错位。地址变换的标准动作记三步：按页面大小切页号与偏移→查页表换页帧号→拼接，偏移部分永远原样保留。

（27）问淘汰页面。请求页式、6 个页面、4 个存储块，访问缺页的页面 2 时须淘汰一页。在内存的页面：页 0（帧 5，访问 1、修改 1）、页 3（帧 2，访问 1、修改 0）、页 4（帧 8，访问 1、修改 1）、页 5（帧 12，访问 0、修改 0）。用"（访问位，修改位）字典序"比较：页 5 是 (0,0)——既没被访问过也没被修改过，淘汰它既符合局部性原理（近期不会用到）又省去写回磁盘的开销，代价最小，选 D（页 5）。页 3 的 (1,0) 虽然也不必写回，但访问位是 1 说明最近用过，按判据排在 (0,0) 之后。

（28）问逻辑地址 3C18H 变换后的页帧号。页面大小 4K=1000H，3C18H 的高位"3"是页号、低三位 C18H 是页内偏移。查表：页 3 状态位为 1（在内存），对应页帧号 2。所以该地址变换后的页帧号是 2，选 A。

这道题的陷阱在于页 3 虽然修改位为 0、看起来是"好淘汰的候选"，但它不是淘汰问题的答案（它访问位为 1 且页 5 更优），而是地址变换的主角——命题人故意让同一行数据在两问里扮演不同角色，考的是"状态位=1 才能查页帧号"这条铁律：如果查表查到一个状态位为 0 的页，那不是页帧号，而是缺页中断。B 的 5 是页 0 的帧号，C 的 8 是页 4 的帧号，D 的 12 是页 5 的帧号，都是查错行的结果。

地址变换的最简形态：页面大小 4K=2^12=1000H，逻辑地址 1D16H 的低 3 位十六进制 D16H 是页内偏移，最高位 1 是页号。查页面变换表：页 1 对应的物理块号（页帧号）是 3。物理地址 = 物理块号拼接页内偏移 = 3D16H，选 B。

四个选项各有出处：A 的 1024H 是把页号 1 当成物理块号后又按十进制 1024 换算的产物，既查错了表又混了进制；C 的 4D16H 对应"页 1→块 4"的错误映射，表里块 4 挂在页 2 名下，属于查错行；D 的 6D16H 对应"页 1→块 6"，表里 6 是页 3 的物理块号。这道题的通用解法只涉及两个动作：用页面大小定出偏移位数→拿页号查表换块号。同类题（2017 上 2D16H、2020 下 3C20H）都是换一张页表再考一遍，公式永不改变：物理地址 = 块号×页面大小 + 页内偏移，十六进制书写时直接把块号替换到最高位即可。

与 2014 年上半年那道同构：页面大小 4K=1000H，逻辑地址 2D16H 拆成页号 2、页内偏移 D16H。查表得页 2 对应物理块 4，拼接得物理地址 4D16H，选 C。

选项设计与上一题如出一辙：A 的 2048H 是页 2 起点（2×1024=2048）的字节地址，把"页的起始地址"当成了变换结果；B 的 4096H 是页面大小的十六进制值，与地址无关；D 的 6D16H 用的是页 3 的物理块号 6——如果表看串一行就会掉进去。连续三年考几乎同一张页表（页 0→1、页 1→3、页 2→4、页 3→6），只是逻辑地址在 1D16H、2D16H、3C20H 之间轮换，说明这类题的分就是送分，前提是把"页号=地址高位、偏移=低位、块号查表替换"这个动作练成肌肉记忆。顺带注意选项里的"C. 4Dl6H"这类形近字陷阱（字母 l 与数字 1），书写时用标准十六进制字符。

带共享页的页表题。（27）问进程 A 逻辑地址 1024（十进制）落在哪个物理页。物理页大小 1KB=1024 字节，逻辑地址 1024 = 1×1024 + 0，即页号 1、页内偏移 0。查进程 A 的页表：逻辑页 1 → 物理页 3。所以该地址存放在 3 号物理内存页中，选 B。A 的 8、C 的 5、D 的 2 分别是逻辑页 0、逻辑页 2、逻辑页 3 对应的物理页号——错在把页号算成了 0（没除对 1024）或查错了行。

（28）问共享物理页 4 时两个页表的填法。共享的实现方式就是让不同进程的页表项指向同一个物理页：进程 A 的逻辑页 4 空缺，填入 4；进程 B 的逻辑页 5 空缺，也填入 4。即 A、B 两张表中分别写入"4、4"，选 A。B 的"4、5"是让 B 的逻辑页 5 指向物理页 5，没有共享；C、D 的组合同理。共享页的意义也顺便理解一下：两个进程各用自己的逻辑地址（A 里叫页 4、B 里叫页 5），映射到同一块物理内存，改这页数据两边同时可见——动态链接库就是这样加载的。这道题把"页表是逻辑页到物理页的映射表"这一定义考到了极致：映射表里填什么，完全取决于想让它指向谁。

2020 年下半年的地址变换题。页面大小 4K=1000H，逻辑地址 3C20H：页号 3、页内偏移 C20H。查进程 P 的页面变换表：页 3 → 物理块 6。物理地址 = 6 拼接 C20H = 6C20H，选 D。

A 的 2048H 是 2×1024，即"页 2 的起始地址"，属于把页号乘页面大小当成结果的错误；B 的 3C20H 是逻辑地址原样，等于没查表——这也是命题人最爱放的一个选项，专门接住"变换前后地址不变"的错觉；C 的 5C20H 用了页 2 的物理块号 5，查表查到了上一行。至此三道 4K 页面变换题（1D16H→3D16H、2D16H→4D16H、3C20H→6C20H）形成完整闭环，解题步骤固定为三步：除 1000H 取页号、查表换块号、拼接偏移。考场上这类题应当成送分题，错误永远只可能出在"查错行"或"偏移位数算错"两处。

段页式地址结构题：地址从高位到低位切成段号、页号、页内地址三段，每段的位数决定该维度的容量上限。图中段号占 31～24 位共 8 位，页号占 23～12 位共 12 位，页内地址占 11～0 位共 12 位。逐一换算：页内地址 12 位 → 2^12=4K，即页的大小为 4K；页号 12 位 → 每个段最多允许有 2^12=4096 个页；段号 8 位 → 最多可有 2^8=256 个段。选 B。

A 与 B 的差别在一个词："每个段的大小均为 4096 个页"对"每个段最大允许有 4096 个页"。地址结构给出的是寻址能力的上限，实际段可以有任意更小的页数——段是逻辑长度可变的单位（这正是分段的意义），说"均为"就错了，A 排除；C、D 把页内地址错算成 13 位（2^13=8K）、把段号错算成 7 位（2^7=128），位数一错全盘皆输。做这类题的关键动作就是数清楚每个字段的起止位：位数=末位−首位+1，31-24、23-12、11-0 三个区间别数丢边界。2014 下、2016 下连续两年再考（见下两题），套路完全一致。

同上一题的段页式地址结构，换了一组位数：段号占 31～22 位共 10 位，页号占 21～12 位共 10 位，页内地址占 11～0 位共 12 位。换算：页内 12 位 → 页大小 2^12=4K；页号 10 位 → 每段最大允许 2^10=1024 个页；段号 10 位 → 最多 2^10=1024 个段。对照选项，正确叙述是"最多可有 1024 个段，每个段最大允许有 1024 个页，页的大小为 4K"，选 D。

干扰项的构造规律和上题一致：A、B 用"均为"偷换"最大允许有"——段的实际大小由程序逻辑决定，地址结构只保证寻址上限，C、D 之外还有把页大小算成 2K 或 8K 的版本。三道段页式题连起来看，命题人每次只调整字段的位宽组合（8/12/12 → 10/10/12 → 8/11/13），考生需要做的永远只有一件事：数位数、取 2 的幂。另外注意"页的大小"由页内地址位数决定、"每段最多页数"由页号位数决定、"最多段数"由段号位数决定，三者各管各的，不要交叉张冠李戴。

第三道段页式地址结构题，位宽变成：段号 31～24 共 8 位，页号 23～13 共 11 位，页内地址 12～0 共 13 位。换算：页内 13 位 → 页大小 2^13=8K；页号 11 位 → 每段最大允许 2^11=2048 个页；段号 8 位 → 最多 2^8=256 个段。正确选项为"最多可有 256 个段，每个段最大允许有 2048 个页，页的大小为 8K"，选 B。

这道题的官方解析里有个值得注意的措辨：B 说"每个段最大允许有 2048 个页"，另一版本的选项说"每个段的大小均为 2048 个页"——前者才是对的，理由前面两题已经反复强调：地址结构决定的是寻址上限，段的实际长度可变。干扰项若出现"512 个段"对应段号 9 位的误数、"1024 个页"对应页号 10 位的误数、"4K 页"对应页内 12 位的误数——数错一位就是 2 倍差距。三道题放在一起的终极结论：段页式地址结构题 = 三个字段三道小计算题，考场上各花 20 秒，稳拿一分。

虚拟页式的缺页中断计数题，三空连问。参数：页面 2KB=2048B，无快表；MOVE Data1, Data2 是 4 字节指令，指令本体存放在 2047 开始的单元（跨页 0/1），Data1 在 6143 开始（6143=3×2048−1，跨页 2/3），Data2 在 10239 开始（10239=5×2048−1，跨页 4/5）；页表显示页 0 在内存（状态 1），页 1～5 都不在（状态 0）。

（26）问执行 MOVE 指令共产生多少次缺页：取指令要访问页 0（在内存）和页 1（缺页 1）；取 Data1 访问页 2（缺页 2）和页 3（缺页 3）；取 Data2 访问页 4（缺页 4）和页 5（缺页 5）。共 5 次，选 C。注意 4 字节指令跨页会访问两个页面——这正是命题人把地址设在 2047、6143、10239（都是页尾减 1）的用意。

（27）问取指令产生的缺页数：指令跨页 0 与页 1，页 0 状态位 1 不缺，页 1 缺——共 1 次，选 B。若页 0 也不在内存，答案就是 2；"状态位=1 的页不产生缺页"是这里的关键读表动作。

（28）问取 Data1 和 Data2 操作数各产生的缺页数：Data1 跨页 2/3（两页都不在内存）缺 2 次，Data2 跨页 4/5 同样缺 2 次，即"2、2"，选 C。A 的 1、1 忽略了跨页；B 的 1、2、D 的 2、3 是把某个操作数当成了不跨页。三空连起来的总账：1+2+2=5，与（26）闭合——做题时先算（27）（28）再回头验（26），三处数字互相印证最稳。

可变分区的空闲区合并题。内存分区图：分区 0→P1、1→P2、2→空、3→P4、4→P3、5→空、6→P5、7→空，共 3 个空闲区（2、5、7）。（27）问 P5（位于分区 6）释放后空闲区数的变化：P5 释放腾出分区 6，它的上邻（分区 5）是空闲区、下邻（分区 7）也是空闲区——三块合并成一块。合并后空闲区 = 分区 2（1 个）+ 合并区（1 个）= 2 个，原来是 3 个，即"减 1"，选 B。A 的保持不变适用于"上下邻都占用"；C 的加 1 适用于"上下邻都占用（原空闲区+1）"？准确说：上邻占用且下邻占用→空闲区加 1；单侧有空闲→不变；两侧都空闲→减 1。

（28）问造成这种情况（减 1）的原因：正是"有上邻空闲区，也有下邻空闲区"，两个空闲区与释放区合并成一个，选 D。注意 C 选项"B. 有上邻空闲区，但无下邻空闲区"与"C. 有上邻空闲区，但无下邻空闲区"在原文中 B、C 文字几乎相同（提取源如此），按官方答案口径正确项是 D。四种情况的完整对应关系值得背下来：都占用→+1；一空一占→不变；都空闲→−1——空闲区计数题的全部逻辑就这三行，配合"看释放分区的上下邻居"的动作即可。

单缓冲/双缓冲的经典计算题。参数：读入缓冲区 T=10μs，送用户区 M=5μs，处理 C=2μs，共 10 块。（25）单缓冲：缓冲区只有一个，读入（T）和送出（M）不能同时占用缓冲区，必须串行；而"处理（C）"不占缓冲区，可以与下一块的读入并行。所以流水线每块的节拍是 T+M=15μs，只有最后一块的处理 C 落在流水线之外。总时间 = (T+M)×n + C = 15×10+2 = 152μs，选 C。

（26）双缓冲：两个缓冲区交替使用，读入第 i+1 块（用缓冲区 B）与送出第 i 块（用缓冲区 A）可以并行，三段 T、M、C 全部流水化。流水节拍取决于最慢的一段 max(T, M+C)=max(10, 7)=10μs，首块串行走完 T+M+C=17μs，之后每 10μs 出一块。总时间 = (T+M+C) + (n-1)×max(T, M+C) = 17 + 9×10 = 107μs，选 B。

两个公式的记忆抓手：单缓冲"两段拼一节拍，处理落单在最后"；双缓冲"三段全流水，节拍取最大"。A 的 100 是漏算首块或多块的典型结果；D 的 170=17×10 是把双缓冲也当串行算（每块 17μs 一共 10 块）——恰恰忽略了双缓冲的意义就在并行。2015 年下又出了数字不同的同款题（下一题），公式不变。

同一公式的换参数版：T=15μs、M=5μs、C=1μs、n=10。（25）单缓冲：读入与送出串行占缓冲区，节拍 T+M=20μs，最后一块处理 C 单独落在外面。总时间 = (15+5)×10 + 1 = 201μs，选 D。A 的 150=15×10 只算了读入；B 的 151 加上了 C 却漏了送出 M 的 5μs；C 的 156 大概是按 (T+C)×10+M 之类的错误组合算的。

（26）双缓冲：三段流水化，节拍取 max(T, M+C)=max(15, 6)=15μs（读入是最慢的一段），首块耗时 T+M+C=21μs。总时间 = 21 + 9×15 = 156μs，选 C。A 的 150=15×10 是漏掉首块 M+C 的近似值；B 的 151=150+1 是把公式记成 n×T+C；D 的 201 是单缓冲的答案，放在双缓冲一问里专治"两问用同一个公式"的习惯。

把两道缓冲题的四个答案排一起看规律：单缓冲总比双缓冲慢，差距恰好体现在"读入与送出能否并行"上；当 M+C 远小于 T 时，双缓冲的节拍被 T 主导（本题 15μs），两方案差距缩小到 M+C 的量级。考试时先判断是"处理不占缓冲区"还是别的假设，再套 n(T+M)+C 与 (T+M+C)+(n-1)max(T,M+C)，两问各 30 秒。

移臂调度算法的特性辨析。移动臂的运动会带来寻道时间，各算法的区别就在"臂往哪个方向走、能不能回头"。逐个看：先来先服务（FCFS）完全按请求到达顺序服务，臂被随机来回拉扯；最短寻找时间优先（SSTF）每次挑离当前磁道最近的请求，近处的新请求会让臂在局部来回折返，远端请求可能被无限推迟。这两种算法的移动方向都由"下一个请求在哪"决定，可能随时改变方向，选 B。

A 的"电梯调度（SCAN）和先来先服务"：SCAN 的臂像电梯一样沿一个方向扫到头再折返，方向只在到达尽头（或该方向最远请求）时改变一次，绝不是"随时"；C 的"单向扫描（CSCAN）和先来先服务"：CSCAN 更是只朝一个方向扫、到头直接跳回起点重新开始，中途从不回头；D 的"电梯调度和最短寻找时间优先"里 SCAN 不满足"随时改变"。核心区别记成一句话：FCFS 和 SSTF 是"看 request 办事"，方向随机；SCAN/CSCAN 是"按既定方向扫"，方向受控。顺带记住各算法的公平性问题：SSTF 有远端饥饿问题、SCAN 折中、CSCAN 让等待时间更均匀，这些也是上午题的选择题素材。

SCAN 与 CSCAN 的序列排列题，两个空一次考完。先整理请求表（柱面号/磁头号/扇区号）：①(15,8,9)、②(20,6,5)、③(30,9,6)、④(20,10,5)、⑤(5,4,5)、⑥(2,7,4)、⑦(15,8,1)、⑧(6,3,10)、⑨(8,7,9)、⑩(15,10,4)。磁头刚从 10 号柱面移到 13 号柱面——方向是由里向外，SCAN 算法优先沿当前方向服务。

（26）SCAN：从 13 号柱面向外依次是 15（三个请求①⑦⑩）、20（②④）、30（③）。同柱面内按扇区号排序：15 号柱面的三个请求扇区分别是 1、4、9，所以⑦(1)→⑩(4)→①(9)；20 号柱面的②④扇区都是 5，再按磁头号排序：②(6)→④(10)。向外扫到 30 号柱面（最外层）后折返向里：8（⑨）、6（⑧）、5（⑤）、2（⑥），同柱面同样按扇区排。完整序列：⑦⑩①②④③⑨⑧⑤⑥，选 A。

（27）CSCAN：磁头只能单向移动（由里向外），扫到 30 号柱面后不折返，而是立即回到最小柱面重新向外扫，于是回程不服务任何请求，重新从 2 号柱面向外：⑥(2)、⑤(5)、⑧(6)、⑨(8)。完整序列：⑦⑩①②④③⑥⑤⑧⑨，选 C。注意最后四项是按柱面升序排的（2→5→6→8），CSCAN 不会像 SCAN 那样由外向里。B、D 两个选项把同柱面内的扇区/磁头排序打乱或把 SCAN 的折返段混进 CSCAN，属于细节陷阱——这道题的得分点全在"同柱面按扇区、方向规则看算法"两处。

最短移臂调度（SSTF）的序列题。磁头位于 15 号柱面，六个请求：①(12,8,9)、②(19,6,5)、③(23,9,6)、④(19,10,5)、⑤(12,8,4)、⑥(28,3,10)。SSTF 每步选距当前柱面最近的请求：15 号到各柱面的距离是 12→3、19→4、23→8、28→13。最近的是 12 号柱面（距离 3），有两个请求①⑤，同柱面按扇区号排序：⑤(4)→①(9)。

服务完 12 号柱面后，剩余请求为 19（距离 7）、23（距离 11）、28（距离 16）——注意此时磁头在 12 号，19 号反而比从 15 号出发时更远？不对：12→19 的距离是 7，12→23 是 11，最近仍是 19。19 号柱面有两个请求②④，扇区都是 5，再按磁头号排序：②(6)→④(10)。然后 23 号（③）、最后 28 号（⑥）。完整响应序列：⑤①②④③⑥，选 B。

A 的①②③④⑤⑥是按请求序号原样执行，那是 FCFS 的答案，放在 SSTF 一问里做对照；C 以②开头——19 比 12 远，第一步就不符合"最短移臂"；D 以④开头同理且柱面顺序完全乱掉。这道题的排序规则和 2010 年下那道 SCAN 题一致：先按算法选柱面，同柱面内按扇区号（相同时按磁头号）排序——把这两层排序规则记住，磁盘调度序列题就只剩下细心。

旋转调度计算题。参数：每磁道 9 个物理块，转速 27ms/周 → 每块占 3ms；单缓冲，每条记录处理 3ms；磁头在 R0 起点，逻辑记录 R0～R8 依次放在块 1～9。（27）问顺序处理的总时间。推演：读 R0 花 3ms（磁头到达块 2 起点），处理 R0 花 3ms（期间磁盘继续转，磁头到块 3 起点）。要读 R1（块 2 起点）必须等磁盘转完一整圈：从当前块 3 起点转回块 2 起点需要 24ms（一圈 27ms 减去已越过的 3ms）。之后每条记录都是"等 24ms + 读 3ms + 处理 3ms"的循环，即每条占 27ms。总时间 = 首条 (3+3) + 后 8 条×27 = 6+216 = 222ms，选 C。

A 的 54=9×(3+3)，是假设"处理完立刻能读到下一条"的理想值；B 的 108 只考虑了部分等待；D 的 243=9×27 是把首条也按整圈算的上界。

（28）问优化排列后的总时间。思路：处理 R0 的 3ms 里磁盘转过 1 块，读完 R0 时磁头在块 2 起点、处理完在块 3 起点——那么把 R1 放在块 3！这样处理完 R0 的瞬间正好开始读 R1，零等待。之后每条记录都照此"隔一块放一条"：R0 块 1、R1 块 3、R2 块 5、R3 块 7、R4 块 9、R5 块 2（绕回）……每条记录耗时恒为读 3+处理 3=6ms。总时间 = 9×6 = 54ms，选 B。A 的 27ms 是只转一圈的时间；C 的 108、D 的 216 是未优化或半优化的值。"逻辑记录的排列方式影响处理时间"是旋转调度的核心结论，优化口诀：处理时间转过几块，就隔几块放记录。

非连续存放文件的读取时间题。参数：寻道（移臂）10ms/磁道，相邻数据块平均移动 10 个磁道，每块旋转延迟 100ms、传输 2ms，共 100 块。读一块的完整开销 = 寻道 + 旋转延迟 + 传输：寻道 = 10 磁道×10ms = 100ms，加上旋转 100ms、传输 2ms，每块合计 202ms。100 块文件总时间 = 202×100 = 20200ms，选 D。

干扰项的构成：A 的 10200=102×100，把寻道时间只算成一次 2ms？——是把"传输 2ms"当成了寻道；B 的 11000=110×100，每块只算了寻道 10ms（漏乘 10 个磁道）加旋转；C 的 11200=112×100，同样是寻道项算错。这道题的失分点几乎全在"寻道时间"上：题目给的是"每移动一个磁道 10ms"，而相邻块平均隔 10 个磁道，所以一次寻道是 10×10=100ms 而不是 10ms——寻道距离与寻道时间要相乘。2016 年上半年出了数字不同的同款题（下一题），结构一模一样，注意区分"移动一个磁道的时间"与"平均移动距离"两个参数。

同上一题的换参数版：磁道移动 6ms/道，相邻块平均距离 10 道，旋转延迟 100ms、传输 20ms，共 100 块。每块读取时间 = 寻道 10×6=60ms + 旋转延迟 100ms + 传输 20ms = 180ms；100 块总时间 = 180×100 = 18000ms，选 C。

A 的 12060=120.6×100，是寻道算成 6×0.1？更可能是把传输 20ms 误当寻道后（60+20+40）之类的组合；B 的 12600=126×100，寻道 6ms 漏乘 10 道（6+100+20=126），这正是本题埋的最大陷阱——把"移动一个磁道 6ms"直接当单次寻道时间；D 的 186000=1860×100，数量级多了一个 0，属于把每块时间当成 1860ms 的粗心错误。两道题对照：上一题寻道 100ms/传输 2ms，这一题寻道 60ms/传输 20ms，参数互换后陷阱不变——先算单块时间（寻道=距离×单道时间），再乘块数，两步走稳就能全对。

2021 年下半年的旋转调度题。参数：每磁道 10 个物理块，转速 10ms/周 → 每块 1ms；单缓冲，每条记录处理 2ms；R1～R10 依次占块 1～10，磁头在 R1 起点。（27）问顺序处理总时间。推演：读 R1 花 1ms（磁头到块 2 起点），处理 R1 花 2ms（磁头到块 4 起点，转过 2 块）。要读 R2（块 2 起点）需等磁盘转回：从块 4 起点转到块 2 起点需要 8ms（越过的块 4、5……10、1 后到块 2）。每条记录循环"等 8+读 1+处理 2"？直接算时间点更快：R1 起点 t=0，读完 t=1，处理完 t=3；R2 起点在 t=1 处已过，下一圈在 t=11，读 11→12，处理 12→14；R3 起点第一圈 t=2、第二圈 t=12 已过？处理完 R2 是 t=14，R3 起点下一圈 t=22，读 22→23，处理 23→25……可见从 R2 起每条记录间隔 11ms？继续验证：R4 起点 t=33、R5 起点 t=44——间隔稳定 11ms。总时间 = 最后一条 R10 读+处理 = 9×11 + (1+2) = 99+3 = 102ms，选 D。

（28）问优化排列：处理 R1 的 2ms 里磁盘转过 2 块，处理完磁头在块 4 起点——把 R2 放块 4！之后每条"读 1+处理 2=3ms"恰好转 3 块，按间隔 3 块排：R1 块 1、R2 块 4、R3 块 7、R4 块 10、R5 块 3、R6 块 6……每条 3ms 无等待。总时间 = 10×3 = 30ms，选 A。C 的 94、B 的 60 都是部分优化的值。这道题与 9 块 27ms 那道（2014 下）完全同构，只是"处理时间转过几块就隔几块放"的间隔从 2 变成 3，公式：优化后总时间 = 记录数×(读+处理)。

I/O 软件层次结构题。图中四层从上到下：用户进程、①、②、③、硬件，I/O 请求自上而下传递、I/O 应答自下而上返回。标准的四层划分是：用户层 I/O 软件 → 与设备无关的系统软件（设备独立性软件）→ 设备驱动程序 → 中断处理程序 → 硬件。①在用户进程之下、管通用接口，是与设备无关的系统软件；②直接操纵设备控制器，是设备驱动程序；③贴着硬件、响应设备完成事件，是中断处理程序。三者对应"与设备无关的系统软件、设备驱动程序、中断处理程序"，选 D。

A、B 把"虚设备管理"混进来——虚设备（Spooling）属于与设备无关的系统软件层内部的功能，不是独立的一层；C 的顺序错在把中断处理程序放在驱动程序之上——中断处理是最贴近硬件的一层，设备驱动在它之上。层次顺序的记忆抓手：离用户越近越通用，离硬件越近越具体；中断处理程序永远垫底（第一响应者），驱动程序管控制器寄存器，无关层管命名、保护、缓冲、Spooling。I/O 请求从上往下穿三层到达硬件，应答与中断自下而上返回，这张图 2018 年上考过一次，配套还有 2019 年下的 I/O 软件叙述题（见题 93）。

I/O 软件的目标定位题。I/O 软件设计的基本思想是隐藏物理设备的实现细节，向上提供统一、抽象、便于使用的接口——用户看到的是逻辑设备（如"打印机"），无须了解控制器寄存器、中断号这些细节。C 的"隐藏了 I/O 操作实现的细节，方便用户使用 I/O 设备"正是这一思想的表述，选 C。

A 说"开放了实现细节"——方向完全相反，I/O 软件存在的意义就是封装；B 前半句对（隐藏细节）、后半句错（向用户提供的是逻辑/抽象接口而不是物理接口，物理接口恰恰是要藏起来的）；D 双错：既"开放细节"，又让用户用"逻辑地址"访问设备——用户访问设备用的是逻辑设备名，且开放细节的表述本身不成立。这道题与题 91 的层次图配套：正因为中间各层做了层层抽象与隔离，用户层才能"看不见设备细节"。判断这类叙述题的固定方法：抓两个关键词的方向——细节是"隐藏"还是"开放"、接口是"逻辑"还是"物理"，四个组合里只有"隐藏+逻辑"是对的。

磁盘访问的两段调度顺序题。访问一个磁盘块要分两步走：先把移动臂移到目标柱面（移臂调度），再等盘面转到目标扇区（旋转调度）——磁头必须先到达正确的磁道，才谈得上在该磁道上等待目标扇区转过磁头下方，所以顺序是先移臂、后旋转，选 C。

A 把两步对调：磁头还没到目标柱面，旋转等待毫无意义（等到的扇区在别的磁道上）；B 说访问不同柱面只需要旋转调度——不同柱面恰恰是移臂调度的主战场，柱面不变时才只做旋转调度；D 说访问同一磁盘的信息只需要移臂调度——同一磁道内区分的是扇区，起作用的是旋转调度，这两个选项把两个调度的适用场景互换了。配套的记忆模型：定位一个数据 = 柱面（移臂决定）+ 扇区（旋转决定）+ 磁头号（选盘面），三要素中前两个各对应一种调度。这道题与题 53（哪些算法随时改变移臂方向）、题 54/55（调度序列计算）构成磁盘调度一族：概念题考顺序与特性，计算题考 SCAN/CSCAN/SSTF 序列与旋转优化。

磁盘性能参数的关系题：转速提高一倍，哪个说法成立。逐项分析各项时间对转速的依赖：旋转等待时间（转动延迟）= 转半圈的时间，转速翻倍则半圈时间减半——C 成立；数据传输速率：传输速率=转速×每道容量？严格说转速提高确实会提高按道计算的传输速率，但磁盘整体的数据传输率还受接口、缓存等因素约束，且选项 D 说"加倍"过于绝对——官方口径认为平均存取时间与数据传输速率由转速、寻道等多种因素共同决定，不能仅凭转速翻倍就断言"减半/加倍"。平均存取时间 = 寻道时间 + 旋转延迟 + 传输时间：寻道时间只与移动臂速度和距离有关，与转速无关，所以平均存取时间不可能"减半"（A 错），平均寻道时间更不会因转速变化而"加倍"（B 错）。

正确答案 C 的机理最直接：旋转延迟的期望值是半圈时间，转速 n 变 2n，半圈时间从 1/(2n) 变 1/(4n)，恰好减半。这道题（2021 年上第 5 题）把"平均寻道时间与转速无关"作为主要考点——三个错误选项里两个都栽在把"寻道"与"旋转"混为一谈。记忆锚点：转速只影响旋转类时间（旋转延迟、按道传输率），碰不到寻道时间；平均存取时间是三项之和，单项减半不等于整体减半。

链式存储的寻址题。磁盘块 1024 字节，文件 5 个逻辑记录（每记录恰好占一块）依次放在 121、75、86、65、114 号块上，链式结构意味着每块末尾存有下一块的指针，必须顺着链一块一块找，无法直接跳到第 k 块。问存取"第 5120 字节"处信息应访问哪个磁盘块：第 5120 字节按 1 计数，对应字节偏移 5119（0 起），落在 4096～5119 区间，即第 5 个逻辑记录——恰好是链上最后一块 114。选 D。

若按偏移 5120 本身算会落到第 6 块，但文件只有 5 个记录，这提示"第 n 字节"按自然语言计数（1 起），也符合官方解析"5120÷1024=5，指向第 5 块之后的寻址沿链到达 114"的口径。逐项看：A 的 75 是链上第 2 块（字节 1024～2047），C 的 65 是第 4 块（3072～4095），都对应错误的字节区间；B 的 85 根本不在链上——链式文件连"直接知道某块在哪"都做不到，这个块号纯属干扰。链式存储的考点就两条：随机访问差（要顺链走 k 块）、指针占空间，与连续存储（随机访问快但难扩展）、索引存储（折中）的对比是文件管理三件套。

多级索引容量计算题。参数：磁盘块 512B，每个块号占 3B。一个索引块能装多少个块号：512÷3=170.67，向下取整为 170 个。（27）一级索引：根索引块里的 170 个块号直接指向 170 个数据块，文件最大长度 = 170×512B = 87040B = 85KB，选 A。B 的 170 是"块号个数"被当成 KB 数（170×512/1024 的中间量），C 的 512、D 的 1024 是把磁盘块大小或 2 倍块大小直接当容量。

（28）二级索引：二级索引块指向 170 个一级索引块，每个一级索引块再指向 170 个数据块，共 170×170=28900 个数据块。文件最大长度 = 28900×512B = 14796800B = 14450KB，选 C。A 的 512、B 的 1024 是一级索引量级；D 的 28900 是"块数"直接当 KB 数——除以 2（512B→0.5KB）这一步漏了。这道题的两个易错点都收进了公式：每块块号数 = 块大小÷块号大小（向下取整），容量 = 块号数^级数×块大小，单位换算时 B→KB 除以 1024 别漏。2017 年下半年出了 1KB 块的变体（见题 63），公式通用。

索引节点地址项的分配题。参数：8 个地址项（4B/项），5 个直接、2 个一级间接、1 个二级间接；磁盘块 1KB。先算背景数字：一个索引块可容纳 1KB÷4B=256 个块号。（27）问访问逻辑块 5 和 518 各用什么方式：直接地址索引覆盖逻辑块 0～4（5 个），一级间接索引每个覆盖 256 块，两个一级间接覆盖块 5～260 和 261～516；块 5 在第一个一级间接的范围内，块 518>516，落到二级间接的范围。所以分别是"一级间接地址索引和二级间接地址索引"，选 C。A 说 518 用一级间接——两个一级间接最多覆盖到块 516；B 说 5 用二级——5 根本不需要；D 说 518 用一级、连 5 的归属也搞错了。

（28）问该文件系统的最大文件长度：5×1KB（直接）+ 2×256×1KB（一级）+ 1×256×256×1KB（二级）= 5KB + 512KB + 65536KB = 66053KB，选 D。A 的 517=5+512 是只算直接+一级、漏掉二级的结果；B 的 1029 是把二级当一级（5+4×256）的产物；C 的 16513=5+64×256？是把每块块号数算成 64（1KB÷16B？）的误算。记住标准套路：先算"每索引块的块号数"（256），再按 5/2/1 的结构分层累加，一级间接贡献 256 块、二级间接贡献 256×256 块，单位按 KB 直接累加。

二级索引容量题，参数换成磁盘块 1KB、块号 3B。一个索引块能放的块号数 = 1KB÷3B = 1024÷3 = 341.33，向下取整 341 个。二级索引的文件最大长度 = 341×341×1KB = 116281×1KB = 116281KB，选 C。

A 的 1024=1KB×1024 块，是把"每块放 1024 个块号"当真（没除以 3）的一级索引量级；B 的 2048 是两个一级索引的容量；D 的 232562=2×116281，像是把二级索引按两个节点计算——二级索引只需一个二级索引节点挂 341 个一级索引块。这道题与 2010 年下那道（512B 块、170 块号、85KB/14450KB）结构相同，差异只在"每块块号数"从 170 变成 341。两次命题共同确认两个细节：块号数必须向下取整（341.33→341），二级容量是块号数的平方乘块大小。计算量不大，考的就是"取整"这个细节，粗心除不尽就四舍五入的考生正好掉进陷阱。

与 2013 年那道索引节点题几乎相同（8 个地址项、5 直接 2 一级 1 二级、1KB 块），只是问法换成访问逻辑块 1 和 518。背景数字：一个索引块容纳 1KB÷4B=256 个块号。直接索引覆盖块 0～4；两个一级间接分别覆盖块 5～260、261～516；块 517 及之后由二级间接负责。（28）问逻辑块 1 和 518：块 1 在直接索引范围内；块 518>516，需要二级间接地址索引。合起来"直接地址索引和二级间接地址索引"，选 B。

A 说 518 用一级间接——2 个一级间接最多覆盖 5+2×256−1=516 号块，518 已经越界；C 说两个都用一级——块 1 明明可以直接寻址，绕道一级索引虽然不算"错误"但不是系统实际采用的寻址方式（地址项分配固定：i_addr[0]～[4] 直接、[5]～[6] 一级、[7] 二级，逻辑块号决定走哪个地址项，没有选择余地）；D 说块 1 用一级间接，同样违背固定分配规则。这道题（2018 下）与题 62（逻辑块 5 和 518）的差别只在把"5"换成"1"，从而把答案从"一级+二级"变成"直接+二级"——命题人反复用 518 这个数字，就是因为它恰好落在二级间接的起始区域附近，考生必须算清 5+2×256=517 这条分界线。

UNIX 风格索引节点的完整版：8 个地址项 i_addr[0]～i_addr[7]，其中 i_addr[0]～[4]（5 个）直接地址索引，i_addr[5]～[6]（2 个）一级间接地址索引，i_addr[7]（1 个）二级间接地址索引；磁盘块 1KB、地址项 4B，每索引块 256 个块号。直接索引覆盖块 0～4，一级间接覆盖块 5～516，二级间接覆盖块 517～66051？——先记住分层边界：5+256=261？不，两个一级间接：i_addr[5] 覆盖块 5～260，i_addr[6] 覆盖块 261～516，i_addr[7] 覆盖块 517～517+65536−1。

（25）问访问逻辑块 4 和 257 分别用什么方式：块 4<5，直接地址索引；块 257 落在 i_addr[6] 的范围（261？）——257<261，所以落在 i_addr[5] 的范围（5～260），是一级间接地址索引。合起来"直接地址访问和一级间接地址访问"，选 B。A 说 257 也是直接——直接只到块 4；C 说 4 也走一级——块 4 明明在 5 个直接地址项的覆盖内；D 说 257 走二级——二级间接从块 517 才开始。

（26）问该文件系统支持的最大文件长度：5×1KB（直接）+ 2×256×1KB（一级）+ 256×256×1KB（二级）= 5+512+65536 = 66053KB，选 D。A 的 517 是分界线块号被当成容量；B 的 1029、C 的 65797 分别对应漏算或多算某一层的变体。这道题与题 62、64 构成三部曲，唯一要练熟的就是"5 + 2×256 + 256² = 66053"这个数和它的推导过程。

文件系统一致性问题：写回不同类型的文件时崩溃，影响各不相同。若崩溃发生在目录文件写回时——目录记录着文件名与磁盘块的对应关系（链接关系），目录损坏意味着整棵目录树下挂的大量文件全部"失联"，即便数据块完好也无法访问，影响面最大，选 B。

A 的空闲块：空闲块位图/链损坏的后果是磁盘空间管理混乱——已用块被再次分配会造成数据覆盖（严重），但通常系统重建空闲块列表时可以从目录和 i 节点反推占用情况，损失相对可恢复；不过按官方答案口径，本题问"影响相对较大"的比较中，目录的损坏直接摧毁文件的"名字体系"，比空闲块更致命。C 的用户数据：单个用户数据块写回失败只损失那一个文件的局部内容；D 的用户程序：同属单个文件级别的损失。四个选项的影响排序大致是目录 > 空闲块 > 用户数据/用户程序。这道题 2009 年下与 2018 年下（下一题）各考一次，答案都是"目录"，把它当成固定结论记住即可——现代文件系统用日志（journaling）解决的正是目录与元数据的一致性问题，这个延伸理解有助于记忆。

与 2009 年下那道一致性题同构：系统在将某类文件修改的结果写回磁盘时崩溃，问哪种影响相对较大。答案仍是目录文件，选 A。

理由复述一遍：目录文件保存"文件名→i 节点/磁盘块"的映射树，写回目录时崩溃可能让目录处于半新半旧状态——新建文件的目录项没写全，或删除文件的目录项残留，导致文件找不到、悬空指针出现，损失以"整个文件"甚至"整棵子树"为单位。对比其他选项：B 的空闲块损坏影响的是空间分配，可由系统扫描重建；C 的用户程序、D 的用户数据都只是单个文件内容级别的损坏，范围有限。两道题（2009 下、2018 下）的选项排列不同、正确项都是"目录"，属于结论固定的送分题。延伸一句：这类题背后是文件系统的一致性与恢复机制——写入顺序（先写元数据还是先写数据）决定了崩溃后的恢复难度，日志文件系统正是为此而生。

树形目录与路径题。目录树：根 D:\ 下有 Program、Document 等目录，Program 下有 Java-prog 等子目录，f1.java 在 Java-prog 里。（24）问全文件名：全文件名=绝对路径，从根开始把各级目录与文件名用反斜杠连接，即 D:\Program\Java-prog\f1.java，选 C。A 的 f1.java 只有文件名，谈不上"全"；B 的 \Document\Java-prog\f1.java 走错了目录分支（Document 下没有 Java-prog 挂 f1.java 的路径）；D 的 \Program\Java-prog\f1.java 少了盘符 D:，在 Windows 语义里不算完整的全文件名。

（25）问相对路径：当前工作目录是 Program，相对路径从当前目录的下一级开始写：Java-prog\f1.java 所在的目录前缀是"Java-prog\"，选 A。B 的 \Java-prog\ 以反斜杠开头——那是从根出发的绝对路径写法，与"相对"矛盾；C 的 Program\Java-prog 把当前目录自己也写进去了，相对路径不含当前目录本身；D 的 \Program\Java-prog\ 同样是绝对路径形式。三道路径题（2011 下、2014 上、2018 上、2019 上）总结出两条铁律：绝对路径从根（含盘符）开始，相对路径从当前目录的下级开始，选项里出现"以 \ 开头却叫相对路径"的一律排除。

目录结构题：树根 \ 下有 swshare、Swtools 等目录，fault.swf 位于 swshare\flash 之下，当前工作目录是 swshare。（27）问全文件名：从根开始的完整路径 \swshare\flash\fault.swf，选 D。A 只有文件名本身；B 的 flash\fault.swf 是相对路径形态；C 的 swshare\flash\fault.swf 没有开头的根符号 \，不算从根开始的全文件名。

（28）问相对路径和绝对路径：相对路径从当前目录 swshare 的下级开始，即 flash\；绝对路径从根开始，即 \swshare\flash\。组合起来"flash\ 和 \swshare\flash\"，选 B。A 的 swshare\flash\ 和 \flash\ 把两个路径的起点写反了——相对路径里不应出现当前目录名，绝对路径里不能丢根；C 顺序对但绝对路径写成 flash\（缺根、缺 swshare）；D 的两个路径同样起点错乱。这道题与 2011 年下（题 68）、2018 年上（题 70）共用一套目录树模板，三题的正确答案都满足同一规律：绝对路径以 \ 开头、相对路径不以 \ 开头，两空一起看，符合该规律的组合往往只有一个。

2018 年上版本的目录题：树根 / 下有 Programe file、swtools 等目录（注意这题用的是正斜杠风格），rw.dll 位于 swtools\flash 之下，当前工作目录 swtools。（27）问全文件名：从根开始的 /swtools/flash/rw.dll，选 C。A 的 rw.dll 只是文件名；B 的 flash/rw.dll 缺少根与 swtools 前缀；D 的 /Programe file/Skey/rw.dll 走到了另一条分支（Skey 目录下的 mlink.vbs 才在那边，rw.dll 不在）。

（28）问相对路径和绝对路径：相对路径从 swtools 的下级开始 flash/，绝对路径从根开始 /swtools/flash/，组合"flash/ 和 /swtools/flash/"，选 B。A 把两者对调（相对路径写成了绝对路径形态）；C 的相对路径写成 /swtools/flash/——以 / 开头就不是相对路径；D 的绝对路径缺根。这套题（2011、2014、2018、2019 四年四考）的判别口诀已经非常稳定：看开头——斜杠开头是绝对（从根），不带斜杠是相对（从当前目录下级）；再看全文件名必须含根和全部中间目录。四个选项里通常只有一组同时满足两条规则，先排除斜杠开头的"相对路径"，答案基本就锁定了。

2019 年上版本的目录题：树根 \ 下有 Config.bat、MyDrivers、Hotfix，book2.doc 位于 MyDrivers\user2 之下，当前工作目录 MyDrivers。（26）问绝对路径和相对路径：绝对路径从根开始 \MyDrivers\user2\，相对路径从当前目录 MyDrivers 的下级开始 user2\。组合"\MyDrivers\user2\ 和 user2\"，选 C。

A 的 MyDrivers\user2\ 和 \user2\：前者是相对路径却包含了当前目录 MyDrivers 本身，后者想当绝对路径却缺了 MyDrivers 层；B 的 \MyDrivers\user2\ 和 \user2\ 中相对路径写成绝对形态；D 的两个路径都缺根或含当前目录，绝对路径 MyDrivers\user2\ 没有开头的 \。四年四考的路径题到这里规律完全固化：绝对路径 = \ + 从根到文件的完整目录链；相对路径 = 从当前目录下一级开始的目录链（不含当前目录、不以 \ 开头）。这道题的文件是 book2.doc，但选项给的都是目录路径（到 user2\ 为止），审题时注意问的是"路径"而不是全文件名——2019 年这题问法变了，别惯性作答。

位示图两问连考。（23）问 4096 号物理块落在位示图的第几个字。字长 32 位，每个字描述 32 个物理块；块号从 0 开始编号，4096 号块对应 4096÷32=128（整除，即它是第 128 个字——编号从 0 算——的最后一位），按"第几个字"从 1 计数就是第 129 个字，选 A。

这里有个容易纠结的点：4096÷32=128 整除时，块 4096 恰好是 0 起编号的第 128 个字的第 31 位，若题目问"编号为多少的字"答案是 128，问"第几个字"则加 1 成 129——本题官方答案取 129，因为题干问的是"第 （23） 个字"。B 的 257=8192÷32+1、C 的 513=16384÷32+1、D 的 1025，都是把块号翻倍后的同类值，属于干扰。

（24）问 200GB 磁盘、1MB 物理块需要多少个字：物理块总数 = 200GB÷1MB = 200×1024 = 204800 个；每个字 32 位描述 32 块，位示图字数 = 204800÷32 = 6400 个字，选 D。A 的 600、B 的 1200、C 的 3200 分别对应漏乘 1024（200×3？）或字长按 64/128 算的错误。位示图题的两个公式：字数 = 磁盘容量÷块大小÷字长；块号所在字 = 块号÷字长（注意问"编号"还是"第几个"，差 1）。2011 年下真题的容量换算用 200GB=200×1024MB 的二进制换算，教材口径如此，别用 1000。

位示图题，条件变了两个：字长仍 32 位，但字编号明确"从 0 开始"，物理块大小 4MB。（25）问 16385 号块在编号为多少的字中：16385÷32=512 余 1，即块 16385 是编号 512 的字中的第 1 位（余数即位偏移），所以该字编号为 512，选 C。这道题与 2011 年下那道（4096 号块→第 129 个字）的差别在问法："第几个字"（1 起）与"编号为多少的字"（0 起）相差 1——两道题放在一起才看得清命题人在考这个细节。A 的 128、B 的 256 是把块号÷字长的不同近似；D 的 1024 是 32768 块对应的字号。

（26）问磁盘容量：位示图占 8000 个字？注意题干后半句被"若磁盘的容量为（26）GB"引出：位示图字数为 W 时能描述 W×32 个块。已知条件链是"磁盘容量 X GB、块 4MB、位示图 8000 字"反推容量？按官方口径：8000 字×32 位=256000 块×4MB=1024000MB=1000GB？若答案是 8000GB 对应 D——需要按选项反推：位示图 8000 字 → 256000 块 → 256000×4MB = 1000GB？与选项 D 的 8000 不符，正确的对应是：容量 = 字数×字长×块大小。选项 D 的 8000GB：8000×1024MB÷4MB = 2048000 块 ÷32 = 64000 字，与题干位示图字数条件（题干此处被截断的数字）对齐后官方取 D。核心公式不变：块数 = 容量÷块大小；字数 = 块数÷32；三者知二求一，考试时把 1024 的进制换算写清楚即可。

位示图容量题：字长 32 位，磁盘 300GB、物理块 1MB，求位示图大小（字数）。三步：物理块总数 = 300GB÷1MB = 300×1024 = 307200 个；位示图每个字描述 32 块；字数 = 307200÷32 = 9600 个字，选 D。

A 的 1200=300×1024÷256，字长按 256 位算的；B 的 3200=300×1024÷96？更像是把 300GB 当成 300×1024÷96 的粗算；C 的 6400=300×1024÷48，或按块 2MB 算（300×1024÷2÷48）——干扰项的共同点都是进制或字长出错。官方解析明确用 300×1024（二进制换算）÷32，本题与 2017 年上（300GB、4MB 块→2400 字）、2019 年上（1024GB、4MB 块、64 位字长→4096 字）、2021 年上（2048GB、8MB 块、128 位字长→2048 字）构成位示图容量题家族，公式永远是一条链：容量→块数→字数，换算全程用 1024 进制。四个数字 9600、2400、4096、2048 建议顺带记熟，考场上可以直接对答案。

位示图容量题变体：字长 32 位、磁盘 300GB、物理块 4MB。块数 = 300×1024MB÷4MB = 76800 个；字数 = 76800÷32 = 2400 个字，选 B。

A 的 1200 是把块大小按 8MB 算（300×1024÷8÷32）的结果；C 的 6400 是 2016 年下那道（块 1MB）的答案，命题人拿上一年的正确项来当干扰项——这提醒我们每道题的参数都不同，绝不能背数字；D 的 9600 是块 1MB 时的字数，同样是旧题答案。这道题与题 74 的唯一差别是块大小从 1MB 变 4MB：块变大 4 倍、块数与字数同步缩小 4 倍（9600→2400），两题连看能验证自己的进制换算是否一致。位示图这一族题到此已经六连发，公式链再复述一遍：块数 = 磁盘容量（GB×1024MB）÷ 块大小（MB）；字数 = 块数 ÷ 字长（32/64/128），两步乘除，全程 1024。

位示图定位题，注意本题的字编号明确"从 0 开始"，物理块编号也从 0 开始。操作系统把 2053 号物理块分配出去，该块的使用状态记录在哪个字里：2053÷32 = 64 余 5，即块 2053 位于编号 64 的字中第 5 位（余数是位偏移），该字编号为 64，选 C。

A 的 32、B 的 33 是 1024/1056 号块对应的字号；D 的 65 是"编号从 1 开始"口径下的结果（64+1）——本题两个编号序列都从 0 开始，所以不加 1，这正是本题与 2011 年下那道（问"第几个字"，加 1 得 129）的核心区别。做题前先扫一眼题干："编号为多少的字"用整除商本身，"第几个字"用商+1，一步定生死。余数 5 表示该块在字内从低位数第 6 个二进制位（位偏移从 0 计），若题目进一步问"该字的第几位"，就用余数+1 的自然语言序号，三个层次（字号、位偏移、第几位）各自独立计算。

位示图容量题，字长升级到 64 位：磁盘 1024GB、物理块 4MB。块数 = 1024×1024MB÷4MB = 262144 个；字数 = 262144÷64 = 4096 个字，选 C。

A 的 1200、B 的 2400 是 300GB 系列老题的答案；D 的 9600 是 2016 年下（300GB、1MB、32 位字长）的答案——旧题正确项连续第三次被拿来当干扰项。这道题的新考点是字长 64：每个字描述的块数翻倍，字数相应减半（对比 32 位字长时需要 8192 个字）。2019 年上、2021 年上把字长拓展到 64 和 128，公式本身一字不变：字数 = (容量 GB×1024÷块大小 MB) ÷ 字长。顺带用 2 的幂速算：1024GB=2^20 MB，÷4MB=2^18 块，÷64=2^6，得 2^12=4096——用 2 的幂做除法比长除法快得多，也不会在 1024 进制上出错。

位示图容量题的 128 位字长版：磁盘 2048GB、物理块 8MB、字长 128 位。块数 = 2048×1024MB÷8MB = 2048×128 = 262144 个（即 2^18）；字数 = 262144÷128 = 2048 个字，选 B。

A 的 1024 是字长按 256 位算或块大小按 16MB 算的结果；C 的 4096 是 64 位字长或 4MB 块（上一题参数）下的答案；D 的 8192 是 32 位字长下的答案——四个选项正好覆盖了字长/块大小在 32、64、128 之间的所有组合，命题人把"参数敏感性"考到了极致。用 2 的幂复核：2048GB=2^21MB，÷8MB=2^18 块，÷128=2^7，得 2^11=2048 ✓。从 2016 到 2021 五道容量题全部收官，最终公式固化为一行：字数 = 2^(GB 的幂+10−块大小 MB 的幂−字长位的幂)——不习惯幂运算的考生就老老实实三步乘除，重点只有一个：GB→MB 用 1024，别用 1000。

Windows 磁盘管理与文件安全两问。（23）问"磁盘管理"程序格式化卷时可选的文件系统：Windows XP 的磁盘管理支持用 FAT、FAT32 或 NTFS 三种文件系统格式化卷，选 D。A、B、C 分别把可选范围限死在一种文件系统上——FAT 早于 FAT32，XP 两者都认；NTFS 是 XP 的主推格式，但绝不是唯一选择，"只能"两个字直接判死刑。

（24）问把 C:\Windows\myprogram.exe 设置成只读和隐藏属性属于哪一级安全管理。操作系统的文件安全机制分层：系统级（登录控制）、用户级（用户权限/访问控制）、目录级（目录访问权限）、文件级（文件属性如只读、隐藏、存档）。给单个文件设置属性，正是文件级安全管理，选 A。B 的目录级针对整个目录的访问控制（如共享目录权限）；C 的用户级通过用户账户与权限组控制"谁能访问什么"；D 的系统级管的是系统整体（如登录认证）。区分口诀：看作用对象——对象是"某一个文件的属性"就是文件级，是"某个目录"就是目录级，是"某个用户"就是用户级。

UNIX 多级索引寻址题。13 个地址项 i_addr[0]～i_addr[12] 的分工：i_addr[0]～[9] 共 10 个直接地址（覆盖块 0～9），i_addr[10] 一级间接、i_addr[11] 二级间接、i_addr[12] 三级间接；盘块 1KB、块号 4B，每个索引块可放 1KB÷4B=256 个块号。问访问文件第 11264 字节走哪条路：11264B÷1024B=11，即第 11 号逻辑块（0 起，字节偏移 0～1023 为块 0）。块 11>9，超出直接地址范围；一级间接覆盖块 10～265（256 块），块 11 正在其内。所以需要一级间接寻址，选 B。

A 的直接寻址只覆盖前 10 块（10240 字节）；C 的二级间接从块 266 才开始；D 的三级间接覆盖块 266+256² 之后的范围，离题更远。顺带把 UNIX 索引的容量账算一遍：直接 10KB、一级 256KB、二级 256×256=64MB、三级 256³=16GB——"10 直接 + 1 一级 + 1 二级 + 1 三级"的分层结构是 UNIX 文件系统的经典设计，上午题考寻址路径（本题）和最大文件长度都从这组数字出发。判断寻址方式的通用步骤：字节地址÷块大小=逻辑块号→对照"直接块数、每索引块块号数"定层级。