简介这份文档面向正在学习《操作系统精髓与设计原理》第八版的高校学生与考研备考者针对课后习题缺少参考答案、进程与并发概念难以自检的痛点提供系统化的解题参考。压缩包内仅含1个docx文件约904KB按章节组织答案便于对照教材逐题查阅。内容覆盖进程管理、进程调度、资源管理与并发编程四大模块例如习题3.1以状态转换图梳理就绪态、运行态、阻塞态与非常驻态之间的六类转换事件3.2结合时刻5至48的读写磁盘与中断事件推演各进程在时刻22、37、47的状态3.5则给出兼顾优先级与交换开销的中间调度策略5.3与5.4通过共享变量x和tally的交替执行分析伪并行下的输出顺序与取值范围。目前已有7513人学习下载适合作为章节复习、作业核对与考前查漏补缺的参考材料。1. 操作系统第八版习题答案从一份文档到一套可复现的操作系统解题框架很多人第一次拿到「操作系统第八版习题答案.docx」这类文档时第一反应是把它当成背诵材料考前翻一翻考完就丢。但如果你真的做过操作系统相关的工程会发现这份文档里藏着的不是答案而是一套解题框架——进程调度怎么算周转时间、页面置换怎么模拟缺页率、死锁检测怎么建资源分配图这些东西在真实系统调优里天天用。问题在于大部分答案文档只给结果不给过程你抄完还是不会。我见过太多人对着答案点头合上文档就懵。所以这篇笔记不打算复述某份答案而是把「操作系统第八版习题答案」这个标题拆开讲清楚怎么把一份静态文档变成可运行、可验证、可迁移的解题能力。适合正在学操作系统、准备考试、或者想补底层功底的后端和嵌入式从业者。2. 先搞清楚习题答案里到底在考什么四类题型与对应解法2.1 计算类题型调度、置换、磁盘寻道操作系统习题里占比最大的是计算题。进程调度算平均周转时间和带权周转时间页面置换算缺页次数和缺页率磁盘调度算总寻道长度。这三类题的共同点是公式不难但手算容易错尤其是题目给了十几条进程或十几个页面引用串的时候。我一般建议先把公式写成代码再用代码去跑题目数据。比如先来先服务、短作业优先、时间片轮转这三种调度算法用 Python 写出来不到五十行但能帮你验证手算结果。页面置换的 OPT、FIFO、LRU 也一样尤其是 LRU手算容易把最近使用顺序搞混代码跑一遍就清楚了。这里有个关键认知习题答案给的是某一组输入的输出但考试和实际工作换一组输入你就得重新算。所以真正要掌握的是算法逻辑不是那一组数字。2.2 分析类题型死锁、同步、内存分配分析类题目通常给一个场景问你「是否会发生死锁」「信号量初值该设多少」「首次适应和最佳适应哪个更省空间」。这类题没有唯一数值答案但有标准分析路径。死锁分析的标准路径是画资源分配图找环路判断环路是否涉及单个资源的多重请求。如果每个资源只有一个实例有环就有死锁如果资源有多个实例有环不一定死锁还要看能否找到安全序列。这个判断逻辑用代码实现就是银行家算法的安全性检查。信号量题的标准路径是先确定有几个同步点和互斥点每个点需要一个信号量然后确定初值。互斥信号量初值一般为 1同步信号量初值看资源初始可用数量。很多人错在把互斥和同步混在一起导致 P、V 操作顺序写反。2.3 设计类题型文件系统、I/O 调度、虚拟内存设计类题目要求你给出一个方案比如「设计一个支持大文件的索引结构」「设计一个磁盘调度策略兼顾公平和吞吐」。这类题在习题答案里通常只给一个参考方案但实际可以有多种正确解法。我的做法是先确定约束条件文件最大多大、磁盘块多大、内存有多少、访问模式是顺序还是随机。约束定了方案基本就定了。比如多级索引如果文件最大 1GB块大小 4KB那么直接索引加一级间接加二级间接就够不需要三级。习题答案如果给了三级你要看它的约束是不是和你一样。2.4 概念类题型对比、简述、判断概念题看似简单但最容易丢分。比如「进程和线程的区别」「分页和分段的区别」「中断和异常的区别」答案文档里通常列了五六条但你真到面试或工作中被问到能说清楚三条核心区别就不错了。我建议把概念题整理成对比表每行一个维度每列一个对象。这样复习时一眼能看出差异答题时也不会漏点。下面这张表是我自己整理的分页与分段对比你可以照着这个格式整理其他概念。对比维度分页分段划分依据物理块大小固定逻辑模块大小可变地址空间一维二维碎片类型内部碎片外部碎片对用户可见不可见可见共享与保护不易实现容易实现3. 把答案文档变成可运行代码三类核心算法的 Python 实现3.1 进程调度算法FCFS、SJF、RR 的代码实现先看调度算法。下面这段代码实现了 FCFS、非抢占 SJF 和时间片轮转三种调度输入是进程列表每个进程包含到达时间和服务时间输出是平均周转时间和平均带权周转时间。# 进程调度算法实现FCFS、SJF、RR # 输入processes [(pid, arrive, burst), ...] # 输出平均周转时间、平均带权周转时间 def fcfs(processes): # 先来先服务按到达时间排序依次执行 procs sorted(processes, keylambda x: x[1]) time 0 total_turnaround 0 total_weighted 0 for pid, arrive, burst in procs: if time arrive: time arrive # CPU 空闲等待 time burst turnaround time - arrive total_turnaround turnaround total_weighted turnaround / burst n len(procs) return total_turnaround / n, total_weighted / n def sjf_nonpreemptive(processes): # 非抢占短作业优先每次从已到达进程里选服务时间最短的 procs list(processes) time 0 total_turnaround 0 total_weighted 0 completed 0 n len(procs) while completed n: # 筛选已到达且未完成的进程 ready [p for p in procs if p[1] time] if not ready: time 1 # 没有就绪进程时间推进 continue # 选服务时间最短的 pid, arrive, burst min(ready, keylambda x: x[2]) time burst turnaround time - arrive total_turnaround turnaround total_weighted turnaround / burst procs.remove((pid, arrive, burst)) completed 1 return total_turnaround / n, total_weighted / n def rr(processes, quantum): # 时间片轮转每个进程执行一个时间片未完成则排到队尾 from collections import deque procs sorted(processes, keylambda x: x[1]) queue deque() time 0 idx 0 n len(procs) remaining {p[0]: p[2] for p in procs} finish_time {} while queue or idx n: # 把到达时间小于等于当前时间的进程加入队列 while idx n and procs[idx][1] time: queue.append(procs[idx]) idx 1 if not queue: time procs[idx][1] continue pid, arrive, burst queue.popleft() run min(quantum, remaining[pid]) time run remaining[pid] - run if remaining[pid] 0: finish_time[pid] time else: # 未完成重新加入队列注意要放在新到达进程后面 queue.append((pid, arrive, burst)) total_turnaround 0 total_weighted 0 for pid, arrive, burst in procs: turnaround finish_time[pid] - arrive total_turnaround turnaround total_weighted turnaround / burst return total_turnaround / n, total_weighted / n # 测试数据 processes [ (1, 0, 7), (2, 2, 4), (3, 4, 1), (4, 5, 4), ] print(FCFS:, fcfs(processes)) print(SJF:, sjf_nonpreemptive(processes)) print(RR(q2):, rr(processes, 2))这段代码的关键点有三个。第一FCFS 里要处理 CPU 空闲等待的情况如果当前时间小于进程到达时间时间要跳到到达时间。第二SJF 非抢占版本每次只从已到达进程里选不能选还没到的。第三RR 里未完成的进程重新入队时要放在当前已到达但还没入队的进程后面否则会打乱轮转顺序。参数方面时间片 quantum 的选择很关键。时间片太大就退化成 FCFS太小则上下文切换开销占比高。一般取略大于一次上下文切换时间的值习题里通常给固定值实际系统中常见范围是 10ms 到 100ms。3.2 页面置换算法OPT、FIFO、LRU 的模拟与缺页率对比页面置换的代码比调度稍短但细节更多。下面实现 OPT、FIFO、LRU 三种算法输入是页面引用串和物理块数输出缺页次数和缺页率。# 页面置换算法OPT、FIFO、LRU # 输入refs [页面号序列], frames 物理块数 # 输出缺页次数、缺页率 def opt(refs, frames): # 最佳置换淘汰未来最长时间不被访问的页面 memory [] faults 0 for i, page in enumerate(refs): if page in memory: continue faults 1 if len(memory) frames: memory.append(page) else: # 找未来最远才被访问的页面 farthest -1 victim None for p in memory: # 找 p 在 i 之后第一次出现的位置 try: next_use refs.index(p, i 1) except ValueError: next_use float(inf) # 之后不再使用 if next_use farthest: farthest next_use victim p memory.remove(victim) memory.append(page) return faults, faults / len(refs) def fifo(refs, frames): # 先进先出淘汰最早进入内存的页面 from collections import deque memory deque() faults 0 for page in refs: if page in memory: continue faults 1 if len(memory) frames: memory.append(page) else: memory.popleft() memory.append(page) return faults, faults / len(refs) def lru(refs, frames): # 最近最久未使用淘汰最长时间未被访问的页面 memory [] faults 0 for page in refs: if page in memory: memory.remove(page) memory.append(page) # 移到最近使用位置 continue faults 1 if len(memory) frames: memory.append(page) else: memory.pop(0) # 淘汰最久未使用的 memory.append(page) return faults, faults / len(refs) # 测试经典引用串 refs [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1] for name, func in [(OPT, opt), (FIFO, fifo), (LRU, lru)]: faults, rate func(refs, 3) print(f{name}: 缺页 {faults} 次, 缺页率 {rate:.2%})OPT 的实现要注意 refs.index(p, i1) 这个用法它在 i1 之后找 p 第一次出现的位置找不到就抛 ValueError我们把它当作无穷远。FIFO 用队列实现最自然但要注意 Python 的 deque 和 list 在删除操作上的性能差异。LRU 用 list 模拟每次访问把页面移到末尾淘汰时取头部逻辑清晰但时间复杂度是 O(n)实际系统中会用哈希表加双向链表做到 O(1)。跑这组经典数据OPT 缺页 9 次FIFO 缺页 15 次LRU 缺页 12 次。你会发现 FIFO 出现了 Belady 异常——物理块增多缺页反而可能增加而 LRU 和 OPT 不会。这个现象在习题里经常考代码跑一遍比背结论印象深得多。3.3 银行家算法安全性检查与死锁避免银行家算法是死锁避免的核心习题里通常给 Allocation、Max、Available 三个矩阵问是否存在安全序列。下面代码实现了安全性检查。# 银行家算法安全性检查 # 输入available 可用资源向量, max_need 最大需求矩阵, # allocation 已分配矩阵 # 输出是否存在安全序列以及该序列 def banker_safety(available, max_need, allocation): n len(allocation) # 进程数 m len(available) # 资源种类数 # 计算需求矩阵 Need Max - Allocation need [[max_need[i][j] - allocation[i][j] for j in range(m)] for i in range(n)] work available[:] # 工作向量初始等于 Available finish [False] * n safe_seq [] while len(safe_seq) n: found False for i in range(n): if finish[i]: continue # 检查 Need[i] 是否小于等于 Work if all(need[i][j] work[j] for j in range(m)): # 进程 i 可以执行完成释放资源 for j in range(m): work[j] allocation[i][j] finish[i] True safe_seq.append(i) found True break if not found: # 找不到可执行进程不安全 return False, [] return True, safe_seq # 测试数据 available [3, 3, 2] max_need [ [7, 5, 3], [3, 2, 2], [9, 0, 2], [2, 2, 2], [4, 3, 3], ] allocation [ [0, 1, 0], [2, 0, 0], [3, 0, 2], [2, 1, 1], [0, 0, 2], ] safe, seq banker_safety(available, max_need, allocation) print(安全: , safe, 序列:, seq)这段代码的核心是 Work 向量的更新进程执行完成后已分配的资源要归还给 Work。注意 Need 矩阵是 Max 减 Allocation不是单独给的。习题里有时直接给 Need有时给 Max 和 Allocation你要会换算。参数方面Available 是系统当前可用资源Allocation 是已分配给各进程的资源Max 是各进程声明的最大需求。安全性检查的时间复杂度是 O(n²m)进程数和资源种类数都不大时完全够用。4. 避坑与排查习题答案里最容易翻车的五个地方4.1 周转时间算错到达时间和服务时间的顺序搞反现象算出来的平均周转时间比答案大很多或小很多。原因周转时间是完成时间减到达时间不是服务时间减到达时间。很多人把服务时间当成完成时间或者忘记加等待时间。解决画甘特图把每个进程的开始、完成时间标出来周转时间等于完成减到达带权周转时间等于周转除以服务。4.2 缺页率算错引用串长度和缺页次数对不上现象缺页率超过 100% 或者明显偏低。原因缺页率是缺页次数除以总引用次数不是除以物理块数。另外 OPT 算法里如果页面在内存中但未来不再使用它的下次使用位置是无穷大应该优先淘汰。解决先确认引用串长度再数缺页次数两者相除。OPT 的淘汰逻辑用代码跑一遍别手算。4.3 信号量初值设错互斥和同步混在一起现象P、V 操作顺序写反或者信号量初值设成 0 导致进程永远阻塞。原因互斥信号量初值必须是 1表示资源可用同步信号量初值看资源初始数量如果生产者要先生产消费者才能消费同步信号量初值设 0。解决先画同步点每个同步点一个信号量互斥单独一个信号量。P 操作顺序是先同步后互斥V 操作顺序是先互斥后同步。4.4 银行家算法漏判Need 矩阵算错或 Work 更新遗漏现象明明有安全序列却判成不安全。原因Need 矩阵应该是 Max 减 Allocation不是直接抄题目给的某个矩阵。另外进程执行完成后Work 要加上该进程的 Allocation不是加上 Need。解决把三个矩阵列成表格逐行核对。Work 更新时只加 Allocation不加 Max。4.5 磁盘调度算错寻道长度是相邻访问的差值绝对值现象总寻道长度算成最大磁道减最小磁道。原因寻道长度是磁头从当前磁道移动到下一个目标磁道的距离是相邻两个访问磁道号的差的绝对值不是总范围。解决把访问序列按算法排序然后逐对计算差值绝对值再求和。SCAN 和 C-SCAN 要注意磁头移动方向到达端点后是否反向。5. 从习题到实战用一套验证脚本把答案变成可迁移能力5.1 建立自己的验证脚本库习题答案最大的问题是不可验证。你抄完答案不知道自己算的对不对。我的做法是给每类题型写一个验证脚本输入题目数据输出结果然后和答案对比。上面三节给的调度、置换、银行家算法代码就是基础版本你可以把它们存成一个 os_solver.py以后遇到同类题直接调用。更进一步你可以给每个函数加上参数校验和边界测试。比如调度算法里如果进程到达时间都是 0SJF 和 FCFS 的结果应该一样如果时间片设得比所有进程服务时间都大RR 应该退化成 FCFS。这些边界条件能帮你确认代码逻辑是否正确。5.2 用随机数据做交叉验证手算容易错但代码也可能有 bug。交叉验证的方法是用随机生成的数据跑两种不同实现看结果是否一致。比如 LRU 可以用 list 实现也可以用 OrderedDict 实现两者结果应该相同。如果不同说明至少有一个实现有问题。下面这段代码生成随机进程数据分别用两种方式实现 LRU对比缺页次数。# LRU 交叉验证list 实现 vs OrderedDict 实现 import random from collections import OrderedDict def lru_list(refs, frames): memory [] faults 0 for page in refs: if page in memory: memory.remove(page) memory.append(page) else: faults 1 if len(memory) frames: memory.pop(0) memory.append(page) return faults def lru_ordered(refs, frames): memory OrderedDict() faults 0 for page in refs: if page in memory: memory.move_to_end(page) else: faults 1 if len(memory) frames: memory.popitem(lastFalse) memory[page] True return faults # 随机测试 100 组 for _ in range(100): refs [random.randint(0, 9) for _ in range(50)] frames random.randint(1, 5) f1 lru_list(refs, frames) f2 lru_ordered(refs, frames) if f1 ! f2: print(不一致:, refs, frames, f1, f2) break else: print(100 组随机测试全部一致)这段代码跑完如果输出「100 组随机测试全部一致」说明两种实现逻辑等价。如果中间有不一致打印出来的那组数据就是你的排查线索。5.3 把习题结论映射到真实系统参数习题里的参数往往是简化过的比如页面大小固定 4KB物理块数固定 3 个时间片固定 2ms。真实系统里这些参数是动态的。Linux 的页面大小通常是 4KB但可以配置为大页 2MB 或 1GB物理内存的页面帧数量取决于可用内存时间片在 CFS 调度器里不是固定值而是根据进程优先级和负载动态计算。我的习惯是做完一道习题去查一下真实系统里对应的参数范围。比如做完页面置换去查 Linux 的页回收策略做完调度去查 CFS 的 vruntime 计算方式。这样习题就不是孤立的而是真实系统的一个简化模型。5.4 一个具体技巧用甘特图验证调度结果调度类习题最容易错的是周转时间。我的验证技巧是画甘特图横轴时间纵轴进程每个进程一个条形条形长度等于服务时间条形起点是开始执行时间。画完图每个进程的完成时间一目了然周转时间就是完成时间减到达时间。手画太慢可以用 matplotlib 画。下面这段代码把 FCFS 的调度结果画成甘特图。# 用 matplotlib 画 FCFS 调度甘特图 import matplotlib.pyplot as plt def fcfs_gantt(processes): procs sorted(processes, keylambda x: x[1]) fig, ax plt.subplots() time 0 for pid, arrive, burst in procs: if time arrive: time arrive ax.barh(pid, burst, lefttime, height0.5) ax.text(time burst / 2, pid, fP{pid}, hacenter, vacenter) time burst ax.set_xlabel(时间) ax.set_ylabel(进程) ax.set_title(FCFS 调度甘特图) plt.show() processes [(1, 0, 7), (2, 2, 4), (3, 4, 1), (4, 5, 4)] fcfs_gantt(processes)画出来之后每个进程的开始和结束时间清清楚楚周转时间直接读图就行。这个技巧我用了很多年比反复手算靠谱得多。5.5 最后的习惯每道题都问一句「如果参数变了会怎样」习题答案给的是特定输入下的输出。真正要掌握的是如果到达时间变了、时间片变了、物理块数变了结果会怎么变。我的习惯是每做完一道题改一个参数再跑一遍看结果的变化趋势。比如时间片从 2ms 改成 4msRR 的平均周转时间是变大还是变小物理块数从 3 增加到 4FIFO 的缺页次数是增加还是减少。这个习惯坚持下来你会发现习题答案不再是背诵材料而是一个可以反复实验的平台。操作系统这门课的精髓不在答案本身而在答案背后的算法逻辑和参数敏感性。希望帮到你。本文还有配套的精品资源点击获取