操作系统专题 Operating System · 考点 · 怎么考 · 真题全解
软考 · 软件设计师 ｜ 上午 6~8 分 （进程/线程 / PV操作+前趋图 / 存储管理 / 文件 / 磁盘）原题 ，附原始配图 （base64 内嵌）或等价示意图 、官方答案 与怎么做（解题动作） 。2023~2024 真题 PDF 损坏/无文字层，暂覆盖 2020下 ~ 2025上 。
⏱ 考前 10 分钟速览（点击展开/收起）
① 进程 vs 线程： 进程=
资源分配 的最小单位；线程=
CPU 调度/程序执行 的最小单位。线程
共享 进程的代码段/数据段/全局变量/打开的文件，但
各有自己的栈指针、寄存器、程序计数器(PC) 。
② 三态 + 转换： 就绪→运行（被调度）、运行→就绪（时间片到/被抢占）、运行→等待（请求资源/IO）、等待→就绪（资源到手）。
等待不能直接到运行 。
③ PV 操作： P(S)=申请(S-1，<0 则阻塞)；V(S)=释放(S+1，≤0 则唤醒)。信号量 S 是资源数，
S<0 时 |S| = 等待队列里的进程数 。
细讲 ↓
④ 前趋图 → PV（每年必考！）： 一条箭头 = 一个信号量。箭头
出发 的进程做
V(信号) ，箭头
到达 的进程做 P(信号)。
先画的边=前面的进程先 V。 细讲 ↓
⑤ 信号量取值范围： n 个进程共享 m 个资源 → S∈
[-(n−m), m] （2020下 Q27 就是它）。
细讲 ↓
⑥ 死锁 4 必要条件： 互斥、请求并保持、不可剥夺、环路等待。（四个都破坏其一即可预防）
细讲 ↓
⑦ 存储管理三兄弟： 页式（页号+页内地址，无外部碎片）/ 段式（段号+段内地址，便于共享）/
段页式（段号+页号+页内地址） 。
细讲 ↓
⑧ 页面置换： OPT(最优·理论) · FIFO(可能 Belady 异常) · LRU(最近最少使用)；改进型 CLOCK 优先淘汰
未访问、未修改 的页。
细讲 ↓
⑨ 磁盘访问时间 = 寻道 + 旋转延迟 + 传输 ；转速翻倍 →
只有旋转等待时间减半 。
细讲 ↓
⑩ 位示图： 字数 = 物理块数 ÷ 字长；物理块数 = 容量 ÷ 块大小。
细讲 ↓
⑪ 调度方式： 正在运行的进程被
强行撤下 给更高优先级 →
可剥夺（抢占） 方式。
细讲 ↓
⑫ 磁盘调度： FCFS 先来先服务 · SSTF 最短寻道优先 · SCAN 电梯（来回） · CSCAN 单方向。
细讲 ↓
⑬ 今早新背（正文原来缺）： 响应最敏感=
实时 ；临界区四原则
没有无限等待 ；不死锁最少资源=
n(k−1)+1 ；chmod r=4/w=2/x=1 → 751；FAT=
链接 ；SPOOLing=磁盘假装独占设备。
今早先看 ↓
⚡ 今早先看 · 这页原来没写、能背就能拿的 HTML 里没出现过 = 你还没看过
下面 6 块是正文以前空着 的。PV / 化简 / 页式 / 位示图 / 磁盘时间你已经在下面各节看过，今早先把这张表背完再往下翻 。细讲和原题在各节里。
背什么 一句话 细讲 特殊 OS 问「响应时间最敏感」→ 实时 。批处理无交互；分时靠时间片；嵌入式可裁剪、资源少 1.0 ↓ 临界区 4 原则 空闲让进 · 忙则等待 · 有限等待 · 让权等待。无限等待 / 忙等 都不属于 3.1c ↓ 死锁最少资源 n 个进程、每人最多要 k 个同类资源 → 保证不死锁最少 n(k−1)+1 4.1b ↓ Linux 权限 r=4 w=2 x=1，顺序所有者 / 组 / 其他 。rwx r-x --x = 751 6.3 ↓ FAT / SPOOLing FAT = 链接结构 。SPOOLing = 用磁盘假装独占设备（共享打印机） 6.3 ↓ · 7.4 ↓ 路径 绝对从根 / 起；相对从当前目录；.. = 上一级 6.2 ↓
🎯 今早只抠这 6 句。PV 填空、页式变换、磁盘「寻道+旋转+传输」已经在后面正文里，不算新的。
★ 考点与怎么考（先看这个）
操作系统这块，上午每年稳定出 6~8 分 ，全部是"概念识别 + 简单计算"。分值分布与考法如下（依据 2020下~2025上 真题统计）：
考点 近年分值 考什么 怎么考（题型动作） 前趋图 + PV 操作 ~16 用信号量控制进程同步/前趋关系 给前趋图 + 代码骨架 → 填 6 个空（P/V、哪个信号量） 磁盘管理 ~11 访问时间、旋转延迟、单缓冲区读记录的最长/最短时间 给转速/每块时间 → 算总时间；或转速翻倍选影响 进程状态 ~6 三态转换、释放资源后各进程状态 "P1 释放了扫描仪，则各进程状态为（ ）" 位示图 ~5 用位示图记录磁盘使用情况，算位数/字数 给字长/容量/块大小 → 算位示图大小 页式存储 ~4 页表、逻辑地址→物理地址、页面置换 给页表和逻辑地址 → 算物理地址；或选淘汰哪页 段页式 ~2 地址结构各字段位宽 → 段数/页数/页大小 看 32 位地址划分 → 选"最多几段、每段最多几页、页多大" 死锁 ~2 资源分配图可化简性、资源数下限、四条件 "图①和图②是否可化简" / "至少几个资源才不死锁" 文件 / 目录 ~5+3 索引节点结构、最大文件长度、树形目录路径 给直接/间接索引项数 → 算最大文件大小 线程 ~3 线程共享/独享哪些资源 选"错误/正确"的叙述 特殊操作系统 ~3 嵌入式/实时/批处理/网络 OS 特征 给场景 → 选属于哪类 OS
🎯 一句话策略 ：
OS 这 6~8 分几乎全是"认概念 + 一两个小公式" ，把下面 ①~⑦ 七节背熟即可；每年必考的前趋图 PV 填空（值 3~4 分） 只要记牢一条规则——"箭头起点 V、箭头终点 P" ——就能稳拿。
① 进程与线程 process & thread
1.0 特殊操作系统（给场景选类型，2024上 Q23）
这页原来只有地图上的一行、正文没写。考试就是对上最刺眼的那一个特征 ，别背长定义。
类型 人话 卷面一抓就能认出 批处理 作业整批交进去，中间不能交互 ，跑完才出结果 吞吐量大、无交互、平均周转 分时 时间片轮转，多用户轮流用 CPU，能打字交互 时间片、多用户、响应过得去就行 实时 必须在截止时间 内给出响应，晚了等于失败 对响应时间最敏感 ；飞控/导弹/工业控制嵌入式 裁进某个设备里，资源少、功能专用，常带实时 可裁剪、家电/汽车 ECU、ROM 里跑 网络 OS 管网上的文件/打印共享，用户知道 有多台机器 资源共享、通信 分布式 多台机器在用户眼里像一台 位置透明、统一逻辑计算机
🎯 口诀：问「响应时间最敏感 / 必须按时完成」→ 实时 。批处理没交互；分时靠时间片；嵌入式=可裁剪塞进设备；网络知道多机、分布式看成一机。
练一练 · 2024上 · Q23 特殊操作系统（空白卷 OCR）
Q23 特殊操作系统
在以下操作系统中，对响应时间最敏感的是（23）。
A. 批处理系统B. 分时系统C. 实时系统D. 网络操作系统
答案 C 。
小白版： 批处理整批扔进去、不管你等不等；分时轮流切时间片，晚几十毫秒也能忍；网络 OS 管共享。只有实时 把「晚了」当成失败——飞控晚 10ms 飞机就偏了。所以最敏感 = C 实时 。干扰项： 分时也讲「响应」，但标准是「人能接受」，不是硬截止期。
1.1 进程 = 程序 + 数据 + PCB（一个正在跑的程序）
程序是静态 的一堆指令（放在磁盘上不动）；进程是程序一次执行 的过程，是动态 的。操作系统为了管理进程，给每个进程建一个进程控制块 PCB ，里面记录 PID、状态、程序计数器、优先级、资源清单等——PCB 是进程存在的唯一标志 。
1
进程的组成 程序段（代码）+ 数据段 + PCB（进程控制块） 。
2
进程的特征 动态性（最基本）、并发性、独立性、异步性、结构性。
3
进程的三种基本状态 运行 （占着 CPU）、就绪 （万事俱备，只差 CPU）、等待/阻塞 （在等某事件，如 IO 完成）。再加"创建""终止"两态，就是常说的五态模型 。
练一练 · 2020下 · Q22 栈的应用
Q22 栈的应用
在程序的执行过程中，系统用（ ）实现嵌套调用(递归调用)函数的正确返回。
A. 队列 B. 优先队列 C. 栈 D. 散列表
答案 C（栈） 。
小白版： 函数 A 调用 B、B 又调用 C……每进一层，都要把"返回地址、参数、局部变量"记下来，等这一层执行完再按后进先出 的顺序退回上一层。这种"后进先出"正好是栈 的特性。所以系统用栈 保存活动记录（栈帧），保证能一层层正确返回。为什么别的错： 队列是先进先出（适合排队），优先队列按优先级取，散列表用于快速查找——都不符合"后进先出"的返回顺序。
1.2 进程状态转换（每年都考"释放资源后谁变谁"）
三态：运行 （占着 CPU）· 就绪 （万事俱备只差 CPU）· 等待 （在等 IO / 某资源）。合法转换只有下面 4 条，等待不能直接变运行 。
从 变成 什么时候 题干信号 ① 就绪 运行 调度程序把 CPU 分给它 获得处理机、被调度、FCFS 轮到它 ② 运行 就绪 时间片到 / 被抢占 / 释放资源后让出 CPU 时间片用完、被更高优先级抢占 ③ 运行 等待 进程自己 去申请资源或启动 IO 申请打印机、等待扫描仪、启动 IO ④ 等待 就绪 它等的资源被别人释放 了（只唤醒，还没拿到 CPU） P1 释放了×× → 等这个资源的那个进程走这一条✗ 等待 运行 不存在 。被唤醒必须先回就绪，再等调度选项里「等待直接变运行」一律排除
真题模板（2021 下 Q23）：单处理机，1 台打印机 + 1 台扫描仪，FCFS。P1 运行，P2 就绪，P3 等打印机，P4 等扫描仪。此时 P1 释放了扫描仪 ：
进程 释放前 释放后 为什么 P1（释放者） 运行 就绪 让出 CPU，自己走② P2（早就在就绪队列） 就绪 运行 FCFS，CPU 空出来轮到它，走① P3（等打印机） 等待 等待 释放的不是它要的东西，不动 P4（等扫描仪） 等待 就绪 等的资源被释放，走④；不会直接变运行
🔑 答案顺序 P1 P2 P3 P4 = 就绪、运行、等待、就绪 。释放唤醒「等这个资源的人」→ 就绪；早就排着的就绪进程 → 运行；释放者自己 → 就绪。
练一练 · 2021下 · Q23 进程状态转换
Q23 进程状态转换
在单处理机计算机系统中有 1 台打印机、1 台扫描仪，系统采用先来先服务调度算法。假设系统中有进程 P1、P2、P3、P4，其中 P1 为运行状态，P2 为就绪状态，P3 等待打印机，P4 等待扫描仪。此时，若 P1 释放了扫描仪，则进程 P1、P2、P3、P4 的状态分别为（ ）。
A. 等待、运行、等待、就绪 B. 运行、就绪、等待、就绪 C. 就绪、就绪、等待、运行 D. 就绪、运行、等待、就绪
答案 D 。
小白版（按官方答案 D）： P1 释放扫描仪后，正在等扫描仪的 P4 被唤醒、从"等待"变为"就绪" ；同时 P1 运行态结束/让出 CPU，自身转为"就绪"，调度程序按 FCFS 把 CPU 交给早就排在就绪队列里的 P2（就绪→运行） ；P3 仍在等打印机（等待）。故 P1~P4 = 就绪、运行、等待、就绪 → D。核心结论（更重要）： 进程释放资源 时，被唤醒的一定是"正在等这个资源的进程 "（等待→就绪），而不会 直接跳到运行。等待态只能先回就绪态。
1.3 线程（要记：共享什么、独享什么）
线程是进程里的"执行单元"。一个进程可以有很多线程，它们共享 进程的资源，但各自独立地被调度。
线程共享（整个进程内的线程共用） 线程独享（每个线程一份） 代码段 · 数据段 · 全局变量 · 堆 · 打开的文件 · 信号处理 栈指针 · 寄存器 · 程序计数器(PC) · 局部变量
🎯 一句话：能共享的是"进程级资源"（代码、数据、文件、全局变量）；独享的是"执行现场"（栈、寄存器、PC）。
所以"线程可共享另一个线程的栈指针 "一定是错误 说法（2020下 Q28）。
练一练 · 2020下 · Q28 线程共享/独享
Q28 线程共享/独享
在支持多线程的操作系统中，假设进程 P 创建了线程 T1、T2 和 T3，那么以下叙述中错误的是（ ）。
A. 线程 T1、T2 和 T3 可以共享进程 P 的代码B. 线程 T1、T2 可以共享进程 P 中 T3 的栈指针C. 线程 T1、T2 和 T3 可以共享进程 P 打开的文件D. 线程 T1、T2 和 T3 可以共享进程 P 的全局变量
答案 B 。
小白版： 同一进程内的线程共享进程级资源 （代码 A、打开的文件 C、全局变量 D 都对），但各自独享执行现场 ——栈指针、寄存器、程序计数器。T3 的栈指针属于 T3 私有，别的线程不能"共享"它，所以 B 错误 。口诀： 共享代码/数据/文件/全局变量；独享栈/寄存器/PC。
练一练 · 2025上 · Q24 中断（异常） 进程/中断
Q24 中断（异常） 进程/中断
下列事件中，会触发软件中断的是（ ）。
A. 电源故障 B. 按键输入 C. 除零错误 D. 定时器溢出
答案 C（除零错误） 。
小白版： 内部中断（异常） 是 CPU 执行指令时自己产生的特殊事件，比如除零、溢出、非法指令 。外部中断 来自 CPU 外部，如电源故障(A)、按键输入(B)、定时器溢出(D)。除零是程序自己算出来的错误 → 内部/软件中断 → C。记忆： CPU 自己"算错"的 = 异常/内中断；外面"通知"它的 = 外中断。
② 处理机调度 scheduling
电脑通常只有一个 CPU （单处理机）。很多进程都想用它，操作系统必须排队决定下一个把 CPU 给谁 。这个动作叫处理机调度 。
先分清两件事，别混：
问的是什么 考试关键词 调度算法 按什么规则排队（先来的？短的？优先级高的？轮流？） FCFS / SJF / 优先级 / 时间片轮转 调度方式（考点⑪） 正在跑的进程，能不能被强行赶下 CPU 可剥夺/抢占 vs 不可剥夺/非抢占
2.1 四种常见调度算法
把 CPU 想成唯一的窗口 ，进程想成排队的人 ：
算法 窗口怎么叫号 好处 坏处 FCFS 先来先服务 谁先到谁先办，后面的等 公平、实现简单 一个超长作业堵住后面所有短作业 SJF 短作业优先 估计干活时间最短的先办 平均等待时间最短 长作业可能一直排不上，饿死 优先级调度 牌子上优先级高的先办 紧急任务能插队 低优先级也可能饿死（可用动态优先级缓解） 时间片轮转 RR 每人用一小段时间（时间片），到点换下一个人 响应快，适合分时系统 时间片太短：切换开销大；太长：退化成 FCFS
💡 小白对照： 食堂窗口按到号顺序办 = FCFS；先给买一份菜的人结账 = SJF；领导插队 = 优先级；每人打 30 秒菜就换下一位 = 时间片轮转。
2.2 可剥夺 vs 不可剥夺（考点⑪，2022下 Q23）
这不是问"按什么规则排队"，而是问：已经占着 CPU 的那个进程，能不能被操作系统强行赶下去 。
正在跑的进程会怎样 什么时候才让出 CPU 题干信号 可剥夺（抢占） 可以被强行撤下 ，把 CPU 让给更高优先级的 更高优先级来了 / 时间片到了，不等它自己说完 强行、撤下、抢占、剥夺 不可剥夺（非抢占） 谁也抢不走它手里的 CPU 它自己 跑完，或自己去等 IO/资源 一直运行到结束 / 主动放弃
🎯 秒杀： 题干出现「正在运行的进程被强行撤下 ，把处理机分给优先级更高的进程」→ 一定是可剥夺（抢占）方式 。没有"强行"两个字，就别选可剥夺。
练一练 · 2022下 · Q23 调度方式（可剥夺）
Q23 调度方式（可剥夺）
在计算机系统中，若 P1 进程正在运行，操作系统强行撤下 P1 进程所占用的 CPU，让具有更高优先级的进程 P2 运行，这种调度方式称为（ ）。
A. 中断方式 B. 先进先出方式 C. 可剥夺方式 D. 不可剥夺方式
答案 C（可剥夺方式） 。
小白版： 关键词是"强行撤下 "。正在运行的进程不必自己让出，而是被操作系统强行夺走 CPU 交给更高优先级进程 → 这就是"可剥夺（抢占） 方式"。若是"等它自己跑完/自己阻塞才换人"则是"不可剥夺"。
③ 进程同步与互斥 · PV 操作 & 前趋图 semaphore
多个进程都要用同一台打印机，不能一起打，否则纸上会乱。操作系统用一个整数 S（信号量 semaphore） 当"余票"：P 操作 = 买票进场 ，V 操作 = 用完退票 。
把 S 想成空闲车位的个数 ：
操作 别名 代码（必须按这个顺序） 人话 P(S) wait / down / 申请 先 S = S − 1；若 S < 0，自己去睡觉 （阻塞，进等待队列） 先占一个车位。占完发现车位变成负数了 → 其实没位，自己去排队等 V(S) signal / up / 释放 先 S = S + 1；若 S ≤ 0，叫醒一个排队的人 （让它变就绪） 开走，腾出一个车位。如果还有人在等（S 加完仍 ≤0），喊一个人进来
💡 三个务必记住的细节： 先改 S，再判断 。不要想成"先看有没有再减"。P=申请、V=释放 。S 现在是几，代表什么：
S 的值 含义 S > 0 还有 S 个空闲资源，谁来谁用，不用等 S = 0 资源刚好用完，下一个再来申请就会被挡住 S < 0 资源不够，|S| = 正在等待队列里的进程个数 （比如 S=−3，就有 3 个人在等）
走一遍最简单的例子：一把锁 mutex，初值 S=1 （同时只准 1 个人进临界区）。
谁在干什么 S 变成 发生了什么 一开始 1 1 把锁空闲 P1 做 P(S) 0 P1 拿到锁，进临界区。S=0 不小于 0，P1 不用睡 这时 P2 也做 P(S) −1 S<0，P2 阻塞 ，进等待队列。|S|=1，正好 1 个人在等 P1 做完，做 V(S) 0 S≤0，说明有人在等 → 唤醒 P2 （P2 从等待变就绪，还没拿到 CPU） P2 被唤醒后继续跑 0 P2 进临界区。它之前的 P 已经减过了，不用再减 P2 做 V(S) 1 S=1>0，没人在等，不唤醒任何人，锁还回去
3.1 互斥的写法（一把锁）
互斥 = 同一时刻只许一个进程进"临界区"（比如写同一台打印机）。写法永远是：进门 P、出门 V，中间夹临界区 。信号量初值 = 1。
semaphore mutex = 1; // 初值 1，一把锁
进程 Pi：
P(mutex); // 进门，上锁
临界区代码… // 同一时刻只允许一个进程执行
V(mutex); // 出门，解锁
⚠️ 两个常见错： P 和 V 写反了（出门才上锁，等于没锁）；以及忘了 V（进程拿着锁不还，后面全堵死）。
3.1c 临界区管理四原则（2024上 Q24）
进临界区的规矩就这四条。卷面爱问「不属于 / 不包括 」——把假的那条叉掉。
原则 人话 1 空闲让进 没人用临界区，就让申请的人进去，别空着不给 2 忙则等待 已经有人在里面，后来的必须等，不能一起进 3 有限等待 再等也不能等到天荒地老（防饿死）。反面就是无限等待 ——四原则没有 这一条 4 让权等待 等的时候把 CPU 让出去 （去睡眠），别占着 CPU 空转死循环。也叫「放权等待」
🎯 口诀：空闲让进、忙则等待、有限等待、让权等待 。无限等待 / 忙等 / 资源等待 / 定时等待 都不在这四条里。 「忙等」= 占着 CPU 空转，违反的是让权等待 。
练一练 · 2024上 · Q24 临界区准则（空白卷 OCR 题干有噪点）
Q24 临界区 / 同步准则
在 CPU 调度中，（24）不可能的。（空白卷 OCR 把「同步机制应遵循的准则」扫成了「CPU 调度」；选项原样保留。按四原则答。）
A. 放权等待B. 资源等待C. 无限等待D. 定时等待
答案 C 。
小白版： 四原则里有「让权等待」（OCR 写成放权等待）和「有限等待」。无限等待 正好是有限等待的反面，同步机制不允许 一直等到死——所以「不可能 / 不属于」= C 。
3.1b 信号量取值范围（考点⑤，2020下 Q27）
题干典型长这样：「n 个进程共享 5 个资源，每个进程最多用 1 个。信号量 S 的取值范围是？」
先认清一件事：S 不是"现在还剩几个资源"这么简单 。S 会跟着每次 P/V 加减，可以变成负数 。负数的绝对值 = 正在排队等资源的人数。
默认假设（这道题就是这个）：每个进程一次只申请 1 个资源 ，用完再 V 还回去。所以一个人最多让 S 减 1。
最大值怎么来： 谁都还没申请，m 个资源全空闲。S 的初值就是 m，也到不了比 m 更大（没有人凭空 V）。所以 Smax = m 。
最小值怎么来（这就是 −n+m 的出处）： 最坏情况是 n 个人都来申请了，还没有任何人释放 。S 从 m 开始，被减了 n 次：
Smin = 初值 −（P 的次数）= m − n
三个写法是同一个数 ，只是括号展开：
写法 怎么变过来 n=8、m=5 时 m − n 初值减 n 次 P，最直白 5 − 8 = −3 −n + m 把 m−n 两项对调：m−n = −n+m −8 + 5 = −3 −(n − m) 提取负号：−(n−m) = −n + m −(8−5) = −3
所以「为啥能 −n+m」：不是另有一套公式，就是 m−n 把两项对调了一下。 选项里常写成 −(n−m)，跟 −n+m 完全相等。
这 n 次 P 发生之后，现场是这样的：
这 n 个人里 人数 他们的 P 之后 S 变成几 前 m 个：成功拿到资源（在用） m S 从 m 减到 0。这 m 次 P 时 S 减完都 ≥0，所以他们不用睡 后 n−m 个：没拿到，进等待队列 n−m S 从 0 继续往下减，减成 −1、−2、…、−(n−m)。每次 S<0，他们阻塞
所以最小值时：握着资源的有 m 人，排队的有 n−m 人 ，S = −(排队人数) = −(n−m)。
用 2020 下的数字走一遍（m=5 个资源，假设 n=8 个进程，谁都还没 V）：
谁做了 P S 变成 这个人怎样 一开始 5 5 个空闲 第 1 人 P 4 拿到，接着跑 第 2 人 P 3 拿到 第 3 人 P 2 拿到 第 4 人 P 1 拿到 第 5 人 P 0 拿到。资源刚好分光 第 6 人 P −1 S<0，去排队。|S|=1 人在等 第 7 人 P −2 去排队。|S|=2 第 8 人 P −3 去排队。|S|=3
8 个人都申请完：5 人在用、3 人在等。S = 5−8 = −3 。
S 不能再往下了：一共就 n 个人，每人只 P 一次，最多减 n 次。有人做 V 的话 S 只会变大，不会更小。
🎯 公式： n 个进程共享 m 个资源 → S ∈ [ m−n , m ] ，也就是 [ −n+m , m ] 或 [ −(n−m) , m ] 。[−(n−5), 5] ，选 D 。
练一练 · 2020下 · Q27 信号量取值范围
Q27 信号量取值范围
假设系统有 n (n≥5) 个进程共享资源 R，且资源 R 的可用数为 5。若采用 PV 操作，则相应的信号量 S 的取值范围应为（ ）。
A. -1~n-1 B. -5~5 C. -(n-1)~1 D. -(n-5)~5
答案 D（ -(n-5)~5 ） 。
小白版： 每个进程一次只用 1 个资源。S 初值 = 资源数 = 5 → 最大就是 5（没人凭空 V）。Smin = 5 − n = −n + 5 = −(n−5) 。三种写法同一个数。[ −(n−5), 5 ] → 选 D 。细讲（含 8 人抢 5 个资源逐步表）： ③ 信号量取值范围 ↓
3.2 前趋图 → PV 填空（考点④，★每年必考，4 分稳拿）
前趋图在说什么？ 几个进程可以同时往前赶，但有的必须排队。箭头 P1 → P2 的意思只有一句：P1 必须先全部做完，P2 才准开始 。没有箭头的两个进程（比如下面的 P2 和 P3）互不挡路，可以一起跑。
操作系统不会自己看图。要用 PV 把这张图「翻译」成每个进程门口的通行证。考试每年都是：给图 + 给一段挖了空的程序 → 选每个空填 P 还是 V、填哪个信号量 。
3.2.1 先认空在哪（卷面上最值钱的一步）
题目里每个进程大概长这样：
P2: ② ; P2执行 ; ③ ;
空出现的位置，已经告诉你该填 P 还是 V，先别急着对信号量 ：
空在哪 这个空在干什么 一定填 人话 执行前 （上例的 ②）问前面的人好了没，没好就睡觉 P(…) 进门查票 执行后 （上例的 ③）自己干完了，喊后面的人可以开始 V(…) 出门发通行证
⚠️ 把 P/V 填反是送分题最常见的错：执行前填了 V = 还没干活就喊别人开始；执行后填了 P = 干完了反而去睡觉。
3.2.2 一条箭头 = 一张专用票（初值必须 0）
为什么不能大家共用一个信号量？因为每一条「谁先谁后」都要单独管 。P1 做完要同时放行 P2 和 P3，如果只 V 一次，只能叫醒一个人，另一个会一直睡。所以：
图上有什么 代码里就有什么 几条箭头 几个信号量，名字通常叫 S1、S2、S3… 每条箭头的初值 全部 = 0 （一开始后面的人一张票都没有） 箭头尾巴（出发的人） 执行完做 V(这条边的 S) → 发出这一张票 箭头尖（到达的人） 执行前做 P(这条边的 S) → 收这一张票，没有就等
🎯 口诀就一句：造箭头的 V，接箭头的 P 。指进来几条 = 几个 P（写在执行前）；指出去几条 = 几个 V（写在执行后） 。
初值为什么是 0：后面的人一做 P，S 从 0 变成 −1，立刻阻塞。等前面的人 V，S 变成 0，才被叫醒。如果初值写成 1，后面的人第一次 P 就能通过，前趋关系作废 。
🎯 一条箭头 = 一个信号量（初值全是 0） 出发 的进程，执行完之后做 V （喊"我好了"）到达 的进程，执行之前做 P （问"前面好了没？没好我就等"）
P1
P2
P3
P4
S1
S3
S2
S4
一个前趋图 = 若干条箭头；每条箭头配一个信号量 ，初值全为 0。P2 和 P3 之间没有箭头，互不等对方。
3.2.3 考试三步走（对着上图做一遍）
第 1 步：数箭头、给每条边起名。 上图 4 条边 → S1、S2、S3、S4，初值都是 0。名字你自己编，但同一条边两端必须用同一个 S。
箭头（谁先谁后） 信号量（初值 0） 出发的人（执行完做 V） 到达的人（执行前做 P） P1 → P2 S1 P1 执行完 V(S1) P2 执行前 P(S1) P1 → P3 S3 P1 执行完 V(S3) P3 执行前 P(S3) P2 → P4 S2 P2 执行完 V(S2) P4 执行前 P(S2) P3 → P4 S4 P3 执行完 V(S4) P4 执行前 P(S4)
第 2 步：盯住「一个进程」，数它自己的入边、出边，抄到代码里。 不要一次看整张图，看一个写一个。
进程 指进来几条（执行前 P） 指出去几条（执行后 V） 代码骨架 P1 0（起点，没人挡它） 2 → V(S1) V(S3) P1执行; V(S1); V(S3);P2 1 → P(S1) 1 → V(S2) P(S1); P2执行; V(S2);P3 1 → P(S3) 1 → V(S4) P(S3); P3执行; V(S4);P4 2 → P(S2) P(S4) 0（终点，做完就结束） P(S2); P(S4); P4执行;
第 3 步：把骨架填进卷面那种 cobegin 程序。 题目通常已经写好了 S1=S2=…=0 和每个进程的「执行」那一行，你只要填空。
begin
S1=S2=S3=S4=0; // 题目会告诉你初值全是 0
cobegin // 四个进程同时往前赶，但被 P/V 卡住顺序
P1: P1执行; V(S1) V(S3); // 起点：没有 P，出门 2 张票
P2: P(S1); P2执行; V(S2); // 进门 1 张，出门 1 张
P3: P(S3); P3执行; V(S4);
P4: P(S2) P(S4); P4执行; // 两张票都收到才能干
coend
end
卷面若把 P2 写成 a; P2执行; b;，则 a=P(S1) ，b=V(S2) 。先根据「空在执行前还是后」锁定 P 还是 V，再根据「连的是哪条边」锁定 S 几。
3.2.4 用时间走一遍（看懂为什么不会抢跑）
一开始四个人都想跑，但 S 全是 0。只有 P1 门口没有 P，所以只有 P1 能立刻执行 。
时刻 谁在干什么 S1 S2 S3 S4 其他人怎样 开始 谁都还没跑 0 0 0 0 P2 做 P(S1)：0−1=−1，去睡；P3 同样睡；P4 更睡 ① P1 执行完，V(S1) V(S3) 1 0 1 0P2、P3 被叫醒（S 从 −1 变 0） ② P2、P3 可以同时 执行（图上没箭头互挡） 0 0 0 0 他们进门时各减回 0 ③ P2 做完 V(S2)；P3 做完 V(S4) 0 1 0 1 P4 的两张票都齐了 ④ P4 做 P(S2) P(S4) 后才执行 0 0 0 0 少一张票它都动不了：必须等 P2 和 P3 都做完
💡 P4 为什么要写两个 P ？因为它有两条入边，意思是「左边也要完、下边也要完」。只写一个 P，另一条边的人没做完它也会开跑。
3.2.5 对着选项怎么排（每年都是这种）
真题不会让你默写整段程序，而是一次问两个空，四个选项。做法：
步骤 做什么 ① 看这两个空分别在「执行前」还是「执行后」→ 锁定该填 P 还是 V。选项里 P/V 反了的直接划掉 ② 看空所属的那个进程：入边用哪个 S、出边用哪个 S（先在图上把边标好号，跟题目给的 S1~Sn 对应） ③ 两个空同时 对得上才选。只对了一个空的选项是干扰项
例如空在 P2 的执行前、执行后：只能是「P(等 P1 的那条) + V(给 P4 的那条)」。选项若写成 V(S1) 打头，位置就错了。
同一空里两个 V 的书写顺序一般无所谓：V(S1)V(S3) 和 V(S3)V(S1) 效果一样。以题目选项的写法为准，不要自己纠结先后。
3.2.6 容易踩的坑
坑 为什么错 P 和 V 填反 执行前必须是 P，执行后必须是 V 信号量拿错条边 P2 等的是 P1→P2 那张票，不是 P1→P3 那张。边不同，S 就不同 两条入边只写一个 P 另一条前驱没做完也会开始，前趋图被破坏 两条出边只写一个 V 只能叫醒一个后继，另一个永远等 初值当成 1 题目写明初值 0。前趋同步必须 0；互斥锁才是 1，别混
🎯 考场 30 秒流程：标边 → 看空在执行前(P)还是后(V) → 数这个进程的入边/出边对上 S → 两个空一起照合选项。
练一练 · 2021上 · Q26-28 前趋图 + PV 操作（★每年必考）
Q26-28 前趋图 + PV 操作（★每年必考）
进程 P1、P2、P3、P4、P5 和 P6 的前趋图如下所示。若用 PV 操作控制这 6 个进程开发执行的过程，需要设置 6 个信号量 S1~S6，且初值都等于零。下面的进程执行图中 a 和 b 处分别填写（26）；c 和 d 处应分别填写（27）；e 和 f 处应分别填写（28）。
P1
P2
P3
P4
P5
P6
图1 前趋图（原卷上图，边上没有 写 S1~S6）
P1执行
V(S1)
a
P2执行
b
P(S2)
P3执行
c
d
P4执行
V(S5)
e
P5执行
f
P(S6)
P6执行
（终点，无 V）
图2 进程执行图（原截图右侧把 P6 裁掉了；P6 顶上是 P(S6) ，底下没有 V）
(26) A. V(S1)和P(S2)V(S3) B. P(S1)和P(S2)V(S3)(27) A. P(S2)和P(S4) B. V(S4)和P(S3)(28) A. P(S4)V(S5)和V(S6) B. P(S4)V(S5)和P(S6)
答案 (26) D、(27) B、(28) C 。
先说清楚：P2→P4 不是 S4，是 S3。 S4 是 P3→P5。前趋图边上没写 S 号，号是对「进程执行图里已经填好的 P/V」推出来的。
箭头 信号量 怎么确定的（不是猜的） P1 → P2 S1 卷面已写：P1 执行后 V(S1)。P1 只指出去 1 条，就是这条。 P2 → P3 S2 卷面已写：P3 执行前 P(S2)。P3 只指进来 1 条，就是这条。 P2 → P4 S3 （不是 S4）P2 指出去 2 条：一条已是 S2（去 P3），另一条就只能是 S3。选项 (26)D 的 b=V(S2)V(S3) 也对得上。若标成 S4，b 就该写成 V(S2)V(S4)，选项里没有。 P3 → P5 S4 6 条边里只剩这条还没号。P3 指出去就是它，所以 c=V(S4)。 P4 → P5 S5 卷面已写：P4 执行后 V(S5)。 P5 → P6 S6 卷面已写：P6 执行前 P(S6)（原先被裁掉的那一格）。
P1
P2
P3
P4
P5
P6
S1
S2
S3 ← P2到P4
S4 ← P3到P5
S5
S6
解析用：把 S 标回边上。橙色粗线 = P2→P4 = S3 ；蓝色粗线 = P3→P5 = S4 。
规则： 箭头出发 的进程执行后做 V ；箭头到达 的进程执行前做 P 。(26) a、b 在 P2： P2 要等 P1 → a=P(S1) ；P2 做完要唤醒 P3、P4 → b=V(S2)V(S3) → 选 D 。(27) c 在 P3、d 在 P4： c 是 P3 做完、沿 P3→P5 发出的 → V(S4) ；d 是 P4 开始前、等 P2→P4 那条 → P(S3) （不是 P(S4)）→ 选 B 。(28) e、f 在 P5： P5 要等 P3(S4)、P4(S5) → e=P(S4)P(S5) ；P5 做完唤醒 P6 → f=V(S6) → 选 C 。
练一练 · 2021下 · Q24-26 前趋图 + PV 操作
Q24-26 前趋图 + PV 操作
进程 P1、P2、P3、P4、P5 和 P6 的前趋图如下所示。用 PV 操作控制这 6 个进程之间同步与互斥的程序如下，程序中的空①和空②处应分别为(24)，空③和空④处应分别为(25)，空⑤和空⑥处应分别为(26)。
P1
P2
P3
P4
P5
P6
P5→P6
图1 前趋图（边上没有 S，也没有空①②）
begin
S1,S2,S3,S4,S5,S6: semaphore;
S1:=S2:=S3:=S4:=S5:=S6:=0;
cobegin
begin P1执行; V(S1); end
begin ① ; P2执行; ② ; end
begin P(S2); P3执行; ③ ; end
begin ④ ; P4执行; V(S5); end
begin P(S4); P5执行; ⑤ ; end
begin ⑥ ; P(S6); P6执行; end
coend
end
图2 程序（空①～⑥在这里 。原卷 PDF 扫描模糊，骨架按通行解析还原：已写出的 P/V 是卷面原有的，黄框是要填的空）
(24) A. V(S1)和P(S2)P(S3) B. V(S1)和V(S2)V(S3)(25) A. V(S3)和P(S3) B. V(S4)和P(S3)(26) A. V(S6)和P(S5) B. V(S5)和P(S6)
答案 (24) D、(25) B、(26) A 。
空①②不在前趋图上，在上面那段程序里。 前趋图只告诉你谁先谁后；要填哪几个空，看 cobegin 程序：①②夹着 P2，③在 P3 后面，④在 P4 前面，⑤在 P5 后面，⑥在 P6 前面。图上也没有 S1、S2 ，号是按边从前往后编的：S1=P1→P2，S2=P2→P3，S3=P2→P4，S4=P3→P5，S5=P4→P6，S6=P5→P6。选项按这个顺序出。P1 不是注定 V(S1)，本题它只出 1 条边，那条习惯叫 S1。D 。(24) 空①、空②： ① 在 P2 执行前，要等 P1 → P(S1) ；② 在 P2 执行后，要唤醒 P3、P4 → V(S2)V(S3) → 选 D 。(25) 空③、空④： ③ 是 P3 做完发出的 → V(S4) （喊 P5）；④ 是 P4 开始前等 P2 → P(S3) → 选 B 。(26) 空⑤、空⑥： ⑤ 是 P5 做完唤醒 P6 → V(S6) ；⑥ 是 P6 开始前等 P4 → P(S5) → 选 A 。方法仍然是： 出边 V、入边 P；先数每个进程的入边和出边个数，再对号入座。
练一练 · 2022下 · Q24-26 前趋图 + PV 操作（★）
Q24-26 前趋图 + PV 操作（★）
进程 P1、P2、P3、P4、P5 和 P6 的前趋图如下所示。假设用 PV 操作控制这 6 个进程的同步与互斥的程序如下，程序中的空①和空②处应分别为（24），空③和空④应分别为（25），空⑤和空⑥应分别为（26）。
前趋图 + PV 程序（原图）
(24) A. V(S1)V(S2)和P(S2)P(S3) B. V(S1)P(S2)和V(S3)P(S4) C. V(S1)V(S2)和V(S3)V(S4) D. P(S1)P(S2)和V(S2)V(S3)(25) A. V(S3)和V(S6)V(S7) B. V(S3)和V(S6)P(S7) C. P(S3)和V(S6)V(S7) D. P(S3)和P(S6)V(S7)(26) A. V(S6)和P(S7)P(S8) B. P(S8)和P(S7)P(S8) C. P(S8)和P(S7)V(S8) D. V(S8)和P(S7)P(S8)
答案 C、C、D 。
先配信号量（8 条边=S1..S8）： S1:P1→P2｜S2:P1→P3｜S3:P2→P3｜S4:P2→P4｜S5:P3→P5｜S6:P4→P6｜S7:P4→P5｜S8:P5→P6。(24)： P1 做完唤醒 P2、P3 → ①=V(S1)V(S2) ；P2 做完唤醒 P3、P4 → ②=V(S3)V(S4) → 选 C 。(25)： P3 开始前要等 P2(S3) → ③=P(S3) ；P4 做完唤醒 P6、P5 → ④=V(S6)V(S7) → 选 C 。(26)： P5 做完唤醒 P6 → ⑤=V(S8) （只有 D 以 V(S8) 开头）→ 选 D 。万能口诀： 出边 V、入边 P；入边几个就有几个 P，出边几个就有几个 V。
④ 死锁 deadlock
两个人过独木桥：A 已经走上桥，手里还要 B 那头的通行证；B 已经站在对面，手里还要 A 这头的通行证——谁也不肯先退，谁也过不去 。这就是死锁 。
换成进程：进程 A 拿着资源 1、等资源 2；进程 B 拿着资源 2、等资源 1。互相等对方手里的东西，永远等不到。
4.1 死锁的四个必要条件（考点⑥）
四个条件同时成立 才会死锁。考试两种问法：① 四个名字是什么；② 破坏哪一个就能预防死锁（破坏任意一个 即可）。
条件 人话 想预防就这样破坏它 1 互斥 这东西同一时刻只能一个人用（打印机、扫描仪） 一般不破坏 ——打印机没法两人同时打 2 请求并保持 手里已经握着东西，又去要新的，还不放手 一次把需要的资源全部申请齐 ，不够就不开始；或者要新的之前先把手里的还掉 3 不可剥夺 别人不能强行抢走你手里的资源，只能你自己放 允许操作系统抢占 资源（把资源从阻塞进程手里拿走） 4 环路等待 A 等 B，B 等 C，C 又等 A，围成一个圈 给资源编号 ，规定必须按编号从小到大申请，圈就围不成
🔑 口诀：互斥、请求并保持、不可剥夺、环路等待 。四个都要，缺一不可；预防只要砸掉其中一个。
4.1b 死锁最少资源数（死记公式，换数字就能算）
n 个进程抢同一类 资源，每个人最多要 k 个。最坏情况：每个人都已经拿到 k−1 个，再差 1 个就能跑完。这时如果系统里还剩 0 个，就全卡住。
🎯 保证不死锁的最少资源数 = n(k−1)+1 可能 死锁。
题面数字 代入 结论 3 个进程，每人最多要 3 个 3×(3−1)+1 = 7 至少 7 个同类资源才保证不死锁；6 个就可能锁死 总量 8 个，3 个进程，每人最多要 i 个 3(i−1) ≥ 8 → i−1 ≥ 3 → i ≥ 4 每人最多要 4 个及以上才可能死锁（i=3 时 3×2=6<8，还剩 2 个，有人能凑齐）
⚠️ 这是同类资源 的下限。银行家算法那张表（最大需求 / 已分配 / Need / Work）这页不展开——上午性价比低，先把公式背熟。
练一练 · 死锁最少资源（公式换数字）
死锁资源下限
某系统有 3 个进程，每个进程最多需要 3 个同类资源。为使系统不因该类资源而发生死锁，该类资源最少应为（ ）个。
A. 6B. 7C. 8D. 9
答案 B 。
套公式： n=3，k=3 → n(k−1)+1 = 3×2+1 = 7 。人话： 3 人各拿 2 个 = 6 个，再多 1 个就能有人凑齐 3 个跑完。只有 6 个时人人差 1 个、系统空空，死锁。
4.2 资源分配图"可化简 / 不可化简"（2020下 Q23 考点）
图上有两种节点：圆圈 = 进程 ，方块 = 资源 。线的方向要看清楚：
线 方向 意思 实线 资源 → 进程 这个资源已经分配给 这个进程了（它手里握着） 虚线 进程 → 资源 这个进程正在申请 这个资源（它想要还没拿到）
判断会不会死锁，用化简法 （纸上一步步划掉）：
步骤 做什么 ① 找一个进程：它还在申请的资源，系统现在都给得起 （包括别人还回来之后够用的） ② 假设它跑完，把它占用的 + 它申请的 全部还给系统，然后把它从墙上抹掉 ③ 重复 ①②。能一路抹到图上空空如也 = 可化简 = 不死锁 卡住 剩下的人谁也拿不到足够资源，抹不动 = 不可化简 = 死锁
🎯 化简法一句话： 反复找"要的东西现在够"的进程 → 让它跑完还资源 → 抹掉。化简完长什么样： 可化简 = 进程圆圈全没了，只剩资源方块（一条线都不剩，叫「空图」）；不可化简 = 死锁那一圈还在，抹不掉。
画图约定：实线箭头 资源→进程 = 已经分给他了；虚线箭头 进程→资源 = 他还在要、没拿到。
图① 可化简： P1 手里握着 R1、没有虚线 （要的都齐了），可以从它开始抹。
① 原图
P1
P2
P3
R1
R2
P1 无虚线，先抹它
→
② 抹掉 P1
P1
P2
P3
R1
R2
R1 空闲，P2 能拿到
→
③ 抹掉 P2
P2
P3
R1
R2
R2 空闲，P3 能拿到
→
④ 化简完毕 = 空图
R1
R2
没有进程、没有线
只剩两个孤零零的资源
可化简 = 不死锁
可化简完：进程圆圈全部消失，连线全部消失 ，只剩资源方块。这就是「空图」。
图② 不可化简： P1 握着 R1 还要 R2；P3 握着 R2 还要 R1。两个人互相等，谁的虚线都满足不了，一步都抹不了。
原图（也是「化简后」——根本没动）
P1
P3
R1
R2
互相等的环
化简失败
P1 要 R2，R2 在 P3 手里
P3 要 R1，R1 在 P1 手里
谁也拿不齐 → 谁也抹不掉
图还是原样，环还在
= 不可化简 = 死锁
不可化简完：不是变成空图 ，而是卡在原图——死锁环还在，一个进程都抹不掉。
化简「完」的图长什么样 结论 可化简 进程圆圈全没了，连线全没了，只剩孤零零的资源方块（空图） 不死锁 不可化简 至少还剩一圈「你占着我要的、我占着你要的」，图几乎没变 死锁
🔑 考试只问「能不能化简完」，不会让你交化简后的图。判据就一句：能抹到空 = 可化简；抹不动还剩环 = 不可化简。 2020 下原题 资源有多份（方框里几个点 = 几份），原图在下面这一题里，做题请看原图。
练一练 · 2020下 · Q23 资源分配图是否可化简（死锁）
Q23 资源分配图是否可化简（死锁）
假设系统中有三个进程 P1、P2、P3，两种资源 R1、R2。如果进程资源图如图①和图②所示，那么（ ）。
读图：方框里几个点 = 该类资源一共几份（空心 = 还空闲）；绿实线 资源→进程 = 已分配；红虚线 进程→资源 = 正在申请（一条箭头 = 一份）
图①
P1
P2
P3
R1（共 3 份）
R2（共 3 份）
P1 无虚线（要的都齐了）→ 可先抹
图②
P1
P2
P3
R1（共 3 份）
R2（共 2 份）
三个都有虚线，空闲资源 = 0 → 一步都抹不了
2020 下原题进程资源图（按官方解析还原：图① R1 剩 1 份空闲；图② 两类资源都分光了）
A. 图①和图②都可化简 B. 图①和图②都不可化简 C. 图①可化简，图②不可化简 D. 图①不可化简，图②可化简
答案 C 。
先数图（一条箭头 = 一份）：
R1 已分 / 剩余 R2 已分 / 剩余 各进程手里有什么 还在申请 现在谁能跑 图① 2 / 1 （共 3） 3 / 0（共 3） P1: R1+R2 P1 无 P1 能 （没有虚线）图② 3 / 0（共 3） 2 / 0（共 2） P1: R1 P1 要 1 个 R2 三个都不能
图① 化简： P1 要的都齐了 → 跑完，还回 1 个 R1 + 1 个 R2。此时 R1 空闲变成 1+1=2 ，R2 空闲变成 0+1=1 。可化简 。图② 化简： R1、R2 剩余都是 0，三个进程各自还在要自己缺的那一份，谁也拿不到 → 一步都抹不掉 = 不可化简（死锁） 。口诀： 先找「没有虚线 / 申请能被空闲资源满足」的进程开刀；三个都阻塞 = 死锁。
⑤ 存储管理 memory management
程序里写的地址叫逻辑地址 （程序员眼里的"第几号房间"）。真正插在内存条上的位置叫物理地址 。操作系统要把逻辑地址翻译 成物理地址，常见三种切法：
方式 怎么切地址 像什么 优点 缺点 页式 页号 + 页内地址 把内存切成同样大小 的格子（页），程序也按同样大小切开 无外部碎片 ，利用率高有内部碎片（最后一页可能装不满）；不按逻辑模块划分，共享不方便 段式 段号 + 段内地址 按程序自己的逻辑切开：代码段、数据段、栈段，每段长短可以不一样 便于共享、保护 ，按逻辑划分 有外部碎片 （段之间缝太大又装不下下一段） 段页式 段号 + 页号 + 页内地址 先按逻辑分段，每段里再分页 两者优点兼得 地址变换多查一次表，开销大
💡 两种碎片别混： 内部碎片 ：格子已经分给你了，但你没用满（页式会有，因为页大小固定）。外部碎片 ：内存里东一块西一块的空闲区，每一块都太小，拼起来够但连不成一整段（段式会有）。页式无外碎、段式有外碎、段页式两边讨好但变换慢。
5.1 页式地址变换（2020下 Q24 考点）
页式的翻译只有一招：高位的页号拿去查页表，换成块号；低位的页内地址原样照抄。
逻辑地址：3C20H
3H
页号
C20H
页内地址（12位=4K）
查页表
页号3 → 块号6
物理地址：6C20H
6H
块号
C20H
页内地址不变
口诀：页号换成块号，页内地址照抄
页式地址变换：把逻辑地址高位（页号）查表换成物理块号，低位（页内地址）原样保留
🎯 两步算： 页大小 定"页内地址占几位"：页大小 4K=2¹² → 低 12 位 是页内地址（十六进制就是低 3 位，因为 4 位二进制=1 位十六进制，12 位=3 个十六进制数字）。高位=页号 ，查页表得块号 ，把高位换掉、低位不动 → 物理地址。
步骤 对 3C20H、页大小 4KB 做什么 拆地址 4KB=2¹² → 低 12 位 / 低 3 个十六进制位是页内地址：C20H ；高位 3H 是页号 查页表 题干给：页号 3 对应块号 6 拼回去 块号 6 + 页内地址 C20H → 物理地址 6C20H
🔑 口诀：页号换成块号，页内地址照抄。 千万别把低位也拿去查表。
练一练 · 2020下 · Q24 页式地址变换
Q24 页式地址变换
假设计算机系统的页面大小为 4K，进程 P 的页面变换表如下表所示。若 P 要访问的逻辑地址为十六进制 3C20H，那么该逻辑地址经过地址变换后，其物理地址应为（ ）。
A. 2048H B. 3C20H C. 5C20H D. 6C20H
答案 D（6C20H） 。
小白版： 页大小 4K = 2¹²，所以逻辑地址低 12 位 是"页内地址"（十六进制低 3 位 = C20H）。剩下的高位就是"页号"：3C20H 的高位是 3 。查页表，页号 3 对应的物理块号是 6 。把高位 3 换成 6、页内地址 C20H 原样保留 → 物理地址 6C20H 。口诀： 逻辑地址 = 页号|页内地址，物理地址 = 块号|页内地址（页内地址不变）。
5.2 段页式地址结构（考点⑦ 的计算题，2022下 Q27）
题干会画一条 32 位地址，上面标着「这一段是段号、这一段是页号、这一段是页内偏移」。你数每一段有几位 ，套 2ⁿ 就行。
字段 公式 人话 段数（最多几段） 2^(段号位数) 段号有 10 位 → 2¹⁰ = 1024 段 每段最多页数 2^(页号位数) 页号有 10 位 → 2¹⁰ = 1024 页/段 页大小 2^(页内地址位数) 页内地址 12 位 → 2¹² = 4096B = 4KB
🎯 2022下：段号 31~22（10 位→1024 段）｜页号 21~12（10 位→1024 页）｜页内地址 11~0（12 位→4K）→ 答案 D 。10 位。漏掉 "+1" 会少算 1 位，整道题全错。
练一练 · 2022下 · Q27 段页式地址结构
Q27 段页式地址结构
假设段页式存储管理系统中的地址结构如下图所示，则系统（ ）。
段页式地址结构（原图）：段号 31~22｜页号 21~12｜页内地址 11~0
A. 最多可有 512 个段，每个段的大小均为 2048 个页，页的大小为 8KB. 最多可有 512 个段，每个段最大允许有 2048 个页，页的大小为 8KC. 最多可有 1024 个段，每个段的大小均为 1024 个页，页的大小为 4KD. 最多可有 1024 个段，每个段最大允许有 1024 个页，页的大小为 4K
答案 D 。
小白版（数位宽）： 段号占 31~22 共 10 位 → 最多 2¹⁰ = 1024 个段 ；页号占 21~12 共 10 位 → 每段最多 2¹⁰ = 1024 个页 ；页内地址占 11~0 共 12 位 → 页大小 2¹² = 4K 。注意措辞： "最多可有 1024 个段、每段最大允许 1024 个页"（是上限，不是每段都一样大）→ D。
练一练 · 2025上 · Q16 分页管理 · 地址结构 分页
Q16 分页管理 · 地址结构 分页
在分页管理系统中，逻辑地址由页面编号和偏移值构成。如下所示的逻辑地址表示，（ ）。
逻辑地址结构（原图）：page number 31~12｜offset 11~0
A. 页面大小为 2K，每个页面最大为 8M B. 页面大小为 4K，每个页面最大为 1M C. 页面大小为 8K，每个页面最大为 2M D. 页面大小为 1K，每个页面最大为 16M
答案 B 。
小白版： offset 占 11~0 共 12 位 → 页大小 = 2¹² = 4K 。page number 占 31~12 共 20 位 → 一个进程最多 2²⁰ = 1M 个页 → "每个页面最大为 1M"（即页表最多 1M 项）。选 B 。注意： "每个页面"这里指页表项数量的上限（1M 页）。
5.3 页面置换算法（考点⑧，2021上 Q25）
内存格子有限，新页要进来就得踢掉一页 。踢谁？四种算法：
算法 淘汰谁 备注 OPT 最优淘汰"以后最久不会被用到"的 要预知未来，理论最优，无法实现 （只当标准答案的参照） FIFO 先进先出淘汰最早进来 的（不管它刚用过没有） 可能出现 Belady 异常 ：内存块变多了，缺页反而更多。只有 FIFO 会有这个怪现象 LRU 最近最少使用淘汰最久没被访问 的 性能接近 OPT，实现要记每个页的访问时间 改进型 CLOCK 优先淘汰 未访问 & 未修改 的页 每页有两个标记：访问位 A、修改位 M。改过的页踢出去还要写回磁盘，尽量不踢
改进型 CLOCK 按"踢出去划不划算"排优先级，考试就考这一张表：
优先级（先找这个） 访问位 A 修改位 M 含义 为什么先/后踢 ① 最先淘汰 0 0 好久没碰，也没改过 扔掉最不心疼，也不用写磁盘 ② 0 1 好久没碰，但改过 要写回磁盘，稍微贵一点 ③ 1 0 最近用过，没改过 可能马上还要用，先留着 ④ 最后才淘汰 1 1 最近用过，还改过 又热又脏，最不该踢
🔑 2021上 Q25：内存 3 页分别是 页0(A=1,M=0)、页2(A=1,M=1)、页4(A=1,M=1)。没有 (0,0) 也没有 (0,1)，剩下 ③ 和 ④ 里选 ③ → 淘汰页0 。又冷又干净 的，最后才踢又热又脏 的。
练一练 · 2021上 · Q25 页面置换（改进型 CLOCK）
Q25 页面置换（改进型 CLOCK）
进程 P 有 5 个页面，页号为 0-4，页面变换表及状态位、访问位和修改位的含义如图所示。若系统给进程 P 分配了 3 个存储块，当访问的页面 3 不在内存时，应该淘汰表中页号为（ ）的页面。
页表与状态位/访问位/修改位含义（原图）
A. 0 B. 1 C. 2 D. 4
答案 A（页 0） 。
读表： 状态位=1 的才在内存里：页 0(访1改0)、页 2(访1改1)、页 4(访1改1)——正好占了 3 个块。页 1、3 不在内存。淘汰谁： 改进型 CLOCK 优先淘汰"未访问、未修改 "的页（这样不用写回磁盘）。现在内存三页都被访问过（访问位都是1），于是按 (访问1,修改0) 找 → 只有页 0 是"访问过但没改过" → 淘汰 页 0 。优先级： (0,0)→(0,1)→(1,0)→(1,1)。
5.4 位示图（考点⑩，2021上 Q24）
磁盘切成很多物理块 。哪一块空着、哪一块被占了，用一张位示图 记账：1 个 bit 对应 1 个块 ，通常 0=空闲、1=已分配。
考试几乎只问「这张图表要占几个字」：
步骤 公式 2021上 Q24 代入 ① 先算有多少块 物理块数 = 磁盘容量 ÷ 块大小 2048GB ÷ 8MB。先统一单位：2048GB=2048×1024 MB，再 ÷8 → 262144 块 ② 再算占多少字 字数 = 物理块数 ÷ 字长（bit） 字长 128 位，一"字"能记 128 个块 → 262144 ÷ 128 = 2048 字 ，答案 B
🎯 公式： 位示图字数 = (容量 ÷ 块大小) ÷ 字长。除不尽就向上取整 （多出来那几块也要占一个字）。
练一练 · 2021上 · Q24 位示图大小
Q24 位示图大小
若计算机系统的字长为 128 位，磁盘的容量为 2048GB，物理块的大小为 8MB，假设文件管理系统采用位示图(bitmap)法记录该计算机系统磁盘的使用情况，那么位示图的大小需要（ ）个字。
A. 1024 B. 2048 C. 4096 D. 8192
答案 B（2048 字） 。
小白版： 位示图用一个 bit 管一个物理块。先算有多少块：2048GB ÷ 8MB = 262144 块，就需要 262144 个 bit。一个字长 128 位，所以需要 262144 ÷ 128 = 2048 个字。注意单位： 2048GB/8MB 时 GB 与 MB 约掉，2048×1024/8 = 262144。
⑥ 文件管理 file system
文件在磁盘上怎么放？常见三种物理结构 ：
结构 做法 特点 连续结构 文件占用连续的块 顺序/随机读都快；难扩展、有外部碎片 链接结构 每块存"下一块"的指针。FAT = 这种 无碎片、易扩展；只能顺序访问 索引结构 用索引节点(inode) 列出文件所有块的地址 随机访问快；索引开销大
6.1 索引节点的直接/间接索引（2020下 Q25-26 考点）
🎯 算最大文件长度（画个加法）： B/a 个地址项。直接地址 ：直接指向数据块 → 贡献 1 块/项；一级间接 ：指向一个索引块，索引块里再放 B/a 个数据块地址 → 贡献 B/a 块/项；二级间接 ：索引块的索引 → 贡献 (B/a)² 块/项。最大长度 = （直接项数×1 + 一级间接项数×(B/a) + 二级间接项数×(B/a)² ）× B 。2020下：块 1KB、地址项 4B → 每块 256 项。iaddr[0..4] 直接（5 块）、iaddr[5..6] 一级间接（2×256 块）、iaddr[7] 二级间接（256² 块）→ 总块数=5+512+65536=66053 块 → ×1KB = 66053 KB ，答案 D。逻辑块号 4 走直接、5 走一级间接 → 答案 B。
练一练 · 2020下 · Q25-26 文件索引结构（直接/间接索引）
Q25-26 文件索引结构（直接/间接索引）
某文件系统采用索引节点管理，磁盘索引块和磁盘数据块大小均为 1KB，每个文件索引节点有 8 个地址项 iaddr[0]~iaddr[7]，每个地址项大小为 4 字节，其中 iaddr[0]~iaddr[4] 采用直接地址索引，iaddr[5] 和 iaddr[6] 采用一级间接地址索引，iaddr[7] 采用二级间接地址索引。若用户要访问文件 userA 中逻辑块号为 4 和 5 的信息，则系统应分别采用（ ），该文件系统可表示的单个文件最大长度是（ ）KB。
(25) A. 直接地址访问和直接地址访问 B. 直接地址访问和一级间接地址访问(26) A. 517 B. 1029 C. 65797 D. 66053
答案 B、D 。
第一空（逻辑块号 4 和 5）： 直接地址项 iaddr[0..4] 负责逻辑块 0~4，一级间接 iaddr[5] 负责逻辑块 5 起。所以块 4 → 直接 ，块 5 → 一级间接 → 选 B 。第二空（最大文件长度）： 每个索引块能放 1KB ÷ 4B = 256 个地址项。66053 块，每块 1KB → 66053 KB → 选 D 。
6.2 树形目录（路径、当前目录）
树形目录 = 文件夹套文件夹。找文件就两条路：
从哪起 写法 绝对路径 永远从根 /（有的题写成 \） /usr/xisi/mbox —— 当前在哪都一样相对路径 从当前目录 当前已在 /usr/xisi 时，同目录文件就是 mbox；上一级用 ..
🎯 .. = 上一级；. = 当前这一层。当前在 /usr/xisi，要去 /usr/wangwu/f → 相对路径 ../wangwu/f。树形目录的好处：分类清楚、便于按路径共享。
练一练 · 树形目录相对路径
相对路径
当前目录为 /usr/xisi。要访问文件 /usr/wangwu/f，使用的相对路径是（ ）。
A. /wangwu/fB. wangwu/fC. ../wangwu/fD. ../../wangwu/f
答案 C 。
当前 /usr/xisi，.. 回到 /usr，再进 wangwu/f → ../wangwu/f。
6.3 Linux 权限位 + FAT 物理结构（2024上 Q25、Q26）
权限三位一组，从左到右：所有者 · 所属组 · 其他人 。每一位是 r/w/x 的加减法：
字母 意思 数字 r 读 4 w 写 2 x 执行 1 - 没有这个权限 0
🎯 把三组各加起来就是 chmod 数字。例：所有者 rwx=7，组 r-x=5，其他人 --x=1 → 751 。5 ，不是 4（只有读）也不是 6（读+写）。
三种物理结构见本节开头那张表。再钉一句：FAT 文件系统 = 链接结构 （文件分配表里串着下一块的指针）。连续/顺序结构、索引结构、哈希文件都不是 FAT。
练一练 · 2024上 · Q25 Linux 权限（空白卷 OCR）
Q25 Linux 权限 chmod
某个程序所有者拥有所有权限，组成员有读取和运行的权限，其他用户只有运行的权限，该程序的权限为（25）。
A. 741B. 742C. 751D. 752
答案 C 。
所有者「所有权限」= rwx = 4+2+1 = 7 ；5 （不是 4，也不是 6）；1 。751 。741 是组只读不执行；742 / 752 其他人带了写，题干没有。
练一练 · 2024上 · Q26 FAT 物理结构（空白卷 OCR）
Q26 FAT 物理结构
FAT 文件系统中，文件的物理结构是（26）。
A. 顺序结构B. 链接结构C. 索引结构D. 哈希文件
答案 B 。
FAT = File Allocation Table，表项里记的是下一块的块号 ，整条链串起一个文件 → 链接结构 。顺序/连续是整段挨着放；索引是 inode 那套（6.1 刚算过）；哈希不是磁盘物理结构的主流分类。
⑦ 磁盘与设备管理 disk & I/O
7.1 磁盘访问时间（考点⑨，2021上 Q5 · 2022下 Q28）
磁盘是一张会转的圆盘 ，磁头是一根会左右移动的针 。读一块数据必须走完三步，一步都不能少：
三步 干什么 谁决定快慢 ① 寻道时间 磁头左右移动 ，对准目标那一圈（磁道） 磁头机械移动的速度。和转速无关 ② 旋转延迟 （旋转等待） 盘子转，把目标扇区转到磁头正下方 转得越快，等的时间越短。平均大约是转半圈 的时间 ③ 传输时间 数据从盘片流进内存 转速越快，单位时间扫过的扇区越多，传输越快
寻道时间
磁头移到目标磁道
旋转延迟
目标扇区转到磁头下
传输时间
读写数据
磁盘访问时间 = 寻道 + 旋转延迟 + 传输
🎯 总公式： 磁盘访问时间 = 寻道 + 旋转延迟 + 传输
转速变成 2 倍时（2021上 Q5） 变不变 为什么 寻道时间 不变 磁头左右移动跟盘子转多快没关系 旋转延迟 减半 转一圈的时间减半，等半圈也减半 数据传输率 提高一倍 同样时间扫过两倍扇区。注意：传输率是变大，不是减半 平均存取时间（三步加总） 变小，但不是减半 只有其中一步减半，寻道那步没动
🔑 2021上 Q5 答案 C ：转速翻倍 → 只有旋转等待时间减半 。21ms ；100 块 × 21ms = 2100ms → 答案 C 。先算一块 的三步之和，再乘块数。
练一练 · 2021上 · Q5 磁盘性能
Q5 磁盘性能
若磁盘的转速提高一倍，则（ ）。
A. 平均存取时间减半 B. 平均寻道时间加倍 C. 旋转等待时间减半 D. 数据传输速率加倍
答案 C 。
小白版： 转速提高一倍 = 转一圈的时间减半，所以"等目标扇区转到磁头下"的旋转等待(延迟)时间减半 （C 对）。逐项排除： A 平均存取时间=寻道+旋转+传输，只有旋转减半、寻道不变，整体不是简单的减半 ，错；B 寻道时间由机械臂决定，与转速无关 ，错；D 数据传输速率是"每秒传多少"，转速翻倍确实提高 了，但说法是"加倍"，而题面问的是最优选项，本题官方答 C——严格说 D 也为真、C 更贴切。考试按 C 选。记忆： 转速→只影响"旋转延迟"和"传输率"；寻道时间不受转速影响。
练一练 · 2022下 · Q28 磁盘访问时间计算
Q28 磁盘访问时间计算
假设磁盘磁头从一个磁道移至相邻磁道需要 2ms。文件在磁盘上非连续存放，逻辑上相邻数据块的平均移动距离为 5 个磁道，每块的旋转延迟时间及传输时间分别为 10ms 和 1ms，则读取一个 100 块的文件需要（ ）ms。
A. 1100 B. 1200 C. 2100 D. 2200
答案 C（2100ms） 。
小白版： 每读一块，要花"找磁道 + 等扇区 + 读数据"三部分：10ms ；10ms ；1ms ；21ms ；100 块 × 21ms = 2100ms → C。
7.2 单缓冲区读记录的最长时间/最短时间（2021下 Q27-28 考点）
磁盘是圆 的：读完一条记录要处理 2ms，等处理完，磁头已经转过去了，下一条可能要等再转一圈 。这就是"顺序存放 vs 优化存放"的经典计算。
发生了什么 时间 读第 1 条 1ms 传输 + 2ms 处理 3ms。此时磁头已经转到第 4 块上方，而我们要的是第 2 块 之后每条（顺序放） 等几乎一整圈回来 + 再读 + 再处理 = 8+1+2 每条 11ms 最长（10 条顺序） 第 1 条 3ms + 后面 9 条各 11ms 3+99=102ms → Q27 选 D 最短（优化排列） 下一条刚好停在磁头下，不用空转 10×3=30ms → Q28 选 A
🎯 转速 10ms/周、每块转 1ms、处理 2ms、顺序处理 10 条：最长时间 = 3 + 9×(8+1+2) = 102ms ；优化后 = 10×3 = 30ms。
练一练 · 2021下 · Q27-28 磁盘单缓冲区读记录的最长/最短时间
Q27-28 磁盘单缓冲区读记录的最长/最短时间
在磁盘上存储数据的排列方式会影响 I/O 服务的总时间。假设每个磁道被划分成 10 个物理块，每个物理块存放 1 个逻辑记录。逻辑记录 R1,R2,…,R10 存放在同一个磁道上，排列顺序如下表所示。假定磁盘的旋转速度为 10ms/周，磁头当前处在 R1 的开始处。若系统顺序处理这些记录，使用单缓冲区，每个记录处理时间为 2ms，则处理这 10 个记录的最长时间为(27)；若对存储数据的排列顺序进行优化，处理 10 个记录的最少时间为（28）。
逻辑记录在线上的排列（原图）
(27) A. 30ms B. 60ms C. 94ms D. 102ms (28) A. 30ms B. 60ms C. 102ms D. 94ms
答案 (27) D（102ms）、(28) A（30ms） 。
小白版： 转速 10ms/周，10 块 → 每块在磁头下停留 1ms ；处理一块要 2ms 。最长时间： 读第 1 块（1ms）+ 处理（2ms）= 3ms，此时磁头已越过了第 2 块。要读第 2 块得等磁头几乎转一整圈回来 = 8ms，再 1ms 读 + 2ms 处理 = 11ms。后面每块都如此 → 3 + 9×(8+1+2) = 102ms 。最短时间： 把记录按"隔着排"优化顺序（如 1,8,5,2,9,6,3,10,7,4），使处理完当前块时下一块正好转到磁头下 → 无需额外等待 → 10 块 × 3ms = 30ms 。公式： 最长 ≈ 第一块时间 + (n−1)×(等待一圈 + 读 + 处理)；最短 = n×(读+处理)。
7.3 磁盘调度算法（考点⑫）
很多进程同时喊"我要读某某磁道"。磁头一次只能去一个地方，先去哪、后去哪 就是磁盘调度。把磁头想成电梯，磁道号想成楼层：
算法 电梯怎么走 优点 缺点 FCFS 先来先服务谁先按按钮就先去谁的楼层，不管远近 公平、实现简单 可能来回空跑，寻道时间很长 SSTF 最短寻道优先当前在 50 层，先去离 50 最近的请求 平均寻道短 两端楼层可能一直轮不上，饿死 SCAN 电梯算法一直往一个方向扫到头，再折返回来扫另一头（真正的电梯） 两端也能照顾到，不会饿死 刚扫过的那一端，新请求要等一个来回 C-SCAN 循环扫描只往一个方向服务；到头后快速空车回到起点 ，再同方向扫一遍 两端等待更均匀 回程那一段不服务
🔑 考试认出名字即可：FCFS 按到达、SSTF 就近、SCAN 来回电梯、C-SCAN 单方向循环 。看到"可能饿死"优先想 SSTF。
有的题不只问名字，还让你顺着磁道走一遍、把走过的格数加起来 。动作就两步：① 每一步在还没访问的请求里挑离当前磁头最近的（SSTF）；② 相邻两次 |磁道差| 全部加起来 = 移动磁道数。
步 当前 还没服务的请求 选谁（最近） 走过 累计 0 100 55, 58, 39, 18, 90, 160, 150, 38, 184 — — 0 1 100 … 90 （差 10，比 58 的 42 近）10 10 2 90 … 58 32 42 3 58 … 55 3 45 4 55 … 39 16 61 5 39 … 38 1 62 6 38 … 18 20 82 7~9 18 只剩 150, 160, 184 150 → 160 → 184 132+10+24 248
🎯 SSTF 路径：100→90→58→55→39→38→18→150→160→184 ，移动磁道数 248 。
练一练 · SSTF 走一遍磁道
SSTF 移动磁道数
磁头当前在 100 号磁道，请求序列为 55、58、39、18、90、160、150、38、184。采用 SSTF 算法，磁头移动的磁道数是（ ）。
A. 202B. 220C. 248D. 268
答案 C 。
按上表逐步就近：100→90(10)→58(32)→55(3)→39(16)→38(1)→18(20)→150(132)→160(10)→184(24)。加起来 10+32+3+16+1+20+132+10+24 = 248 。
7.4 SPOOLing（假脱机）
SPOOLing = Simultaneous Peripheral Operations On-Line，中文同时外围设备联机操作 ，也叫假脱机 。
零件 干什么 输入井 / 输出井 磁盘上划出来的缓冲区：先把要打印的东西倒进井里，打印机有空再真正打 虚拟设备 独占设备（打印机）被改造成「人人都能同时申请」的共享设备——其实每人拿到的是井里的一份 输入/输出进程 在后台搬数据：设备 ↔ 井 ↔ 用户进程
🎯 一句话：用磁盘假装独占设备 ，典型考法是「共享打印机」。它是联机的（On-Line），不是真的脱机；也不是把设备拆成多台物理打印机。
⑧ 真题按年索引 跳转到知识点下的原题
题目已经拆到各知识点正下方（知识点讲完立刻练）。这里只做跳转：
2020下 Q22 · 2020下 Q23 · 2020下 Q24 · 2020下 Q25-26 · 2020下 Q27 · 2020下 Q28 · 2021上 Q5 · 2021上 Q24 · 2021上 Q25 · 2021上 Q26-28 · 2021下 Q23 · 2021下 Q24-26 · 2021下 Q27-28 · 2022下 Q23 · 2022下 Q24-26 · 2022下 Q27 · 2022下 Q28 · 2024上 Q23 · 2024上 Q24 · 2024上 Q25 · 2024上 Q26 · 2025上 Q16 · 2025上 Q24
📭 2022 年上半年上午卷（本套 PDF）未出现操作系统题 （该套上午卷为短卷/回忆版，75 题不全）。2024 上 Q23–Q26 题干来自空白卷 OCR（无答案层，按考点核对）。OS 真题以 2020下、2021上/下、2022下、2024上 这几题为准。
本专题速记总收 资源分配 最小单位；线程=CPU 调度/执行 最小单位。线程共享代码/数据/文件/全局变量，独享栈指针/寄存器/PC 。等待不能直接到运行 。[m−n, m] ＝[−n+m, m] ＝[−(n−m), m] （三种写法同一个数）。出边 V、入边 P （造箭头的 V、接箭头的 P）。不死锁最少资源 n(k−1)+1 。页号换块号，页内地址不变 ；页大小 4K→低 12 位是页内地址。转速翻倍→旋转延迟减半 ，寻道不受影响。可剥夺（抢占） 方式。实时 。临界区四原则：空闲让进 / 忙则等待 / 有限等待 / 让权等待（无限等待不属于 ）。751 。FAT=链接结构 。/；相对从当前；..=上一级。
↑
