# 📖 操作系统复习与教学笔记

> **目标**：不仅能应付考试，更能真正理解操作系统的工作原理
> **定位**：这份笔记不是简单的知识点罗列，而是教你"怎么学、怎么记、怎么做题"

---

## 目录

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，它会怎么做？"——这是最好的学习方式。
>
> 祝考试顺利！🎯