ChoChoX/obsidian
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vault backup: 2026-07-03 23:22:28

Browse Source
This commit is contained in:
ChoChoX
2026-07-03 23:22:28 +08:00
parent 8197fd341e
commit 3aac80fb26
41 changed files with 11906 additions and 10335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
操作系统/2026年操作系统期末预测卷.md Normal file
View File

@@ -0,0 +1,257 @@
# 2026年操作系统期末预测卷
## 考试信息
- **满分**：100分
- **时间**：120分钟
- **题型**：7道大题（与历年试卷格式一致）
---
## 题目一：进程控制与进程树分析（15分）
### 题目
阅读以下程序代码，回答问题：
```c
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
pid_t pid;
int status;
printf("A: pid=%d\n", getpid());
pid = fork();
if (pid == 0) {
printf("B: pid=%d, ppid=%d\n", getpid(), getppid());
pid = fork();
if (pid == 0) {
printf("C: pid=%d, ppid=%d\n", getpid(), getppid());
} else {
wait(&status);
printf("D: pid=%d\n", getpid());
}
} else {
printf("E: pid=%d\n", getpid());
pid = fork();
if (pid == 0) {
printf("F: pid=%d, ppid=%d\n", getpid(), getppid());
} else {
wait(&status);
wait(&status);
printf("G: pid=%d\n", getpid());
}
}
return 0;
}
```
**问题**：
1. （6分）画出完整的进程树，标注每个进程执行的输出语句（用字母A-G表示）
2. （4分）该程序共有多少个进程（包括初始进程）？请列出所有进程的创建顺序
3. （3分）输出语句D和G的执行顺序是否一定？为什么？
4. （2分）如果将所有`wait(&status)`调用删除，进程输出结果会发生什么变化？
---
## 题目二：磁盘调度算法计算（15分）
### 题目
某磁盘有200个磁道（编号0-199），磁盘请求队列中的磁道号依次为：
**98, 183, 37, 122, 14, 124, 65, 67**
当前磁头位于磁道**53**，向磁道号**增大**的方向移动。
**问题**：
1. （8分）分别使用以下磁盘调度算法，计算磁头移动的总磁道数：
- FCFS（先来先服务）
- SSTF（最短寻道时间优先）
- SCAN（电梯算法）
- C-SCAN（循环扫描算法）
2. （4分）在上述四种算法中，哪种算法的磁头移动总磁道数最少？哪种最多？简要说明原因。
3. （3分）如果磁头初始方向改为向磁道号减小的方向移动，SCAN算法的结果会如何变化？请计算新的磁头移动总磁道数。
---
## 题目三：虚拟内存与页面置换（15分）
### 题目
某系统采用请求分页存储管理，页面大小为4KB，分配给某进程的物理页框数为**4**。该进程的页面访问序列为：
**1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5**
**问题**：
1. （9分）分别使用以下页面置换算法，计算缺页次数和缺页率：
- OPT（最优算法）
- FIFO（先进先出算法）
- LRU（最近最久未使用算法）
2. （3分）如果将分配的物理页框数增加到5，使用FIFO算法，缺页次数是否会减少？请验证并解释是否出现了Belady异常。
3. （3分）假设页面大小改为8KB（其他条件不变），该进程的虚拟地址空间大小为32KB，请问：
- 进程共有多少个虚拟页？
- 页表需要多少个页表项？
- 虚拟地址`0x3A5F`对应的页号和页内偏移分别是多少？
---
## 题目四：文件系统与inode计算（15分）
### 题目
某Unix文件系统采用Ext2结构，文件系统的块大小为**4KB**，磁盘块号占**4字节**，inode中包含**15个地址项**（12个直接索引、1个一次间接、1个二次间接、1个三次间接）。
**问题**：
1. （6分）计算：
- 每个磁盘块可以存放多少个磁盘块号？
- 一个inode支持的最大文件大小是多少？（请列出计算过程）
2. （4分）假设某文件大小为260KB，请问：
- 该文件占用多少个数据块？
- inode中的哪些地址项会被使用？
- 是否需要使用间接索引块？如果需要，使用几个？
3. （5分）假设要读取该文件偏移量为100KB处开始的4KB数据，请描述完整的地址转换过程：
- 如何确定使用inode中的哪个地址项？
- 如何计算数据在磁盘上的具体位置？
- 需要访问几次磁盘？
---
## 题目五：CPU调度算法计算（15分）
### 题目
某单处理器系统中有以下进程，按到达时间排序：
| 进程 | 到达时间 | 运行时间 |
|------|----------|----------|
| P1 | 0 | 8 |
| P2 | 1 | 4 |
| P3 | 2 | 9 |
| P4 | 3 | 5 |
| P5 | 4 | 2 |
**问题**：
1. （9分）分别使用以下调度算法，计算各进程的完成时间、周转时间和带权周转时间，并求平均周转时间和平均带权周转时间：
- FCFS（先来先服务）
- SJF（非抢占最短作业优先）
- HRRF（最高响应比优先）
2. （3分）在上述三种算法中：
- 哪种算法的平均周转时间最短？
- 哪种算法可能产生"饥饿"现象？为什么？
3. （3分）如果采用时间片轮转调度（RR），时间片大小为3，请画出甘特图并计算P1和P2的周转时间。
---
## 题目六：I/O控制方式与磁盘访问（15分）
### 题目
1. （6分）比较以下四种I/O控制方式的特点，填写下表：
| 特性 | 程序直接控制 | 中断驱动I/O | DMA | 通道 |
|------|-------------|-------------|-----|------|
| CPU介入频率 | | | | |
| 数据传输单位 | | | | |
| CPU与I/O并行性 | | | | |
| 硬件复杂度 | | | | |
2. （4分）某磁盘转速为7200 RPM，平均寻道时间为8ms，每个磁道500个扇区，每个扇区512字节。
- 计算平均旋转延迟
- 计算读取一个扇区的平均访问时间
- 如果要连续读取100个扇区（在同一磁道上），总访问时间是多少？
3. （5分）某系统使用SPOOLing技术管理打印机：
- 画出SPOOLing系统的组成结构图
- 解释SPOOLing如何将独占设备改造为共享设备
- 说明SPOOLing与缓冲技术的区别
---
## 题目七：段页式存储管理与地址转换（10分）
### 题目
某系统采用段页式存储管理，地址结构如下：
- 段号：8位
- 页号：8位
- 页内偏移：16位
系统参数：
- 页大小：64KB
- 段表基址寄存器指向的段表如下：
| 段号 | 段长（页数） | 页表始址 |
|------|-------------|----------|
| 0 | 4 | 1000 |
| 1 | 6 | 2000 |
| 2 | 2 | 3000 |
页表（部分）如下：
| 页号 | 物理块号 |
|------|----------|
| 0 | 50 |
| 1 | 51 |
| 2 | 52 |
| 3 | 53 |
**问题**：
1. （4分）逻辑地址`0x00018000`对应的段号、页号、页内偏移分别是多少？该地址对应的物理地址是多少？（写出计算过程）
2. （3分）逻辑地址`0x01028000`是否合法？为什么？如果合法，计算其物理地址。
3. （3分）与纯分页和纯分段相比，段页式存储管理有哪些优点和缺点？
---
## 参考答案要点
### 题目一参考答案
1. 进程树：A→(B, E)，B→(C, D)，E→(F, G)
2. 共7个进程，创建顺序：A→B→E→C→F→D→G
3. D和G的执行顺序不一定，取决于哪个子进程先完成
4. 删除wait后，输出顺序不确定，可能出现孤儿进程
### 题目二参考答案
1. FCFS: 640道，SSTF: 236道，SCAN: 299道，C-SCAN: 356道
2. SSTF最少（贪心选择最近），FCFS最多（无优化）
3. 反向SCAN：53→37→14→0→65→67→98→122→124→183，总移动：359道
### 题目三参考答案
1. OPT: 8次(66.7%)，FIFO: 10次(83.3%)，LRU: 10次(83.3%)
2. 页框数=5时FIFO缺页仍为10次，未出现Belady异常
3. 虚拟页数=4，页表项=4，地址0x3A5F：页号=3，偏移=0x2A5F
### 题目四参考答案
1. 每块1024个块号，最大文件约16GB+
2. 65个数据块，使用直接索引12个+一次间接索引1个，不需要二次间接
3. 偏移100KB=第25块，使用直接索引项2，需2次磁盘访问
### 题目五参考答案
1. FCFS平均周转7.8，SJF平均周转6.2，HRRF平均周转7.0
2. SJF最短，SJF可能饥饿（长作业持续等待）
3. RR甘特图：0-3(P1),3-6(P2),6-8(P5),8-11(P1),11-14(P3),14-17(P4),17-20(P1),20-23(P3),23-25(P3)
P1周转=23，P2周转=6
### 题目六参考答案
1. 表格填写（见知识点总结）
2. 旋转延迟4.17ms，扇区访问12.21ms，连续100扇区约12.5ms
3. SPOOLing由输入/输出井和预输入/缓输出程序组成
### 题目七参考答案
1. 段号=0，页号=1，偏移=0x8000，物理地址=51×64KB+0x8000
2. 合法，段号1页号2，物理地址=52×64KB+0x8000
3. 优点：分段便于共享/保护+分页解决外部碎片；缺点：地址转换复杂，需3次访存

688
操作系统/复习与教学笔记（加强版）.md Normal file
View File

@@ -0,0 +1,688 @@
# 📖 操作系统复习与教学笔记
> **目标**：不仅能应付考试，更能真正理解操作系统的工作原理
> **定位**：这份笔记不是简单的知识点罗列，而是教你"怎么学、怎么记、怎么做题"
---
## 目录
1. [复习策略与时间规划](#一复习策略与时间规划)
2. [四大必考计算题 · 手把手教学](#二四大必考计算题--手把手教学)
3. [核心概念 · 快速记忆法](#三核心概念--快速记忆法)
4. [易混淆概念辨析](#四易混淆概念辨析)
5. [代码题考点精讲](#五代码题考点精讲)
6. [问答题高频考点](#六问答题高频考点)
7. [考前速查表](#七考前速查表)
---
## 一、复习策略与时间规划
### 1.1 按优先级分三层
| 层级 | 内容 | 建议投入时间 | 策略 |
|------|------|-------------|------|
| 🔴 **保命层** | 磁盘调度、页面置换、fork进程树、inode计算 | 60% | 必须能**独立默写**解题步骤 |
| 🟡 **进阶层** | CPU调度、I/O控制方式、段页式地址转换、死锁 | 30% | 理解原理 + 做2-3道题 |
| 🟢 **基础层** | 概念题、代码优化、工作集模型 | 10% | 多看几遍，有印象即可 |
### 1.2 复习三步法
```
第一步：看本笔记 → 建立知识框架和记忆锚点
第二步：做预测卷 → 实战演练，暴露薄弱点
第三步：复盘错题 → 针对性地回顾对应章节
```
### 1.3 考试时间分配建议（120分钟）
| 题型 | 建议用时 | 策略 |
|------|---------|------|
| 计算题（磁盘/页面置换/CPU调度/inode） | 50-60min | 先做！这是拿分大头 |
| 代码分析题（fork进程树） | 15-20min | 画图要清晰规范 |
| 简答/概念题 | 25-30min | 分点作答，关键词给分 |
| 地址转换题 | 10-15min | 按步骤写，不要跳步 |
| 检查 | 5-10min | 检查计算题的数字 |
---
## 二、四大必考计算题 · 手把手教学
### 2.1 磁盘调度算法计算（★★★★★ 每年必考）
#### 本质理解
磁盘调度就是在解决"磁头怎么走最省时间"的问题。可以把磁头想象成电梯，磁道就是楼层号。
#### 各算法的"人设"
| 算法 | 一句话人设 | 行为特征 |
|------|-----------|----------|
| **FCFS** | "先来后到"的耿直 boy | 来一个处理一个，不做任何优化 |
| **SSTF** | "贪心"的近视眼 | 每次都选最近的，但可能让远的永远等不到 |
| **SCAN** | "电梯"本梯 | 一直走到头再回头 |
| **C-SCAN** | 单向电梯 | 只往上走，到顶后直接回到底部重来 |
| **LOOK** | 智能电梯 | 走到最后一个请求就回头，不到边界 |
| **C-LOOK** | 智能单向电梯 | 只往上到最高请求，然后直接回最低请求 |
#### 📐 解题模板（以最难的 C-SCAN 为例）
```
题目：磁道0-199，磁头在53，向增大方向移动
请求序列：98, 183, 37, 122, 14, 124, 65, 67
Step 1: 将请求排序
排序：14, 37, 65, 67, 98, 122, 124, 183
Step 2: 确定方向并依次服务
C-SCAN规则：向增大方向走 → 到199（边界）→ 回到0 → 继续向增大方向
路径：53 → 65 → 67 → 98 → 122 → 124 → 183 → 199（到边界）→ 0 → 14 → 37
移动距离：12 + 2 + 31 + 24 + 2 + 59 + 16 + 199 + 14 + 23
Step 3: 求和
= 12+2+31+24+2+59+16+199+14+23 = 382道
```
#### ⚠️ 常见错误
| 错误 | 正确做法 |
|------|---------|
| SCAN/C-SCAN 忘记走到边界（199或0） | **必须**走到边界，除非题目说用 LOOK |
| SSTF 选择了相等距离的两个磁道 | 通常选编号小的（题目可能会有说明） |
| 方向搞反 | 题目说"向增大方向"就从53往上走 |
| C-SCAN 往回时逐个服务 | C-SCAN 回头时**不服务**，到底后才重新开始 |
#### 💡 速算技巧
SSTF 的路径一定是最短的（贪心嘛），FCFS 通常是最长的。检查时如果 SSTF 比别的算法还长，肯定算错了。
---
### 2.2 页面置换算法（★★★★★ 每年必考）
#### 本质理解
内存满了，要换掉哪个页面？OPT 是"预言家"，LRU 是"记仇本"，FIFO 是"排队机"。
#### 各算法速记
| 算法 | 口诀 | 关键特征 |
|------|------|---------|
| **OPT** | "看未来，谁最晚用就换谁" | 理论最优，无法实现（但考试能算） |
| **FIFO** | "先来先走，排队淘汰" | 可能 Belady 异常（页框变多反而缺页更多） |
| **LRU** | "看过去，谁最久没用就换谁" | 无 Belady 异常，硬件开销大 |
| **Clock** | "转圈查，引用位=0就换" | LRU 的简化版 |
#### 📐 解题模板（以 LRU，页框数=3 为例）
```
访问序列：7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1
画表格法：
-------------------------------------------------------------
访问 页框1 页框2 页框3 是否缺页 说明
-------------------------------------------------------------
7 7 - - ✓缺页 空，直接放入
0 7 0 - ✓缺页 空，直接放入
1 7 0 1 ✓缺页 空，直接放入
2 7 0 2 ✓缺页 换掉最久未用的1（1离上次最远）
0 7 0 2 ✗命中 0已存在，更新它的使用时间
3 3 0 2 ✓缺页 换掉最久未用的7（7离上次最远）
0 3 0 2 ✗命中 0已存在
4 3 0 4 ✓缺页 换掉最久未用的2（2离上次最远）
...以此类推
```
#### ⚠️ OPT 和 LRU 的区别（最容易混淆）
```
序列：1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5（页框数=4）
OPT 在访问5时：
当前页框：1,2,3,4
看未来：1还要用（第5位），2还要用（第6位），3还要用（第10位），4还要用（第11位）
最晚使用的是4（第11位才用），所以换4
LRU 在访问5时：
当前页框：1,2,3,4
看过去：1最近在位置4用过，2在位置5用过，3在位置2用过，4在位置3用过
最久未用的是3（位置2之后就没用过），所以换3
```
> **关键口诀**：OPT 看**未来**，LRU 看**过去**。OPT 是"预言"，LRU 是"历史"。
#### 💡 Belady 异常
**只在 FIFO 中出现**。增加页框数反而缺页更多。LRU 和 OPT 都不会有这个问题。
---
### 2.3 fork 进程树分析（★★★★★ 每年必考）
#### 本质理解
`fork()` 就像细胞分裂 — 调用一次，变成两个进程，从同一行代码继续执行。
#### 黄金法则
```
法则1：fork() 一次，返回两次
- 父进程返回值 = 子进程的 PID
- 子进程返回值 = 0
法则2：子进程从 fork() 的下一行开始执行（不是从 main 开头）
法则3：fork() 嵌套时，每个进程都要独立分析它的执行路径
法则4：父进程总数 = 2^n（n为fork调用次数，无嵌套时）
```
#### 📐 解题模板
```
程序：
fork() // fork1
if (pid == 0) {
fork() // fork2
}
fork() // fork3
Step 1: 画出进程树
P(初始)
╱ ╲ ← fork1
P(子1) P(父)
╱ ╲ ╲ ← fork2（只有子1执行）
P(孙1) P(子1续) P(父)
| | | ← fork3（所有进程都执行）
P(曾孙1) P(孙2) P(子2)
Step 2: 统计进程总数
2³ = 8个进程（3次fork，最外层没有if限制）
Step 3: 分析每个进程的输出
按执行路径逐条跟踪...
```
#### ⚠️ 常见陷阱
| 陷阱 | 说明 |
|------|------|
| `if (pid == 0)` 内的 fork | 只有子进程执行，父进程跳过 |
| `wait(NULL)` | 父进程等待**任意**子进程结束 |
| 嵌套的 `wait` | 每个 `wait` 只能回收一个子进程 |
| 没有 wait | 子进程变成僵尸进程（Zombie） |
#### 💡 wait 的个数
父进程有几个子进程，就应该有几个 `wait()`，否则会产生僵尸进程。
---
### 2.4 Ext2 inode 最大文件计算（★★★★★ 每年必考）
#### 本质理解
inode 就像文件系统的"目录索引卡"，有15个格子放地址。前12个直接指向数据块，后3个是间接指向（指向一个"指针块"，指针块再指向数据块）。
#### 计算公式速记
```
块大小 = 4KB = 4096 字节
指针大小 = 4 字节
每块指针数 = 4096 / 4 = 1024 个
最大文件：
直接：12 × 4KB = 48KB
一次间接：1024 × 4KB = 4MB
二次间接：1024² × 4KB = 4GB
三次间接：1024³ × 4KB = 4TB
──────────────────────────────────
总计：48KB + 4MB + 4GB + 4TB ≈ 4.004 TB
```
> **注意**：如果块大小是 1KB、指针 4B，则每块 256 个指针，结果约 16GB+（你的知识点总结里那个）。
#### 📐 解题模板：给定文件大小，问需要哪些地址项
```
题目：块大小=4KB，指针=4B，文件=260KB
Step 1: 计算文件占多少数据块
260KB / 4KB = 65 块
Step 2: 检查直接索引能装多少
直接索引 = 12 块 → 只能装 48KB，不够
Step 3: 一次间接能装多少
一次间接 = 1024 块 → 1024 × 4KB = 4MB
12 + 1024 = 1036 块，65 ≤ 1036，所以只需要一次间接
结论：使用直接索引12个 + 一次间接1个（其中用到 65-12=53 个指针）
```
#### ⚠️ 易错点
- 问"需要几次磁盘访问"：直接索引=1次，一次间接=2次（先读指针块，再读数据块），二次间接=3次...
- 在计算最大文件时，**不要忘了加直接索引的12块**
---
## 三、核心概念 · 快速记忆法
### 3.1 操作系统四大特征
```
口诀：共、享、虚、异 → "恭喜虚拟"
- 共（并发）：宏观并行，微观串行
- 享（共享）：资源共享
- 虚（虚拟）：物理实体变为逻辑多个
- 异（异步）：进程走走停停
```
### 3.2 CPU 双模式
```
用户态 →→→ 中断/异常/系统调用 →→→ 内核态
内核态 →→→ PSW切换 →→→ 用户态
记忆：用户态进内核态叫"陷入"（trap），内核态回用户态叫"恢复"
```
### 3.3 中断分类速记
```
中断(Interrupt)
├── 硬中断（外部，异步）
│ ├── I/O中断（键盘敲一下）
│ └── 时钟中断（OS拿回控制权的关键！）
│
└── 软中断/异常（内部，同步）
├── 故障（Fault）：缺页异常（可恢复）
├── 陷阱（Trap）：系统调用 int 0x80
└── 终止（Abort）：除零错误（不可恢复）
```
> **必考提问**：OS 如何获得 CPU 控制权？→ **时钟中断！** 时间片到了，时钟中断触发，OS 重新调度。
### 3.4 ELF 内存布局
```
从低地址到高地址：
┌─────────────────┐
│ .text 代码段 │ ← 只读，存放指令
│ .rodata 只读数据 │ ← 字符串常量等
│ .data 初始化数据 │ ← 已初始化全局变量
│ .bss 未初始化数据 │ ← 不占磁盘！只占内存
├─────────────────┤
│ heap（堆）↑ │ ← malloc 分配
├─────────────────┤
│ ↓ │
│ stack（栈） │ ← 局部变量、函数调用
└─────────────────┘
```
**记忆 trick**：堆向上长（像树往上），栈向下长（像水往下流）。
### 3.5 死锁四个必要条件
```
口诀：互、请、不、循 → "互请不循"（互相请求，不能循环）
1. 互斥（Mutual exclusion）
2. 请求和保持（Hold and wait）
3. 不可抢占（No preemption）
4. 循环等待（Circular wait）
破坏任意一个 → 死锁预防
```
### 3.6 页面置换算法特征速记
```
OPT → 看未来，最晚用的 → 不可能实现（除非能预知未来）
LRU → 看过去，最久没用 → 硬件开销大
FIFO → 看时间，最早进入 → 会有 Belady 异常
Clock→ 看引用位，转圈查 → 近似 LRU
LFU → 看次数，最少使用 → 可能被"热数据"刷掉
```
---
## 四、易混淆概念辨析
### 4.1 并发 vs 并行
| | 并发 | 并行 |
|--|------|------|
| 含义 | 同时**处理**多个任务 | 同时**执行**多个任务 |
| 核心 | 宏观上同时，微观上交替 | 真正的同一时刻都在运行 |
| 硬件 | 单核 CPU | 多核 CPU |
| 类比 | 一个人交替做几件事 | 几个人同时做各自的事 |
### 4.2 进程 vs 线程
| | 进程 | 线程 |
|--|------|------|
| 资源拥有 | 独立地址空间 | 共享进程资源 |
| 切换开销 | 大（需切换页表等） | 小（只需切换栈） |
| 通信方式 | IPC（管道、共享内存等） | 直接读写共享数据 |
| 独立性 | 一个崩溃不影响其他 | 一个线程崩溃→整个进程崩溃 |
### 4.3 死锁 vs 饥饿
| | 死锁 | 饥饿 |
|--|------|------|
| 状态 | 多个进程**互相等待**，都无法前进 | 一个进程**一直等不到**资源 |
| 是否可以解除 | 必须外部干预（终止进程/抢占资源） | 其他进程释放资源后可自动解除 |
| 典型场景 | 银行家算法中不安全状态 | SJF 中长作业一直得不到 CPU |
### 4.4 静态链接 vs 动态链接
| | 静态链接 | 动态链接 |
|--|---------|---------|
| 时机 | 编译时 | 运行时 |
| 文件大小 | 大（包含所有库代码） | 小（运行时加载） |
| 更新库 | 需重新编译 | 直接替换库文件 |
| 依赖 | 无外部依赖 | 需要 .so/.dll 文件存在 |
### 4.5 全局置换 vs 局部置换
| | 全局置换 | 局部置换 |
|--|---------|---------|
| 范围 | 从所有进程中选页面换出 | 只从当前进程的页面中选 |
| 公平性 | 进程可能互相影响 | 每个进程独立管理 |
| 抖动控制 | 难控制 | 容易控制 |
### 4.6 固定分区 vs 动态分区 vs 分页
| | 固定分区 | 动态分区 | 分页 |
|--|---------|---------|------|
| 内部碎片 | ✓ | ✗ | ✓（最后一页） |
| 外部碎片 | ✗ | ✓ | ✗ |
| 管理复杂度 | 低 | 中 | 高 |
---
## 五、代码题考点精讲
### 5.1 fork 代码分析
#### 经典模式 1：单次 fork
```c
pid_t pid = fork();
if (pid == 0) {
// 子进程代码
} else {
// 父进程代码，pid 是子进程的 PID
}
```
**输出特点**：
- 子进程和父进程的代码都会执行
- 子进程从 fork() 返回处开始执行（不是从 main 开始）
- "A\n" 只有一个进程输出，"B\n" 和 "C\n" 各输出一次（因为 fork 后两个进程都继续）
#### 经典模式 2：嵌套 fork
```c
pid_t pid1 = fork(); // fork1
if (pid1 == 0) {
pid_t pid2 = fork(); // fork2 — 只在子进程中执行
if (pid2 == 0) {
// 孙进程
}
}
```
**进程树分析**：
```
P（初始）
/ \ ← fork1
P(子1) P(父)
/ \ ← fork2（仅在子1中执行）
P(孙) P(父)
```
#### 经典模式 3：fork + wait
```c
for (int i = 0; i < 3; i++) {
pid_t pid = fork();
if (pid == 0) {
// 子进程
exit(0);
}
}
// 父进程需要回收所有子进程
while (wait(NULL) > 0);
```
**重点**：循环中的 fork，子进程 exit 后，父进程用 `wait` 回收。总计 `2³ = 8` 个进程。
### 5.2 生产者消费者（多线程同步）
```c
sem_t mutex, empty, full;
void *producer(void *arg) {
// 生产数据...
sem_wait(&empty); // 等空位
sem_wait(&mutex); // 加锁
// 放入缓冲区
sem_post(&mutex); // 解锁
sem_post(&full); // 通知消费者
}
void *consumer(void *arg) {
sem_wait(&full); // 等数据
sem_wait(&mutex); // 加锁
// 取出数据
sem_post(&mutex); // 解锁
sem_post(&empty); // 通知生产者
}
```
**⚠️ 注意顺序**：P(empty) 必须在 P(mutex) 之前！否则可能死锁。
——如果先锁 mutex 再等 empty，而缓冲区满了，生产者拿不到 empty，消费者进不来临界区拿数据，死锁。
### 5.3 Shell 基本框架
```c
while (1) {
printf("$ ");
fgets(cmdline, MAXLINE, stdin);
pid_t pid = fork();
if (pid == 0) {
// 子进程执行命令
execvp(argv[0], argv);
exit(0);
}
// 父进程等待
wait(NULL);
}
```
### 5.4 守护进程创建（5步法）
```c
// 第1步：fork + 父进程退出
pid_t pid = fork();
if (pid > 0) exit(0);
// 第2步：创建新会话
setsid();
// 第3步：再 fork 一次，防止重新获得控制终端
pid = fork();
if (pid > 0) exit(0);
// 第4步：改变工作目录
chdir("/");
// 第5步：重设文件权限掩码
umask(0);
```
**问**：为什么要 fork 两次？
**答**：第一次 fork 后 setsid() 创建新会话，但会话首进程可能重新获得控制终端。第二次 fork 的子进程不是会话首进程，**永远无法**获得控制终端。
---
## 六、问答题高频考点
### 6.1 什么是操作系统？它的四大特征是什么？
**答题模板**：
1. 操作系统是管理计算机硬件和软件资源的系统软件
2. 四大特征：并发、共享、虚拟、异步（各用一句话解释）
### 6.2 中断在操作系统中的作用？
**核心要点**：
- 中断是实现**并发执行**的基础
- **时钟中断**是操作系统**获得 CPU 控制权**的关键机制
- 中断使 CPU 能够**响应外部事件**（I/O 完成、硬件故障等）
- 系统调用通过**软中断（trap）**实现用户态→内核态切换
### 6.3 比较几种 I/O 控制方式
| 方式 | CPU介入 | 传输单位 | 并行性 | 硬件 |
|------|---------|---------|--------|------|
| 程序直接控制 | 全程忙等 | 字 | 无 | 最简单 |
| 中断驱动 | 每个字中断一次 | 字 | 有 | 较简单 |
| DMA | 每块中断一次 | 块 | 高 | 较复杂 |
| 通道 | 程序级 | 块/组 | 极高 | 最复杂 |
**记忆线索**：从上到下，CPU 越来越省事，硬件越来越复杂，传输效率越来越高。
### 6.4 什么是抖动（Thrashing）？如何解决？
**定义**：分配的页框数太少，导致频繁缺页，CPU 大部分时间花在页面置换上，利用率急剧下降。
**原因**：工作集 > 分配的页框数
**解决方案**：
1. 增加分配页框数（工作集模型）
2. 采用局部置换（不让进程互相影响）
3. 降低多道程序度
### 6.5 SPOOLing 如何将独占设备改造为共享设备？
**原理**：
```
输入井
用户进程1 ╲ ╱ 预输入程序
用户进程2 ╲── 磁盘存储 ─╱ （把磁盘当"大缓冲区"）
用户进程3 ╱ (输入/输出井) ╲ 缓输出程序
输出井
```
**核心思想**：用磁盘（共享设备）做缓冲，把独占设备（打印机）的逻辑使用变成对磁盘文件的读写。用户觉得打印机是自己的，实际上是 SPOOLing 系统在排队管理。
### 6.6 段式 vs 分页 vs 段页式
| | 分段 | 分页 | 段页式 |
|--|------|------|--------|
| 出发点 | 用户视角，逻辑模块 | 系统视角，物理管理 | 兼具两者优点 |
| 大小 | 可变（由逻辑决定） | 固定（4KB等） | 段可变，段内页固定 |
| 碎片 | 外部碎片 | 内部碎片（最后一页） | 无外部碎片 |
| 共享/保护 | 方便 | 不方便 | 方便 |
| 地址结构 | 段号+偏移 | 页号+偏移 | 段号+页号+偏移 |
| 访存次数 | 2次 | 2次（有TLB可减） | 3次 |
### 6.7 优先级反转
**场景**：高优先级进程（H）等待低优先级进程（L）持有的资源，而中等优先级进程（M）抢占了 L 的 CPU，导致 H 被 M 间接阻塞。
**解决方案**：优先级继承 — L 持有的资源被 H 需要时，L 临时继承 H 的优先级，运行完释放资源后再降回去。
---
## 七、考前速查表
### 7.1 公式速查
| 公式 | 适用场景 |
|------|---------|
| 周转时间 = 完成时间 - 到达时间 | CPU 调度 |
| 带权周转时间 = 周转时间 / 运行时间 | CPU 调度 |
| 响应比 = 1 + 等待时间 / 运行时间 | HRRF 调度 |
| EAT = λ + t + (1-a)·t | TLB 有效访问时间 |
| 每块指针数 = 块大小 / 指针大小 | inode 计算 |
| 加速比 S = T串行 / T并行 | 并行计算 |
| Amdahl: S = 1 / ((1-f) + f/P) | 并行计算加速比上限 |
| 磁盘访问时间 = 寻道 + 旋转延迟 + 传输 | I/O 性能 |
| 平均旋转延迟 = 1/2 × 转一圈时间 | 磁盘性能 |
### 7.2 数值速查
| 场景 | 典型值 |
|------|--------|
| 页大小 | 4KB |
| 块大小（Ext2） | 1KB 或 4KB |
| 指针大小（地址项） | 4B |
| 时间片（RR） | 几十 ms 级别 |
| 7200RPM 旋转延迟 | 4.17ms（半圈） |
### 7.3 算法时间复杂度速查
| 算法/机制 | 数据结构 | 复杂度 |
|-----------|---------|--------|
| FCFS 调度 | 队列 | O(1) |
| SJF 调度 | 最小堆 | O(log n) |
| CFS（Linux） | 红黑树 | O(log n) |
| 页表查找（无 TLB） | 数组 | O(1) |
| 多级页表 | 树 | O(级数) |
| 倒排页表 | 哈希表 | O(1)平均 |
### 7.4 Linux 常用命令速查
```bash
chmod 755 file # rwxr-xr-x (7=4+2+1, 5=4+1)
chmod u+x file # 给所有者加执行权限
ps -ef # 查看所有进程
top # 动态查看进程
kill -9 PID # 强制终止进程（SIGKILL）
grep pattern file # 搜索文件内容
strace ./prog # 跟踪系统调用
gdb ./prog # 调试程序
```
---
## 附录：考前最后一天做什么
### 8小时冲刺计划
```
第1小时：复习四大计算题模板（本笔记 2.1-2.4）
第2小时：做预测卷的计算题部分
第3小时：复习进程树分析和代码题（第五部分）
第4小时：做预测卷的代码分析题
第5小时：复习概念辨析和问答题（第三、四、六部分）
第6小时：做预测卷的问答题
第7小时：错题回顾 + 速查表记忆
第8小时：放松！早点休息
```
### 考场检查清单
- ✅ 计算题先做（分值高、确定性大）
- ✅ 画进程树时标注字母/输出
- ✅ 缺页次数计算时，初始空页框**算**缺页
- ✅ SCAN/C-SCAN 注意方向
- ✅ CPU 调度画甘特图辅助
- ✅ 地址转换要写出每一步的数值
- ✅ 简答题分点作答，关键词突出
---
> **最后的话**：操作系统不是死记硬背的科目，理解"为什么"比记住"是什么"重要得多。
> 遇到问题时，想想"如果是 Linux，它会怎么做？"——这是最好的学习方式。
>
> 祝考试顺利！🎯

626
操作系统/期末知识点总结与考点分析.md Normal file
View File

@@ -0,0 +1,626 @@
# 操作系统期末知识点总结与考点分析
## 一、历年试卷考点频率统计
| 考点 | 20-21A | 21-22A | 2023A | 2025A | 频率 |
|------|--------|--------|-------|-------|------|
| 磁盘调度算法 | ✓ | ✓ | ✓ | ✓ | ★★★★★ |
| 虚拟内存页面置换 | ✓ | ✓ | ✓ | ✓ | ★★★★★ |
| 进程控制(fork) | ✓ | ✓ | ✓ | ✓ | ★★★★★ |
| CPU调度算法 | ✓ | - | ✓ | ✓ | ★★★★ |
| 文件系统(Ext2/inode) | - | ✓ | ✓ | ✓ | ★★★★ |
| I/O控制方式 | ✓ | - | - | ✓ | ★★★ |
| 段页式地址转换 | ✓ | ✓ | - | - | ★★★ |
| 银行家算法 | ✓ | - | - | - | ★★ |
| 工作集模型 | ✓ | ✓ | ✓ | - | ★★★ |
| 代码优化 | - | ✓ | ✓ | - | ★★ |
| 系统运行机制 | - | - | ✓ | - | ★★ |
| 多级反馈队列 | - | - | ✓ | - | ★★ |
---
## 二、各章核心知识点总结
### 第1章：操作系统概述
**考点：OS基本概念、发展历史、结构**
- **四大特征**：并发、共享、虚拟、异步
- **OS结构类型**：
- 单体结构（Linux）：所有服务在内核态运行，性能好但耦合度高
- 分层结构：按层次组织，便于调试但层间通信开销大
- 微内核结构：内核只保留最基本功能，其余在用户态运行，可靠性高但性能差
- 虚拟机结构：在硬件上运行多个OS实例
---
### 第2章：系统运行机制
**考点：中断、MMU、CPU双模式、系统调用**
- **中断机制**：
- 硬中断：外部设备产生，异步
- 软中断（异常）：CPU内部产生，同步（除零错误、缺页异常、系统调用）
- **时钟中断**：OS获得CPU控制权的关键机制
- **MMU地址转换**：
- 逻辑地址 → 物理地址的硬件支持
- U/S位：用户态/内核态标识，实现内存保护
- **CPU双模式**：
- 用户态（目态）→ 内核态（管态）：通过中断/异常/系统调用
- 内核态 → 用户态：通过PSW（程序状态字）切换
- **系统调用流程**：
```
用户程序 → 系统调用号放入EAX → int $0x80 → 内核态
→ 查系统调用表 → 执行服务程序 → 返回用户态
```
---
### 第3章：Linux基础
**考点：目录结构、文件权限、/proc文件系统**
- **目录结构**：/bin, /etc, /home, /proc, /dev, /tmp
- **文件权限**：chmod 数字法（r=4, w=2, x=1）
- **/proc文件系统**：虚拟文件系统，提供进程和内核信息
---
### 第4章：C语言开发基础
**考点：编译流程、ELF内存布局、调试**
- **编译流程**：预处理 → 编译 → 汇编 → 链接
- **ELF内存布局**（从低到高）：
```
.text（代码段）
.rodata（只读数据）
.data（已初始化全局变量）
.bss（未初始化全局变量，不占磁盘空间）
heap（堆，向上增长 ↗）
↓
stack（栈，向下增长 ↘）
```
- **关键区别**：.bss不占磁盘空间但占内存空间（运行时分配）
---
### 第5-6章：文件I/O
**考点：UNIX IO、文件描述符共享、mmap、重定向**
- **UNIX IO函数**：open/read/write/close/lseek
- **文件描述符表共享**：
```
进程fd表 → 文件表（引用计数） → v-node表（共享）
fork后父子进程共享文件表，引用计数+1
```
- **mmap内存映射**：将文件映射到进程地址空间，实现高效I/O
- **dup2重定向**：实现I/O重定向的标准方法
- **stdio vs UNIX IO缓冲**：
- stdio有用户缓冲区（全缓冲/行缓冲/无缓冲）
- UNIX IO无用户缓冲区
---
### 第7章：磁盘空间管理 ★★★★★必考
**考点：分配方式、Ext2文件系统、inode混合索引**
- **三种分配方式**：
- 连续分配：支持顺序/随机访问，有外部碎片
- 链接分配：无外部碎片，只支持顺序访问，FAT是改进
- 索引分配：支持直接/间接访问，inode是典型实现
- **FAT文件系统**：FAT12/16/32，链接分配的改进版本
- **NTFS**：基于MFT（主文件表），B+树结构
- **Ext2文件系统**（重点）：
```
超级块 → 块组描述符 → 块位图 → inode位图 → inode表 → 数据块
```
- **inode结构**：15个地址项
- 0-11：直接索引（12个块）
- 12：一次间接索引（256个块，假设块大小1KB，指针4字节）
- 13：二次间接索引（256×256个块）
- 14：三次间接索引（256³个块）
- **最大文件计算**：
```
块大小=1KB，指针=4B，则每块256个指针
直接：12块
一次间接：256块
二次间接：256×256=65536块
三次间接：256³=16777216块
总计：12+256+65536+16777216 ≈ 16GB+
```
- **HDFS**：分布式文件系统，NameNode+DataNode架构
- **空闲空间管理**：位图法、成组链接法
- **RAID**：
- RAID0：条带化，无冗余
- RAID1：镜像，100%冗余
- RAID3：位交叉+专用校验盘
- RAID5：块交叉+分布式校验
---
### 第8章：进程控制 ★★★★★必考
**考点：fork/exec/wait/exit、僵尸进程、shell实现**
- **fork()**：
- 调用一次，返回两次（父进程返回子进程PID，子进程返回0）
- **COW（写时复制）**：父子进程共享物理页，写时才复制
- fork后文件描述符共享（引用计数+1）
- **exec系列函数**：替换进程映像，不创建新进程
- **wait/waitpid**：
- 阻塞等待子进程状态变化
- 回收子进程资源，防止僵尸进程
- **exit/_exit**：
- exit：执行清理（刷新缓冲区、调用atexit处理函数）
- _exit：直接退出，不执行清理
- **僵尸进程**：
- 子进程exit但父进程未wait
- 解决方法：父进程调用wait/waitpid，或SIGCHLD信号处理
- **shell实现**：
```c
// 基本框架
while (1) {
读取命令行
解析命令
if (内置命令) 直接执行
else {
pid = fork()
if (pid == 0) execvp(...) // 子进程执行
else wait(NULL) // 父进程等待
}
}
```
- **守护进程（daemon）创建5步**：
1. fork()创建子进程，父进程exit
2. setsid()创建新会话
3. fork()再次fork，父进程exit（防止重新获得控制终端）
4. chdir("/")改变工作目录
5. umask(0)重设文件权限掩码
---
### 第9章：多线程 ★★★★
**考点：pthread API、竞态条件、互斥锁、信号量、生产者消费者**
- **pthread API**：
```c
pthread_create() // 创建线程
pthread_join() // 等待线程结束
pthread_exit() // 退出线程
pthread_detach() // 分离线程
```
- **竞态条件（Race Condition）**：
- 多线程并发访问共享数据，结果取决于执行顺序
- 解决：互斥锁、信号量
- **互斥锁（Mutex）**：
```c
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mutex); // 加锁
// 临界区
pthread_mutex_unlock(&mutex); // 解锁
```
- **信号量（Semaphore）**：
- P操作（wait）：S--，若S<0则阻塞
- V操作（signal）：S++，若有等待者则唤醒
- **实现同步和互斥**
- **生产者消费者模型**：
```
信号量：
mutex = 1 // 互斥访问缓冲区
empty = N // 空闲缓冲区数量
full = 0 // 满缓冲区数量
生产者： 消费者：
P(empty) P(full)
P(mutex) P(mutex)
放入产品 取出产品
V(mutex) V(mutex)
V(full) V(empty)
```
- **并行计算**：
- 加速比 S = T_serial / T_parallel
- 效率 E = S / P（P为处理器数量）
- Amdahl定律：S = 1 / ((1-f) + f/P)
---
### 第10章：进程间通信IPC
**考点：管道、消息队列、共享内存、信号**
- **管道**：
- 匿名管道：只能用于父子进程，单向通信
- 命名管道FIFO：可用于无亲缘关系进程
- **消息队列**：内核中的链表，按消息类型读取
- **共享内存**：最快的IPC方式，需要同步机制保护
- **信号**：异步通知机制，SIGINT/SIGTERM/SIGCHLD等
---
### 第11章：网络编程
**考点：Socket API、TCP客户端服务器模型**
- **Socket API**：
```c
// 服务器
socket() → bind() → listen() → accept() → read/write → close()
// 客户端
socket() → connect() → read/write → close()
```
- **字节序转换**：htonl/htons/ntohl/ntohs
---
### 第12章：并发服务器
**考点：多进程/多线程模型、I/O多路复用、线程池**
- **多进程模型**：fork per request，简单但开销大
- **多线程模型**：pthread_create per request，开销较小
- **I/O多路复用（select）**：
```c
fd_set read_set;
FD_ZERO(&read_set);
FD_SET(fd, &read_set);
select(maxfd+1, &read_set, NULL, NULL, NULL);
```
- **线程池**：预先创建线程，减少创建/销毁开销
---
### 第13章：CPU调度 ★★★★
**考点：调度算法计算、优先级反转、CFS**
- **三级调度**：高级调度（作业调度）、中级调度（内存调度）、低级调度（进程调度）
- **调度算法**：
- **FCFS**（先来先服务）：简单，对长作业有利
- **SJF/SRTF**（最短作业优先/最短剩余时间优先）：平均等待时间最短，但可能饥饿
- **HRRF**（最高响应比优先）：响应比 = 1 + 等待时间/运行时间
- **RR**（时间片轮转）：时间片太大退化为FCFS，太小上下文切换开销大
- **MFQ**（多级反馈队列）：综合了多种算法优点
- **优先级调度**：可能导致低优先级饥饿
- **优先级反转**：高优先级进程等待低优先级进程持有的资源
- 解决方案：优先级继承协议
- **EDF**（最早截止时间优先）：实时调度
- **LLF**（最低松弛度优先）：松弛度 = 截止时间 - 剩余执行时间
- **CFS**（完全公平调度）：Linux默认
- vruntime（虚拟运行时间）
- 红黑树组织运行队列
- **调度公式**：
```
周转时间 = 完成时间 - 到达时间
带权周转时间 = 周转时间 / 运行时间
平均周转时间 = Σ周转时间 / n
```
---
### 第14章：死锁 ★★★
**考点：必要条件、资源分配图、银行家算法**
- **四个必要条件**：
1. 互斥条件
2. 请求和保持条件
3. 不可抢占条件
4. 循环等待条件
- **资源分配图**：检测死锁的图形化方法
- **银行家算法**：
```
Available: 系统可用资源向量
Max: 进程最大需求矩阵
Allocation: 已分配矩阵
Need = Max - Allocation: 还需要矩阵
安全性检查：
1. Work = Available, Finish = false
2. 找一个 Need ≤ Work 且 Finish=false 的进程
3. Work += Allocation, Finish = true
4. 重复直到所有 Finish=true（安全）或找不到（不安全）
```
- **死锁处理**：
- 预防：破坏四个必要条件之一
- 避免：银行家算法
- 检测：资源分配图
- 恢夺：终止进程或资源抢占
---
### 第15章：内存管理 ★★★★
**考点：地址转换、页表、TLB、多级页表、段页式**
- **逻辑地址 vs 物理地址**
- **分页管理**：
- 虚拟页号(VPN) + 页内偏移(VPO)
- 物理帧号(PPN) + 帧内偏移(PPO)
- 页表项：有效位、脏位、引用位、R/W位、U/S位
- **缺页处理**：
```
访问页表 → 有效位=0 → 缺页异常
→ 选择牺牲页（若修改过则写回磁盘）
→ 从磁盘调入新页
→ 更新页表 → 重新执行指令
```
- **TLB（快表）**：
```
有效访问时间 EAT = λ + t + (1-a)·t
λ: TLB访问时间
t: 内存访问时间
a: TLB命中率
```
- **多级页表**：减少页表占用的连续内存
- 二级页表：VPN分为两部分，第一级索引页目录，第二级索引页表
- **倒排页表**：按物理帧组织，减少内存占用但查找慢
- **段页式**：三维地址（段号 + 页号 + 页内偏移）
---
### 第16章：虚拟内存 ★★★★★必考
**考点：页面置换算法、工作集、抖动**
- **请求调页**：访问时才调入页面
- **局部性原理**：
- 时间局部性：最近访问的数据可能再次访问
- 空间局部性：相邻地址可能被访问
- **页面置换算法**（重点中的重点）：
- **OPT**（最优算法）：替换将来最长时间不使用的页面，理论最优但不可实现
- **FIFO**（先进先出）：可能产生**Belady异常**（增加页框数反而增加缺页次数）
- **LRU**（最近最久未使用）：替换最长时间未使用的页面，无Belady异常
- **Clock算法**：LRU的近似，检查引用位
- **LFU**（最不经常使用）：替换访问次数最少的页面
- **抖动（Thrashing）**：
- 分配的页框数太少，频繁缺页
- 工作集 > 分配的页框数
- **工作集模型**：
```
工作集 W(t, Δ) = 在时刻t前Δ时间窗口内访问的页面集合
Δ: 工作集窗口大小
```
- 若 W(t,Δ) > 分配页框数 → 抖动
- **内存分配策略**：
- 固定分配 vs 可变分配
- 全局置换 vs 局部置换
---
### 第17章：I/O系统 ★★★
**考点：I/O控制方式、缓冲、磁盘调度**
- **四种I/O控制方式**：
1. **程序直接控制**：CPU忙等，效率最低
2. **中断驱动**：CPU不必忙等，但每次传输一个字
3. **DMA**：直接内存访问，以块为单位传输
4. **通道**：独立的I/O处理器，执行通道程序
- **I/O软件层次**：
```
用户层I/O软件
↓
设备独立性软件
↓
设备驱动程序
↓
中断处理程序
↓
硬件
```
- **缓冲**：
- 单缓冲、双缓冲、循环缓冲、缓冲池
- **SPOOLing**：假脱机技术，将独占设备改为共享设备
- **磁盘调度算法**（必考）：
- **FCFS**：简单但移动距离长
- **SSTF**（最短寻道时间优先）：可能饥饿
- **SCAN**（电梯算法）：双向扫描到边界
- **C-SCAN**：单向扫描，返回时快速移动
- **LOOK/C-LOOK**：改进版，不到达边界
- **磁盘访问时间**：
```
访问时间 = 寻道时间 + 旋转延迟 + 传输时间
```
---
### 第18章：代码优化
**考点：CPE、代码移动、消除别名、循环展开**
- **CPE**（每元素周期数）：衡量循环性能
- **优化技术**：
1. **代码移动**：将循环不变量移到循环外
2. **消除过程调用**：用内联代码替代函数调用
3. **减少内存引用**：使用局部变量累积，最后写回
4. **消除指针别名**：使用restrict关键字或引入局部变量
5. **循环展开**：减少循环控制开销
6. **SIMD**：单指令多数据流
- **指针别名问题**：
```c
void twiddle1(int *xp, int *yp) {
*xp += *yp;
*xp += *yp;
}
// 若xp==yp，结果是4倍；否则是2倍
// 引入局部变量可消除别名影响
```
---
## 三、高频计算题型总结
### 1. 磁盘调度计算（每年必考）
**题型**：给定磁道请求序列和磁头初始位置，计算各算法的磁头移动总道数
**解题模板**：
```
请求序列：98,183,37,122,14,124,65,67
初始位置：53
FCFS: 53→98→183→37→122→14→124→65→67
SSTF: 53→65→67→37→14→98→122→124→183
SCAN: 53→37→14→0→65→67→98→122→124→183
C-SCAN: 53→65→67→98→122→124→183→0→14→37
```
---
### 2. 虚拟内存页面置换（每年必考）
**题型**：给定页面访问序列和页框数，计算各算法的缺页次数
**解题模板**：
```
访问序列：7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1
页框数：3
OPT: 替换将来最长时间不用的
FIFO: 替换最早进入的
LRU: 替换最长时间未使用的
```
---
### 3. fork进程树分析（每年必考）
**题型**：分析fork()调用序列，画出进程树
**关键规则**：
- fork()创建子进程，子进程从fork处继续执行
- 进程总数 = 2^n（n为fork调用次数，假设无嵌套）
- 嵌套fork需仔细跟踪每个进程的执行路径
---
### 4. CPU调度计算
**题型**：给定进程到达时间和运行时间，计算各算法的周转时间
**公式**：
```
周转时间 = 完成时间 - 到达时间
带权周转时间 = 周转时间 / 运行时间
```
---
### 5. Ext2 inode最大文件计算
**题型**：给定块大小和指针大小，计算单个inode支持的最大文件
**公式**：
```
每块指针数 = 块大小 / 指针大小
直接索引：12块
一次间接：块指针数
二次间接：块指针数²
三次间接：块指针数³
```
---
### 6. TLB有效访问时间计算
**题型**：给定TLB访问时间、内存访问时间、TLB命中率，计算EAT
**公式**：
```
EAT = λ + t + (1-a)·t
```
---
### 7. 银行家算法
**题型**：给定资源分配状态，判断是否安全
**步骤**：
1. 计算Need矩阵 = Max - Allocation
2. 执行安全性检查算法
3. 判断是否存在安全序列
---
## 四、2026年考试预测
### 必考题型（概率>90%）：
1. 磁盘调度算法计算（SSTF/SCAN/C-SCAN）
2. 虚拟内存页面置换（OPT/FIFO/LRU）
3. fork进程树分析
4. 文件系统inode计算或Ext2结构分析
### 高概率题型（概率60-90%）：
5. CPU调度算法（HRRF或SJF）
6. I/O控制方式比较
7. 段页式地址转换
### 可能题型（概率30-60%）：
8. 银行家算法安全性检查
9. 代码优化（别名问题、循环展开）
10. 工作集模型与抖动分析
11. 多线程同步（生产者消费者）
---
## 五、复习建议
1. **重点掌握计算题**：磁盘调度、页面置换、CPU调度、inode计算必考
2. **理解fork机制**：画进程树是每年必考题型
3. **掌握基本概念**：I/O控制方式、死锁条件、虚拟内存原理
4. **练习画图**：进程树、资源分配图、地址转换过程
5. **熟悉公式**：EAT、CPI、周转时间、响应比等

BIN
操作系统/试卷/20-21操作系统a卷.pdf Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2023A卷参考答案.pdf Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2023B卷参考答案.docx Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2023年A卷(统稿）.pdf Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2023年B卷(统稿）.doc Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2025年A卷试卷.pdf Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2025年B卷试卷.pdf Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2025操作系统A卷参考答案.pdf Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/2025操作系统B卷参考答案及评分标准.docx Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/21-22网安学院操作系统A卷.pdf Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/4cec9c0a5e1b0615426df487f9a6716d.docx Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/d6fdbce11aa9feef6f246e73ed09a00e.docx Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/f9c2aa5324dd828dfa7840fc2458f98d.doc Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/操作系统期中考试参考答案2025-2026-2.docx Normal file
View File

Binary file not shown.

BIN
操作系统/试卷/操作系统期中考试试卷.pdf Normal file
View File

Binary file not shown.