操作系统
这篇笔记讲什么
操作系统(Operating System, OS)是硬件之上、应用程序之下的那层管理者。
它把 CPU、内存、磁盘、网卡这些「一堆互相打架的硬件」变成程序员可以放心使用的抽象:
进程、虚拟地址空间、文件、套接字。
本文按「抽象 → 并发 → 内存 → 存储 → IO」的主线走一遍:
用户态/内核态与系统调用、进程与线程、调度算法(含等待/周转时间手算)、
信号量与死锁(银行家算法)、分页与虚拟内存(FIFO/LRU/Clock 与 Belady 异常)、
inode 与磁盘调度、五种 IO 模型,最后附一份 Linux 实操命令清单。
读完你应该能:看懂
top的每一项、解释为什么会有死锁、给一个场景选出合适的调度与置换算法。
一、这是什么
操作系统是管理计算机硬件资源、并为应用程序提供运行环境的系统软件。它向上下两个方向各提供一套接口:
| 方向 | 提供服务 | 例子 |
|---|---|---|
| 向下(对硬件) | 资源管理 | 分配 CPU 时间片、分配/回收物理页、驱动磁盘与网卡 |
| 向上(对程序) | 抽象接口 | 进程/线程、虚拟内存、文件、套接字、系统调用 |
它的三大核心职责:
- 进程管理:创建、调度、同步、通信、销毁。
- 内存管理:地址映射、分配回收、虚拟内存、保护与共享。
- 文件与 IO 管理:文件抽象、目录树、缓冲、设备驱动、中断处理。
内核(Kernel)不等于操作系统
严格说,内核是操作系统的核心,负责上述职责;而「操作系统」通常还包含 Shell、系统库、常用工具。
Ubuntu、CentOS 是发行版(Distribution),Linux 是内核。这个区分在排查问题时很重要:
「Linux 崩了」通常是内核 panic,「Ubuntu 崩了」可能只是某个用户态服务挂了。
二、为什么需要它
如果没有操作系统,写一个「同时读键盘、写磁盘、算数」的程序会是这样:
- 你得自己写磁盘驱动、自己处理中断、自己安排寄存器;
- 你的程序可以随意读写别人的内存,一个 bug 就搞崩整台机器;
- 你想同时做两件事,只能手写状态机,没有任何公平性保障。
操作系统解决的核心问题可以归为四类:
| 问题 | 没有 OS 的后果 | OS 的解法 |
|---|---|---|
| 资源有限 | 只能跑一个程序 | 多道程序、时间片、调度 |
| 隔离与保护 | 程序互相破坏 | 用户态/内核态、虚拟地址空间 |
| 抽象复杂 | 每个程序都要写驱动 | 文件、套接字、统一系统调用接口 |
| 并发正确性 | 数据竞争、死锁 | 信号量、互斥锁、管程、内存屏障 |
一句话动机
操作系统的本质是在有限的硬件上,用可控的开销换取「多任务、隔离、易用」。
后面所有机制(页表、调度器、文件系统)都是在这个约束下的工程折中。
三、操作系统的演化
| 阶段 | 形态 | 特征 | 局限 |
|---|---|---|---|
| 手工操作 | 插线板 / 纸带 | 无 OS,人工切换 | 利用率极低 |
| 批处理 | Batch System | 作业成批提交,监控程序自动切换 | 无交互、CPU 与 IO 不能重叠 |
| 多道批处理 | Multiprogramming | 内存同时放多个作业,IO 时切换 | 仍无交互,响应慢 |
| 分时系统 | Time-Sharing | 时间片轮转,多用户交互 | 需要时钟中断与保护机制 |
| 实时系统 | Real-Time | 硬实时(工业控制)必须满足截止期 | 调度复杂,吞吐量不是目标 |
| 个人/网络/分布式 | PC、云、容器 | 图形界面、虚拟化、微服务 | 隔离边界与性能开销的权衡 |
驱动演化的两条主线:提高资源利用率 与 缩短响应时间,两者经常互相矛盾。
单体内核 vs 微内核
Linux 是单体内核(Monolithic Kernel):文件系统、驱动、网络栈都在内核态,调用直接、性能好,但一个驱动 bug 就可能 panic。
Minix、QNX、seL4 是微内核(Microkernel):内核只保留最基础的调度与 IPC,驱动在用户态,隔离好、可靠性高,代价是 IPC 开销。
macOS 的 XNU 是混合内核(Mach + BSD)。这一取舍至今仍有争议。
四、用户态与内核态、系统调用
4.1 两种特权级
CPU 提供至少两种特权级(x86-64 有 Ring 0~3,实际只用 Ring 0 与 Ring 3):
| 对比项 | 用户态(User Mode) | 内核态(Kernel Mode) |
|---|---|---|
| 权限 | 不能执行特权指令 | 可执行所有指令 |
| 可见内存 | 只能访问自己的虚拟地址空间 | 可访问全部物理内存与内核空间 |
| 典型指令 | 算术、跳转、普通访存 | cli/sti、hlt、修改页表基址、IO 端口读写 |
| 犯错后果 | 自己进程被终止(Segmentation Fault) | 整机崩溃(Kernel Panic) |
| 谁在运行 | 应用程序、库 | 内核代码、驱动 |
态切换(Mode Switch) 通常通过三种入口发生:系统调用(主动)、中断(异步)、异常(同步,如缺页、除零)。
4.2 系统调用(System Call)
系统调用是用户程序请求内核服务的唯一正式入口。一次调用的开销来自:
- 切换到内核栈、保存寄存器现场;
- 参数校验与权能检查(
copy_from_user等); - 执行内核逻辑;
- 恢复现场、返回用户态(可能触发调度)。
系统调用很贵
一次系统调用的量级是 数百纳秒到数微秒(还受 Spectre/Meltdown 缓解措施影响)。
所以:逐字节
read()读文件是灾难;日志要批量刷盘;网络 IO 要用缓冲区聚包。
/* syscall_demo.c —— 亲手调用 write(2) 与 getpid(2),观察返回值与 errno
* 编译:gcc -O2 -Wall -o syscall_demo syscall_demo.c
*/
#include <unistd.h> /* write, getpid */
#include <errno.h>
#include <string.h>
#include <stdio.h>
int main(void) {
/* 系统调用失败时返回 -1 并设置 errno,绝不要忽略返回值 */
const char *msg = "hello from write(2)\n";
ssize_t n = write(STDOUT_FILENO, msg, strlen(msg));
if (n == -1) {
fprintf(stderr, "write 失败: %s\n", strerror(errno));
return 1;
}
/* write 可能「短写」:只写回一部分,健壮的代码必须循环到全部写完 */
printf("本次实际写入 %zd 字节,pid=%d\n", n, (int)getpid());
/* 故意触发一个错误,看看 errno 长什么样 */
if (write(-1, "x", 1) == -1) {
printf("对非法 fd 写入失败,errno=%d (%s)\n", errno, strerror(errno)); /* EBADF=9 */
}
return 0;
}
下面的命令可以观察程序到底调用了哪些系统调用——排查性能问题的第一手段:
# 统计某命令的系统调用次数与耗时分布
strace -c -f ./syscall_demo
# 只看文件相关的调用,并打印时间戳
strace -e trace=openat,read,write -tt ./syscall_demo
# 直接查系统调用的手册页(第 2 节 = 系统调用,第 3 节 = 库函数)
man 2 write
man 3 printf
五、进程与线程
5.1 进程是什么
进程(Process)是程序的一次执行实例,是资源分配的基本单位。它拥有:
- 独立的虚拟地址空间(代码段、数据段、堆、栈、共享库映射);
- 一组资源句柄(打开的文件描述符、信号处理、套接字);
- 至少一个执行流(主线程)。
线程(Thread)是 CPU 调度的基本单位,同一进程内的线程共享地址空间与文件描述符,但各自有独立的栈、寄存器现场与线程局部存储(TLS)。
/* fork_demo.c —— fork 创建进程、pthread 创建线程:观察地址空间是否共享
* 编译:gcc -O2 -Wall -pthread -o fork_demo fork_demo.c
*/
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>
static int g_counter = 0;
static void *thread_fn(void *arg) {
(void)arg;
g_counter += 100; /* 线程共享全局变量,能改到 */
printf("[线程] 修改全局变量后 g_counter=%d,地址=%p\n", g_counter, (void *)&g_counter);
return NULL;
}
int main(void) {
/* ---- 进程:写时复制(Copy-On-Write),父子互不影响 ---- */
int local = 1;
pid_t pid = fork();
if (pid == 0) {
local = 999; /* 只改自己那份副本 */
g_counter = 999;
printf("[子进程] local=%d\n", local);
_exit(0); /* 子进程用 _exit,避免重复刷新 stdio 缓冲 */
}
waitpid(pid, NULL, 0);
printf("[父进程] local=%d g_counter=%d(fork 后子进程的修改不可见)\n", local, g_counter);
/* ---- 线程:共享地址空间 ---- */
pthread_t t;
pthread_create(&t, NULL, thread_fn, NULL);
pthread_join(t, NULL);
printf("[主线程] 线程改过的 g_counter=%d(可见)\n", g_counter);
return 0;
}
5.2 进程 vs 线程对比
| 对比项 | 进程(Process) | 线程(Thread) |
|---|---|---|
| 地址空间 | 独立,互相隔离 | 共享同一地址空间 |
| 创建/切换开销 | 大(要切页表、刷 TLB,微秒级) | 小(同一地址空间,约几百纳秒~微秒) |
| 通信方式 | 管道、消息队列、共享内存、套接字、信号 | 直接读写共享变量(需同步) |
| 隔离性与健壮性 | 一个崩溃不影响其他 | 一个线程段错误,整个进程退出 |
| 资源占用 | 每进程有独立页表、fd 表 | 共享页表与 fd 表,仅独立栈与 TLS |
| 适用场景 | 需要强隔离(浏览器多标签、Chrome 架构) | 需要高并发低开销(IO 密集、计算并行) |
切换开销的真实来源
进程切换贵,主要不是因为「保存寄存器」,而是:
① 换页表基址(CR3)后 TLB 失效,后续访存要重新走页表;
② 缓存局部性被破坏(Cache Pollution)。
所以高并发服务器普遍用「少量进程 + 每进程多线程」或「线程池 + 事件循环」。
5.3 进程状态机与 PCB
五状态模型:
| 状态 | 英文 | 说明 |
|---|---|---|
| 新建 | New | 正在创建,尚未进入就绪队列 |
| 就绪 | Ready | 万事俱备,只等 CPU |
| 运行 | Running | 正在 CPU 上执行(单核同一时刻只有一个) |
| 阻塞 | Blocked / Waiting | 等待事件(IO 完成、锁、信号),给 CPU 也不要 |
| 终止 | Terminated | 已结束,等待父进程回收(僵尸态) |
合法的状态迁移:
新建 --接纳--> 就绪 --调度--> 运行 --时间片用完--> 就绪
运行 --请求IO/等待事件--> 阻塞 --事件完成--> 就绪
运行 --退出--> 终止
非法迁移
「阻塞 → 运行」是非法的:被唤醒的进程只能进入就绪队列,必须重新参与调度。
「就绪 → 阻塞」也是非法的:没在运行就不可能发起 IO 请求。
PCB(Process Control Block,进程控制块) 是内核中描述进程的数据结构(Linux 里是 struct task_struct):
| 字段类别 | 内容 |
|---|---|
| 标识 | PID、PPID、UID/GID、进程组、会话 |
| 状态 | 运行态/就绪/阻塞、退出码、信号 |
| 调度信息 | 优先级、nice 值、时间片、调度类(CFS 的 vruntime) |
| 内存 | 页表基址、mm_struct、栈指针 |
| 文件 | 打开文件表、当前工作目录、umask |
| 上下文 | 寄存器现场、程序计数器、内核栈指针 |
# 查看进程的 PCB 信息(Linux 把很多字段暴露在 /proc 下)
cat /proc/self/status # 人类可读的进程状态汇总
ls /proc/self/task/ # 该进程的所有线程(TID)目录
cat /proc/self/maps # 虚拟地址空间布局
ps -eLf | head # -L 显示线程(LWP 列)
ps -eo pid,ppid,stat,ni,cmd | head
六、CPU 调度算法
6.1 评价指标
其他指标:响应时间(首次获得 CPU 的等待)、吞吐量(单位时间完成作业数)、CPU 利用率、公平性。
6.2 算法对比
| 算法 | 英文 | 抢占 | 优点 | 缺点 | 饥饿 |
|---|---|---|---|---|---|
| 先来先服务 | FCFS | 否 | 简单、公平(按到达序) | 护航效应:长作业堵住短作业 | 无 |
| 短作业优先 | SJF / SRTF | SJF 否,SRTF 是 | 平均等待时间最优(可证明) | 需预知运行时间;长作业可能饿死 | 有 |
| 时间片轮转 | RR | 是 | 响应快,适合分时 | 时间片太小切换开销大,太大退化成 FCFS | 无 |
| 优先级 | Priority | 可抢占/非抢占 | 可表达重要性 | 低优先级饥饿 | 有(可用老化解决) |
| 多级反馈队列 | MLFQ | 是 | 无需预知运行时间,兼顾交互与批处理 | 参数多、难调优 | 可用老化避免 |
时间片的选择
时间片 必须远大于上下文切换开销,否则切换本身会吃掉大部分 CPU。
经验: 取 10~100 ms,切换开销约几微秒,比例控制在 1% 以内。
若 ,RR 退化为 FCFS。
6.3 手算示例(务必自己算一遍)
设 4 个进程,同时(时刻 0)到达,服务时间如下:
| 进程 | 服务时间 |
|---|---|
| P1 | 5 |
| P2 | 4 |
| P3 | 1 |
| P4 | 6 |
FCFS(按 P1→P2→P3→P4):
| 进程 | 完成时刻 | 周转时间 | 等待时间 |
|---|---|---|---|
| P1 | 5 | 5 | 0 |
| P2 | 9 | 9 | 5 |
| P3 | 10 | 10 | 9 |
| P4 | 16 | 16 | 10 |
| 平均 | — | 10.0 | 6.0 |
SJF(按 P3(1) → P2(4) → P1(5) → P4(6)):
| 进程 | 完成时刻 | 周转时间 | 等待时间 |
|---|---|---|---|
| P3 | 1 | 1 | 0 |
| P2 | 5 | 5 | 1 |
| P1 | 10 | 10 | 5 |
| P4 | 16 | 16 | 10 |
| 平均 | — | 8.0 | 4.0 |
RR(时间片 ) 的执行序列(没跑完的进程回到队尾,新到达的排在队尾):
| 时间片 | 0-2 | 2-4 | 4-5 | 5-7 | 7-9 | 9-11 | 11-13 | 13-15 | 15-17 | 17-18 | 18-20 | 20-22 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 运行 | P1 | P2 | P3✔ | P4 | P1 | P2 | P1 | P4 | P2✔ | P1✔ | P4 | P4✔ |
(✔ 表示该进程在本片结束时完成;P3 只需 1 个时间单位,所以第一片就结束了)
| 进程 | 完成时刻 | 周转时间 | 等待时间 |
|---|---|---|---|
| P1 | 18 | 18 | 13 |
| P2 | 17 | 17 | 13 |
| P3 | 5 | 5 | 4 |
| P4 | 22 | 22 | 16 |
| 平均 | — | 15.5 | 11.5 |
从这组数字能读出什么
RR 的平均周转时间(15.5)明显差于 FCFS(10.0)与 SJF(8.0),但它的首次响应时间最好:
FCFS 下 P4 要等到时刻 10 才开始跑;RR 下 P4 在时刻 5 就拿到了第一个时间片,P3 甚至在时刻 4 就跑完了。
这说明:没有一种算法在所有指标上都最优,选择取决于你更在意吞吐量还是交互体验。
这也是 Linux 用 CFS(完全公平调度)而不是 SJF 的原因——服务器要的是公平与低延迟,而不是最短平均周转。
"""schedulers.py —— FCFS / SJF(SRTF) / RR 调度模拟,可直接运行"""
from collections import deque
def simulate_fcfs(procs):
"""procs: [(名字, 到达时间, 服务时间)],按到达时间排序后依次执行"""
t, out = 0, []
for name, arrive, burst in sorted(procs, key=lambda p: p[1]):
t = max(t, arrive) # CPU 可能空闲等待到达
t += burst
out.append((name, t, t - arrive, t - arrive - burst))
return out
def simulate_sjf(procs, preemptive=False):
"""SJF(非抢占)与 SRTF(抢占):每次都挑剩余时间最短的就绪作业
抢占版按「1 个时间单位」推进,这样新作业一到达就能参与比较;
非抢占版则一次把当前作业跑完,中途到达的作业只能等下一轮。
"""
burst = {n: b for n, _, b in procs}
arrive = {n: a for n, a, _ in procs}
remain = dict(burst)
t, out = 0, []
while len(out) < len(procs):
ready = [n for n in remain if arrive[n] <= t and remain[n] > 0]
if not ready:
t = min(arrive[n] for n in remain if remain[n] > 0) # 跳到下一个到达时刻
continue
cur = min(ready, key=lambda n: remain[n]) # 选剩余时间最短者
run = remain[cur] if not preemptive else 1 # 非抢占跑完,抢占只跑 1 个时间单位
t += run
remain[cur] -= run
if remain[cur] == 0:
out.append((cur, t, t - arrive[cur], t - arrive[cur] - burst[cur]))
return sorted(out, key=lambda r: r[1]) # 按完成时刻输出,便于阅读
def simulate_rr(procs, quantum=2):
"""时间片轮转:就绪队列 FIFO,时间片用完但没跑完的进程回到队尾"""
burst = {n: b for n, _, b in procs}
arrive = {n: a for n, a, _ in procs}
remain = dict(burst)
pending = sorted(procs, key=lambda p: p[1])
q, t, out, i = deque(), 0, [], 0
while i < len(pending) or q:
while i < len(pending) and pending[i][1] <= t: # 到达的先入队
q.append(pending[i][0])
i += 1
if not q:
t = pending[i][1] # CPU 空闲,直接跳到下一个到达时刻
continue
name = q.popleft()
run = min(quantum, remain[name])
t += run
remain[name] -= run
if remain[name] == 0:
out.append((name, t, t - arrive[name], t - arrive[name] - burst[name]))
continue
while i < len(pending) and pending[i][1] <= t: # 本时间片内新到达的,先入队
q.append(pending[i][0])
i += 1
q.append(name) # 再把没跑完的放回队尾
return sorted(out, key=lambda r: r[1])
def report(title, rows):
print(f"\n== {title} ==")
print(f"{'进程':<6}{'完成':>6}{'周转':>6}{'等待':>6}")
for name, fin, tat, wait in rows:
print(f"{name:<6}{fin:>6}{tat:>6}{wait:>6}")
n = len(rows)
print(f"平均周转 = {sum(r[2] for r in rows)/n:.2f}, "
f"平均等待 = {sum(r[3] for r in rows)/n:.2f}")
if __name__ == "__main__":
procs = [("P1", 0, 5), ("P2", 0, 4), ("P3", 0, 1), ("P4", 0, 6)]
report("FCFS", simulate_fcfs(procs))
report("SJF(非抢占)", simulate_sjf(procs, preemptive=False))
report("RR(q=2)", simulate_rr(procs, quantum=2))
# 到达时间不同时,SJF 的平均等待时间仍优于 FCFS(可自己改数据验证)
procs2 = [("A", 0, 7), ("B", 2, 4), ("C", 4, 1), ("D", 5, 4)]
report("FCFS(带到达时间)", simulate_fcfs(procs2))
report("SJF(带到达时间)", simulate_sjf(procs2, preemptive=False))
七、进程同步
7.1 临界区与三个要求
临界区(Critical Section) 是访问共享资源的代码段。任何同步方案都必须满足:
| 要求 | 英文 | 含义 |
|---|---|---|
| 互斥 | Mutual Exclusion | 同一时刻至多一个进程在临界区内 |
| 前进 | Progress | 临界区空闲时,想进的进程必须能进,且不能被无限推迟 |
| 有限等待 | Bounded Waiting | 一个进程请求进入后,等待时间有上界(不会饿死) |
忙等(Busy Waiting)的问题
用
while (flag) ;自旋等待会空转 CPU,单核上甚至可能死锁(持锁者拿不到 CPU)。单核场景应使用会睡眠的锁(如 futex 支持的互斥量);自旋只适合临界区极短且核数充足的情况。
/* race_demo.c —— 先看数据竞争长什么样,再用互斥量修好它
* 编译:gcc -O2 -Wall -pthread -o race_demo race_demo.c
*/
#include <pthread.h>
#include <stdio.h>
#define N 1000000
static long counter = 0;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static void *unsafe_add(void *arg) {
(void)arg;
for (int i = 0; i < N; i++) counter++; /* 非原子:load-add-store 三步 */
return NULL;
}
static void *safe_add(void *arg) {
(void)arg;
for (int i = 0; i < N; i++) {
pthread_mutex_lock(&lock); /* 临界区:保证读-改-写整体原子 */
counter++;
pthread_mutex_unlock(&lock);
}
return NULL;
}
int main(void) {
pthread_t t1, t2;
counter = 0;
pthread_create(&t1, NULL, unsafe_add, NULL);
pthread_create(&t2, NULL, unsafe_add, NULL);
pthread_join(t1, NULL); pthread_join(t2, NULL);
printf("无锁:期望 %d,实际 %ld %s\n", 2 * N, counter,
counter == 2 * N ? "" : "← 丢了更新");
counter = 0;
pthread_create(&t1, NULL, safe_add, NULL);
pthread_create(&t2, NULL, safe_add, NULL);
pthread_join(t1, NULL); pthread_join(t2, NULL);
printf("加锁:期望 %d,实际 %ld\n", 2 * N, counter);
return 0;
}
7.2 信号量与 P/V 操作
信号量(Semaphore) 是一个受保护的整型变量,只能通过两个原子操作访问:
| 操作 | 别名 | 语义 |
|---|---|---|
wait(S) | P 操作 / down | S--;若 则阻塞,直到有资源 |
signal(S) | V 操作 / up | S++;若有等待者则唤醒一个 |
- 互斥信号量:初值 1,实现临界区。
- 同步信号量(资源计数):初值 ,表示有 个可用资源。
PV 操作的顺序陷阱
生产者-消费者中,绝不能先 P 互斥量再 P 空槽位:
若缓冲区满,生产者持有互斥锁却阻塞在「空槽位」上,消费者进不了临界区,直接死锁。
正确顺序是「先申请资源信号量,再申请互斥量」。
7.3 生产者-消费者(有界缓冲区)
"""producer_consumer.py —— 用信号量实现有界缓冲区,可直接运行"""
import threading
import time
import random
from collections import deque
BUFFER_SIZE = 5
buffer = deque()
mutex = threading.Semaphore(1) # 互斥:保护 buffer 本身
empty = threading.Semaphore(BUFFER_SIZE) # 空槽位数
full = threading.Semaphore(0) # 已填充槽位数
def producer(pid: int, items: int) -> None:
for i in range(items):
item = f"P{pid}-item{i}"
time.sleep(random.uniform(0.01, 0.03))
empty.acquire() # 先申请空槽位:满了就睡,不占锁
mutex.acquire()
buffer.append(item)
print(f"生产 {item:<12} 缓冲区={list(buffer)}")
mutex.release()
full.release() # 通知消费者:多了一个可消费项
def consumer(cid: int, items: int) -> None:
for _ in range(items):
full.acquire() # 先等有数据,再抢锁
mutex.acquire()
item = buffer.popleft()
print(f" 消费 {item:<12} 缓冲区={list(buffer)}")
mutex.release()
empty.release() # 归还一个空槽位
time.sleep(random.uniform(0.02, 0.05))
if __name__ == "__main__":
threads = [threading.Thread(target=producer, args=(1, 6)),
threading.Thread(target=producer, args=(2, 6)),
threading.Thread(target=consumer, args=(1, 7)),
threading.Thread(target=consumer, args=(2, 5))]
for t in threads:
t.start()
for t in threads:
t.join()
print("结束,剩余缓冲区:", list(buffer))
7.4 读者-写者问题
规则:允许多个读者同时读;写者与任何人互斥。
| 策略 | 规则 | 风险 |
|---|---|---|
| 读者优先 | 只要还有读者在读,写者就等 | 写者可能饿死 |
| 写者优先 | 有写者等待时,新读者排在写者后 | 读者可能饿死 |
| 公平(FIFO) | 按到达顺序发放 | 实现较复杂 |
/* reader_writer.c —— 读者优先的读者-写者实现(用读写锁更简单,这里是原理版)
* 编译:gcc -O2 -Wall -pthread -o rw reader_writer.c
*/
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
static int read_count = 0;
static pthread_mutex_t count_lock = PTHREAD_MUTEX_INITIALIZER; /* 保护 read_count */
static pthread_mutex_t write_lock = PTHREAD_MUTEX_INITIALIZER; /* 写者互斥 + 挡住读者 */
static int shared_data = 0;
static void *reader(void *arg) {
long id = (long)arg;
pthread_mutex_lock(&count_lock);
if (++read_count == 1) /* 第一个读者负责锁住写者 */
pthread_mutex_lock(&write_lock);
pthread_mutex_unlock(&count_lock);
printf("读者 %ld 读到 %d\n", id, shared_data);
usleep(10000);
pthread_mutex_lock(&count_lock);
if (--read_count == 0) /* 最后一个读者负责放行写者 */
pthread_mutex_unlock(&write_lock);
pthread_mutex_unlock(&count_lock);
return NULL;
}
static void *writer(void *arg) {
long id = (long)arg;
pthread_mutex_lock(&write_lock);
shared_data++;
printf("写者 %ld 写入 %d\n", id, shared_data);
usleep(10000);
pthread_mutex_unlock(&write_lock);
return NULL;
}
int main(void) {
pthread_t r[3], w[2];
for (long i = 0; i < 3; i++) pthread_create(&r[i], NULL, reader, (void *)i);
for (long i = 0; i < 2; i++) pthread_create(&w[i], NULL, writer, (void *)i);
for (int i = 0; i < 3; i++) pthread_join(r[i], NULL);
for (int i = 0; i < 2; i++) pthread_join(w[i], NULL);
printf("最终 shared_data=%d\n", shared_data);
return 0;
}
7.5 管程(Monitor)
管程把「共享数据 + 操作 + 同步」封装成一个模块,同一时刻只有一个进程能在管程内活动,同步由条件变量表达。
| 对比项 | 信号量 | 管程 |
|---|---|---|
| 同步逻辑位置 | 分散在调用者代码里 | 集中在管程内部 |
| 出错概率 | 高(P/V 顺序、漏配对) | 低(编译器/运行时保证互斥) |
| 语言支持 | 通用 | Java 的 synchronized、C# 的 lock、Python 的 threading.Condition |
| 条件等待 | wait/signal 作用于信号量 | wait/signal 作用于条件变量,必须与互斥锁配合 |
"""monitor_demo.py —— 用 Condition(管程思想)实现「等条件成立再继续」"""
import threading
class BoundedQueue:
"""管程:所有对内部 list 的访问都在同一把锁下,等待用条件变量表达"""
def __init__(self, capacity: int):
self._cap = capacity
self._items = []
self._cond = threading.Condition() # 内置一把锁 + 等待队列
def put(self, item) -> None:
with self._cond:
# 必须用 while 而不是 if:被唤醒后要重新检查条件(防虚假唤醒)
while len(self._items) >= self._cap:
self._cond.wait()
self._items.append(item)
self._cond.notify_all()
def get(self):
with self._cond:
while not self._items:
self._cond.wait()
item = self._items.pop(0)
self._cond.notify_all()
return item
if __name__ == "__main__":
q = BoundedQueue(3)
threading.Thread(target=lambda: [q.put(i) for i in range(5)], daemon=True).start()
print([q.get() for _ in range(5)]) # [0, 1, 2, 3, 4]
条件变量必须配 while
用
if检查条件、被唤醒后不复查,会在虚假唤醒(Spurious Wakeup)或「被唤醒但条件又被别人抢走」时出错。这是并发代码里最常见、最难复现的 bug 之一。
八、死锁
8.1 四个必要条件
死锁(Deadlock)必须同时满足以下四条,破坏任意一条即可预防:
| 条件 | 英文 | 含义 | 破坏手段 |
|---|---|---|---|
| 互斥 | Mutual Exclusion | 资源同一时刻只能被一个进程占用 | 尽量用可共享资源(只读文件) |
| 占有并等待 | Hold and Wait | 持有资源的同时等待新资源 | 一次性申请全部资源;申请不到就释放已有 |
| 不可剥夺 | No Preemption | 资源不能被强行抢走 | 允许抢占(如 CPU、可回滚的事务) |
| 循环等待 | Circular Wait | 存在进程-资源的环形等待链 | 给资源编号,一律按序申请 |
工程上最实用的两条
① 按固定顺序加锁(破坏循环等待):例如所有代码都先锁 A 再锁 B,绝不反向。
② 加锁超时 + 重试(绕开不可剥夺):
try_lock失败就释放已有锁、退避后重试。
8.2 处理策略对比
| 策略 | 英文 | 做法 | 代价 |
|---|---|---|---|
| 预防 | Prevention | 破坏四个必要条件之一 | 资源利用率下降 |
| 避免 | Avoidance | 动态检查分配后是否仍处安全状态(银行家算法) | 需预知最大需求,开销大 |
| 检测与恢复 | Detection & Recovery | 定期跑检测算法,发现后杀进程/回滚 | 检测开销 + 恢复损失 |
| 忽略 | Ignore(鸵鸟策略) | 假设不会发生,出问题就重启 | 简单,但线上会真的发生 |
8.3 银行家算法
安全状态:存在一个进程执行序列,使得按该序列依次满足每个进程的最大需求都能成功。存在这样的序列就安全,安全状态一定不会死锁。
算法步骤(对每个请求 Request[i]):
- 若 → 出错(请求超过声明的最大需求)。
- 若 → 等待(资源不足)。
- 试探性分配:,,。
- 执行安全性检查;安全则正式分配,不安全则回滚并让进程等待。
"""banker.py —— 银行家算法:安全性检查 + 请求试探,可直接运行"""
def is_safe(available, allocation, need):
"""返回 (是否安全, 安全序列)。Work 为可用向量,Finish 标记已完成进程"""
n = len(allocation)
work = list(available)
finish = [False] * n
sequence = []
while len(sequence) < n:
progressed = False
for i in range(n):
if not finish[i] and all(need[i][j] <= work[j] for j in range(len(work))):
for j in range(len(work)):
work[j] += allocation[i][j] # 进程 i 完成后归还全部资源
finish[i] = True
sequence.append(i)
progressed = True
break # 从头再扫,保证找到的是当前可满足的
if not progressed:
return False, [] # 还有进程无法满足 → 不安全
return True, sequence
def request_resources(available, allocation, need, pid, request):
"""尝试为 pid 分配 request;返回 (是否批准, 说明)"""
if any(request[j] > need[pid][j] for j in range(len(request))):
return False, "请求超过声明的最大需求(Need),属于非法请求"
if any(request[j] > available[j] for j in range(len(request))):
return False, "当前可用资源不足,请求需排队等待"
# 试探性分配
for j in range(len(request)):
available[j] -= request[j]
allocation[pid][j] += request[j] # 注意是二维:进程 pid 的第 j 类资源
need[pid][j] -= request[j]
safe, seq = is_safe(available, allocation, need)
if safe:
return True, f"批准,安全序列为 {['P' + str(i) for i in seq]}"
# 回滚
for j in range(len(request)):
available[j] += request[j]
allocation[pid][j] -= request[j]
need[pid][j] += request[j]
return False, "会导致系统进入不安全状态,请求被拒绝"
if __name__ == "__main__":
# 教材经典例子:5 个进程、3 类资源 A/B/C
available = [3, 3, 2]
allocation = [[0, 1, 0], [2, 0, 0], [3, 0, 2], [2, 1, 1], [0, 0, 2]]
need = [[7, 4, 3], [1, 2, 2], [6, 0, 0], [0, 1, 1], [4, 3, 1]]
safe, seq = is_safe(available, allocation, need)
print("初始是否安全:", safe, "安全序列:", ["P" + str(i) for i in seq])
# True,安全序列形如 ['P1', 'P3', 'P0', 'P2', 'P4']
# (并列可满足时序列可能不同,但「安全」这个结论唯一)
# 例 1:P0 请求 (0,0,2)。合法、资源也够,但分配后 Available=(3,3,0),
# 除 P1 外没有任何进程的 Need 能被满足 → 不安全 → 拒绝
print("P0 请求 (0,0,2):",
request_resources(available, allocation, need, pid=0, request=[0, 0, 2]))
print(" 被拒绝后 Available 是否回滚:", available)
# (False, '会导致系统进入不安全状态,请求被拒绝'),Available 仍是 [3, 3, 2]
# 例 2:P1 请求 (1,0,2)。试探后 Available=(2,1,0),P1 之后 P3、P0 仍能依次完成 → 批准
print("P1 请求 (1,0,2):",
request_resources(available, allocation, need, pid=1, request=[1, 0, 2]))
print("批准后 Available =", available, "P1 的 Allocation =", allocation[1])
# (True, "批准,安全序列为 ['P1', 'P3', 'P0', 'P2', 'P4']")
# Available 变为 [2, 3, 0],Allocation[1] 变为 [3, 0, 2]
# 例 3:请求超过声明的 Need → 直接判定为非法,不做试探分配
print("P3 请求 (1,1,1):",
request_resources(available, allocation, need, pid=3, request=[1, 1, 1]))
# (False, '请求超过声明的最大需求(Need),属于非法请求')
银行家算法的现实局限
它要求预先知道每个进程的最大资源需求,且进程之间互不通信、资源数量固定。
现实中(数据库锁、线程池、容器配额)这些条件几乎不成立,所以主流系统用的是
「超时 + 检测 + 杀进程」或「严格加锁顺序」的工程手段,而不是银行家算法。
九、内存管理
9.1 连续分配
| 方式 | 说明 | 问题 |
|---|---|---|
| 单一连续 | 内存分系统区与用户区 | 只支持单任务 |
| 固定分区 | 预先切成若干块 | 内部碎片(块内浪费) |
| 动态分区 | 按需切分 | 外部碎片(小空洞无法利用) |
动态分区的分配算法:首次适应(First Fit)、最佳适应(Best Fit,易产生小碎片)、最坏适应(Worst Fit)、临近适应(Next Fit)。可用紧凑(Compaction) 消除外部碎片,但需重定位支持。
9.2 分页、分段、段页式
| 对比项 | 分页(Paging) | 分段(Segmentation) | 段页式(Segmented Paging) |
|---|---|---|---|
| 划分依据 | 物理等长(页) | 逻辑意义(代码/数据/栈) | 先按逻辑分段,段内再分页 |
| 地址 | 页号 + 页内偏移 | 段号 + 段内偏移 | 段号 + 页号 + 页内偏移 |
| 大小 | 固定(常见 4 KB) | 可变 | 页固定、段可变 |
| 碎片 | 只有内部碎片(最后一页) | 只有外部碎片 | 内部碎片极小 |
| 对用户可见 | 不可见(透明) | 可见(是逻辑单位) | 段可见,页不可见 |
| 共享与保护 | 以页为单位,粒度细 | 以段为单位,语义自然 | 兼具两者 |
| 典型系统 | x86-64 主流模式 | 早期 x86、部分嵌入式 | x86 传统模式、现代 OS 概念模型 |
地址转换:逻辑地址 → 页号 + 偏移 → 查页表得物理块号 → 物理地址 。
为什么要多级页表
32 位、4 KB 页、每页表项 4 B 时,单级页表有 项,占 4 MB —— 每个进程都要 4 MB 太浪费。
改成两级后,只有实际用到的二级页表才需要分配,未使用的地址区间不占内存。
x86-64 的 4 级页表(PML4 → PDPT → PD → PT)就是同一思路的延伸,详见 Intel SDM。
9.3 虚拟内存与缺页中断
虚拟内存(Virtual Memory) 让每个进程都以为自己独占一整块连续地址空间,实际数据按需在内存与磁盘之间搬运。
| 好处 | 说明 |
|---|---|
| 容量扩展 | 程序可以大于物理内存(按需调入) |
| 隔离保护 | 进程看不到彼此的内存,越界即段错误 |
| 共享 | 共享库、fork 的写时复制(COW) |
| 简化链接加载 | 统一的地址假设,加载器不用重定位所有地址 |
缺页中断(Page Fault)处理流程:
- CPU 访问的页不在内存 → MMU 触发缺页异常,陷入内核;
- 内核检查地址合法性(非法 →
SIGSEGV;合法但不在内存 → 继续); - 在内存中找空闲页框;没有则按置换算法选一个牺牲页;
- 若牺牲页被修改过(脏位 D=1),先写回磁盘;
- 从磁盘读入所需页,更新页表,置有效位;
- 重新执行触发缺页的那条指令。
其中 为缺页率, 通常包含磁盘访问(毫秒级),比内存访问慢 5~6 个数量级。
缺页率必须极低
设内存访问 100 ns、缺页处理 10 ms,则
时 EAT ns,尚可接受;
时 EAT ,性能直接崩掉 100 倍。
这就是抖动(Thrashing):多道程序度过高,每个进程的驻留集都不够,疯狂换页。
9.4 页面置换算法与 Belady 异常
| 算法 | 英文 | 规则 | 优点 | 缺点 |
|---|---|---|---|---|
| 最佳置换 | OPT / MIN | 淘汰未来最久不用的页 | 缺页率理论最低 | 需要预知未来,无法实现(用作基准) |
| 先进先出 | FIFO | 淘汰最早进入的页 | 最简单 | 有 Belady 异常,性能差 |
| 最近最久未使用 | LRU | 淘汰最久未访问的页 | 接近 OPT,无 Belady 异常 | 精确实现成本高(需链表/栈) |
| 时钟 | Clock / NRU | 环形扫描,访问位为 0 就淘汰,为 1 则清零继续 | 近似 LRU,开销小,实际最常用 | 精度略低于 LRU |
Belady 异常:增加页框数反而导致缺页次数增加——只有 FIFO 这类不满足栈性质(Stack Property)的算法才会出现,LRU 与 OPT 不会。
实测数据(用本节代码跑出来的真实结果)
引用串 A:
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1| 算法 | 3 个页框 | 4 个页框 |
|---|---|---|
| FIFO | 15 次缺页 | 10 次缺页 |
| LRU | 12 次缺页 | 8 次缺页 |
| OPT | 9 次缺页 | 8 次缺页 |
| Clock | 14 次缺页 | 9 次缺页 |
引用串 B(Belady 异常的经典构造):
1 2 3 4 1 2 5 1 2 3 4 5| 算法 | 3 个页框 | 4 个页框 | 5 个页框 |
|---|---|---|---|
| FIFO | 9 次 | 10 次 ← 页框变多,缺页反而增加 | 5 次 |
| LRU | 10 次 | 8 次 | 5 次 |
由这两组数据可以得到两条关键结论:
① 比较算法必须在相同页框数下进行,跨页框数对比没有意义;
② LRU 之所以不会出现 Belady 异常,是因为它满足栈性质(Stack Property):
个页框的驻留集一定是 个页框驻留集的子集,因此缺页次数随页框数单调不增。
FIFO 不满足栈性质,所以它可以在页框增加时缺页反而变多。
"""page_replace.py —— FIFO / LRU / OPT / Clock 四种置换算法与 Belady 异常演示"""
from collections import deque, OrderedDict
def fifo(refs, frames):
memq, faults = deque(), 0
for r in refs:
if r in memq:
continue
faults += 1
if len(memq) == frames:
memq.popleft() # 淘汰最早进入的
memq.append(r)
return faults
def lru(refs, frames):
mem, faults = OrderedDict(), 0
for r in refs:
if r in mem:
mem.move_to_end(r) # 命中:移到「最近使用」端
continue
faults += 1
if len(mem) == frames:
mem.popitem(last=False) # 淘汰「最久未使用」端
mem[r] = True
return faults
def opt(refs, frames):
mem, faults = set(), 0
for i, r in enumerate(refs):
if r in mem:
continue
faults += 1
if len(mem) < frames:
mem.add(r)
continue
# 选「下一次出现位置最靠后(或不再出现)」的页淘汰
victim, farthest = None, -1
for page in mem:
try:
nxt = refs.index(page, i + 1)
except ValueError:
nxt = float("inf")
if nxt > farthest:
victim, farthest = page, nxt
mem.remove(victim)
mem.add(r)
return faults
def clock(refs, frames):
"""Clock(二次机会):环形缓冲 + 访问位,访问位为 1 则清零并跳过"""
slots = [None] * frames
use = [0] * frames
hand, faults = 0, 0
for r in refs:
if r in slots:
use[slots.index(r)] = 1 # 命中,给第二次机会
continue
faults += 1
while use[hand] == 1: # 找访问位为 0 的槽位
use[hand] = 0
hand = (hand + 1) % frames
slots[hand], use[hand] = r, 1
hand = (hand + 1) % frames
return faults
if __name__ == "__main__":
refs = [7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1]
print(f"{'算法':<8}{'3 页框':>8}{'4 页框':>8}")
for name, fn in (("FIFO", fifo), ("LRU", lru), ("OPT", opt), ("Clock", clock)):
print(f"{name:<8}{fn(refs, 3):>8}{fn(refs, 4):>8}")
# 实测输出(3 页框 / 4 页框):FIFO 15/10、LRU 12/8、OPT 9/8、Clock 14/9
# 观察点:同一算法在 4 页框下的缺页数应尽量少;LRU / OPT 满足栈性质,一定单调不增
抖动(Thrashing)的识别与处理
症状:CPU 利用率不高,但磁盘 IO 满载,
si/so(swap in/out)很高。原因:多道程序度过高 / 内存不足,进程驻留集小于工作集。
处理:降低并发度、限制进程数、增大内存,或用工作集模型(Working Set)动态调整。
十、文件系统
10.1 inode 与文件元数据
inode(Index Node,索引节点) 存放除文件名外的全部元数据:
| 字段 | 说明 |
|---|---|
| 文件类型与权限 | 普通文件/目录/符号链接/设备;rwx 位、setuid/setgid/sticky |
| 所有者 | UID、GID |
| 大小 | 字节数、占用块数(st_blocks,注意稀疏文件) |
| 时间戳 | atime 访问、mtime 内容修改、ctime inode 变更 |
| 链接计数 | st_nlink,减到 0 才真正释放数据块 |
| 数据块指针 | 直接指针 + 一级/二级/三级间接指针(ext 系列) |
文件名不在 inode 里
目录本质是「文件名 → inode 号」的映射表。所以:
硬链接(Hard Link) 就是新增一条目录项指向同一个 inode,
nlink加一,删除一个名字数据仍在;符号链接(Symbolic Link) 是另一个独立文件,内容是目标路径字符串,目标删掉就变成断链。
# 亲手验证硬链接与符号链接的差别
echo hello > /tmp/orig.txt
ln /tmp/orig.txt /tmp/hard.txt # 硬链接:共享 inode
ln -s /tmp/orig.txt /tmp/soft.txt # 符号链接:新 inode,内容是路径
stat -c '%n inode=%i links=%h size=%s' /tmp/orig.txt /tmp/hard.txt /tmp/soft.txt
rm /tmp/orig.txt
cat /tmp/hard.txt # 仍能读到 hello(inode 未被释放)
cat /tmp/soft.txt # 报错:No such file or directory(断链)
ls -li /tmp/hard.txt /tmp/soft.txt
10.2 目录结构与文件系统类型
Linux 是树形目录 + 单一根,其他文件系统通过挂载(Mount) 接到树上。
| 目录 | 内容(FHS 标准) |
|---|---|
/ | 根 |
/bin /usr/bin | 可执行文件(/bin 多为 /usr/bin 的链接) |
/etc | 配置文件 |
/home | 用户家目录 |
/var | 可变数据:日志、缓存、数据库 |
/tmp | 临时文件(可能被清理或放在内存盘) |
/proc /sys | 内核暴露的虚拟文件系统(不是磁盘上的数据) |
/dev | 设备文件 |
/mnt /media | 挂载点 |
常见文件系统:ext4(通用默认)、XFS(大文件与高并发)、Btrfs/ZFS(快照与校验和)、NTFS/FAT32(Windows 兼容)、tmpfs(内存盘)、NFS/SMB(网络)。
10.3 磁盘调度
| 算法 | 英文 | 思路 | 特点 |
|---|---|---|---|
| 先来先服务 | FCFS | 按请求顺序 | 公平但寻道长 |
| 最短寻道优先 | SSTF | 优先服务最近的柱面 | 平均寻道短,但远处请求饥饿 |
| 扫描 | SCAN(电梯) | 单方向扫到底再折返 | 兼顾公平与效率 |
| 循环扫描 | C-SCAN | 只单向服务,回头不服务 | 响应时间更均匀 |
| LOOK / C-LOOK | — | 扫到该方向最后一个请求就折返 | 比 SCAN 少走空路 |
手算:请求队列
98, 183, 37, 122, 14, 124, 65, 67,磁头初始在 53,向磁道号增大方向移动- FCFS:
- SSTF:53→65→67→37→14→98→122→124→183,总移动
- SCAN:53→65→67→98→122→124→183(到最右端)→ 折返 →37→14,总移动
- C-SCAN:只向一个方向服务,到端后直接跳回最小请求再继续,总移动 左右(取决于是否扫到端点)
现代磁盘调度另有其人
HDD 的固件内部已有复杂的重排序,Linux 的
mq-deadline、kyber、bfq只是补充策略。对 SSD 而言寻道概念消失(无机械臂),调度目标是减少写放大与保证公平,而不是减少寻道。
云环境里真正决定 IO 性能的往往是文件系统层(页缓存、预读)与块层队列深度。
十一、IO 模型
| 模型 | 英文 | 谁在等 | 典型接口 | 适用场景 |
|---|---|---|---|---|
| 阻塞 IO | Blocking IO | 线程被挂起,直到数据就绪并拷贝完 | read() | 简单脚本、线程模型 |
| 非阻塞 IO | Non-blocking IO | 立即返回 EAGAIN,需轮询 | fcntl(O_NONBLOCK) | 轮询少量 fd |
| IO 多路复用 | IO Multiplexing | 一个线程等多个 fd 就绪 | select / poll / epoll | 高并发网络服务 |
| 信号驱动 IO | Signal-driven IO | 内核 SIGIO 通知就绪 | O_ASYNC | 特殊场景,少用 |
| 异步 IO | Asynchronous IO | 内核完成全部工作后通知 | Linux io_uring / aio | 高吞吐磁盘 IO、极致性能 |
同步 vs 异步的分界
判断标准是「数据从内核缓冲区拷贝到用户缓冲区这一步,谁来做」。
epoll只告诉你「可以读了」,read()仍由你自己调用(同步);io_uring可以直接把数据放进你的缓冲区再通知你(异步)。
"""io_models.py —— 同一个「等两个 fd 就绪」的任务,三种写法对比"""
import select
import socket
import asyncio
def blocking_way(socks):
"""阻塞模型:两个连接要两个线程。这里顺序读,后一个会干等前一个"""
for s in socks:
data = s.recv(1024) # 阻塞在这里,直到有数据
print("阻塞读到:", data)
def multiplexing_way(socks):
"""IO 多路复用:一个线程管理多个 fd,只在就绪时读"""
poller = select.poll()
for s in socks:
poller.register(s, select.POLLIN) # 告诉内核:有可读数据就通知我
ready = dict(poller.poll(timeout=1000)) # 毫秒;返回 [(fd, 事件), ...]
for s in socks:
if ready.get(s.fileno(), 0) & select.POLLIN:
print("就绪读到:", s.recv(1024)) # 这里有数据,recv 不会阻塞
async def async_way(reader, writer):
"""异步模型:await 让出控制权,事件循环去处理其他任务"""
data = await reader.read(1024) # 挂起当前协程,不阻塞线程
print("异步读到:", data)
writer.close()
def run_asyncio_server(host="127.0.0.1", port=8888):
return asyncio.start_server(async_way, host, port)
if __name__ == "__main__":
# 演示 epoll 的注册/等待流程(真实服务应使用 selectors 或 asyncio)
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
srv.bind(("127.0.0.1", 0)) # 端口 0:由内核分配空闲端口
srv.listen(5)
print("监听端口:", srv.getsockname()[1])
# 触发一次就绪事件:自己连自己
client = socket.create_connection(srv.getsockname())
client.sendall(b"ping")
conn, _ = srv.accept()
multiplexing_way([conn]) # 打印:就绪读到: b'ping'
client.close()
conn.close()
srv.close()
11.1 select / poll / epoll 对比
| 对比项 | select | poll | epoll |
|---|---|---|---|
| fd 上限 | 通常 1024(FD_SETSIZE) | 无硬上限 | 无硬上限 |
| 每次调用开销 | :每次都要拷入/拷出整个集合 | (注册一次,事件回调通知就绪的 fd) | |
| 数据结构 | 位图 | 数组 | 内核红黑树 + 就绪链表 |
| 触发模式 | 水平触发(LT) | 水平触发 | LT 与边缘触发(ET) |
| 适用规模 | 少量连接 | 中等 | 高并发(C10K/C10M) |
边缘触发(ET)必须循环读到
EAGAINET 模式只在状态变化时通知一次。若一次没读完内核缓冲区,剩余数据不会再触发通知,连接就「假死」了。
正确写法:
while True: n = recv(...)直到抛出BlockingIOError。LT 模式则没读完会持续通知,容错更好但可能空转。
十二、Linux 常用命令实操
# ---------- 进程与调度 ----------
ps aux # 全量进程快照(%CPU、%MEM、STAT)
ps -eLf # 显示线程(LWP 列)
top -H -p 1234 # 只看某进程的线程,按 H 切换线程视图
nice -n 10 ./cpu_hog & # 以更低优先级(更大 nice 值)启动
renice -n -5 -p 1234 # 调整运行中进程的 nice 值(降低需权限)
taskset -c 0,1 ./app # 绑定到 CPU 0 与 1,观察亲和性影响
kill -l # 列出所有信号
kill -TERM 1234 # 优雅终止(进程可清理资源)
kill -KILL 1234 # 强杀,无法被捕获,可能丢数据
pkill -f 'python.*worker' # 按命令行模式批量终止
# ---------- 内存 ----------
free -h # 总览;重点看 available 而不是 free
vmstat 1 5 # 每秒采样:si/so 非 0 说明在换页
cat /proc/meminfo | head -20 # 详细内存项(含 PageTables、Slab)
pmap -x 1234 | tail -5 # 某进程的内存映射明细
cat /proc/1234/smaps_rollup # 进程内存汇总(RSS/PSS,PSS 适合算共享内存分摊)
# ---------- IO 与文件 ----------
iostat -xz 1 # 磁盘:%util、await、aqu-sz
iotop -oP # 按进程看实时 IO(需 root)
lsof -p 1234 # 进程打开的文件与网络连接
lsof +L1 # 找出「已删除但仍被占用」的大文件(磁盘没释放的元凶)
du -sh * | sort -h | tail -10 # 找出当前目录下最大的子目录
df -hT # 各挂载点使用率与文件系统类型
find /var/log -type f -size +100M -exec ls -lh {} \;
# ---------- 追踪与诊断 ----------
strace -c -f ./app # 系统调用耗时统计
strace -e trace=network -tt ./app
lsof -i :8080 # 谁占用了 8080 端口
ss -s # 套接字统计
ss -tnp state established | head
perf top # 采样看热点函数(需权限)
dmesg -T | tail -50 # 内核日志:OOM Killer、IO 错误都在这里
journalctl -u myservice -n 100 --no-pager # 某个 systemd 服务的日志
# 一个完整的排查流程示例:服务变慢,如何一步步定位
# 1) 看整体负载:r 列(运行队列长度)持续大于核数说明 CPU 竞争
uptime
# 2) 定位是 CPU、内存还是 IO 的问题
vmstat 1 5
# si/so 高 -> 内存不足在换页
# wa 高 -> IO 等待
# us+sy 接近 100 -> CPU 瓶颈
# 3) 若是 CPU:找出是哪个进程、哪个线程、哪个函数
top -H -p $(pgrep -f myservice | head -1)
perf top -p $(pgrep -f myservice | head -1)
# 4) 若是 IO:确认是读还是写、多大块、谁在写
iostat -xz 1
iotop -oP
# 5) 若是内存:确认是泄漏还是缓存
cat /proc/$(pgrep -f myservice | head -1)/status | grep -E 'VmRSS|VmSwap'
十三、注意事项与常见坑
十五个高频错误
1. 忽略系统调用返回值。
read可能短读、write可能返回EINTR,健壮代码必须重试与循环。2. 在信号处理函数里调用非异步信号安全的函数(如
printf、malloc)。信号处理里只应设置volatile sig_atomic_t标志,或调用write。3.
fork后在子进程里调用printf未刷新,导致输出重复——应用_exit而非exit。4. 有符号溢出当成回绕:C/C++ 中是有符号溢出是未定义行为,编译器可任意优化。
5. 用
if检查条件变量:必须用while防虚假唤醒。6. P/V 顺序写反导致死锁:先申请资源信号量,再申请互斥信号量。
7. 加锁顺序不一致:A 线程先锁 X 再锁 Y,B 线程反过来,必然死锁。
8. 持锁做耗时操作(IO、网络、日志落盘):临界区膨胀,吞吐骤降。
9. 忘了
waitpid造成僵尸进程:子进程退出但 PCB 未回收,ps里显示<defunct>。10.
free显示内存快满就慌了:Linux 会把空闲内存用作页缓存,应看available列。11.
/tmp当持久存储:可能被 systemd 清理,或被挂成 tmpfs 随重启消失。12. 删除文件后磁盘未释放:进程仍持有 fd,需
lsof +L1找到并重启该进程。13. 硬编码依赖 fd 编号:
close(0)后再open可能拿到 fd 0,引发离奇 bug。14. 以为线程越多并发越高:线程切换、锁竞争、缓存失效会让性能反降;IO 密集适合异步,CPU 密集适合核数量级的线程数。
15. 在多线程程序中使用非线程安全函数(
strtok、localtime、rand):应改_r版本或使用线程局部状态。
十四、练习题
基础题
1. 写出进程五状态模型的三条合法迁移与两条非法迁移,并解释为什么非法。
2. 用第六节的表数据(P1=5, P2=4, P3=1, P4=6,同时到达):
(a) 手算 FCFS 与 SJF 的平均等待时间;(b) 手算 RR()的执行序列与平均周转时间。
(答案:(a) FCFS 平均等待 6.0,SJF 平均等待 4.0,与第六节表格一致;
(b) 时执行序列为
P1(0-3) P2(3-6) P3(6-7, 完成) P4(7-10) P1(10-12, 完成) P2(12-13, 完成) P4(13-16, 完成),周转时间分别为 P1=12、P2=13、P3=7、P4=16,平均周转 ;
对比 时的 15.5,可见时间片越大越接近 FCFS,越小时响应越好但周转变差)
3. 引用串
1 2 3 4 1 2 5 1 2 3 4 5,3 个页框,分别用 FIFO、LRU、OPT 求缺页次数。(答案:FIFO = 9、LRU = 10、OPT = 7;可把引用串换成
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1再算一遍,并验证 FIFO 在 4 个页框下的缺页次数)
进阶题
4. 系统有 3 类资源,
Available = (1, 5, 2),各进程Allocation/Need如下。判断当前是否安全(给出安全序列);若 P1 请求
(1, 0, 1),是否批准?| 进程 | Allocation | Need |
|---|---|---|
| P0 | (0,1,0) | (0,0,0) |
| P1 | (1,0,0) | (1,0,1) |
| P2 | (1,0,1) | (1,0,1) |
| P3 | (0,1,1) | (0,1,1) |
(答案:先看 为零的 P0 —— 它的 恒可满足,完成后归还 ,
变为 ;同理 P2 的 可完成, 变为 ;
P3 的 可完成, 变为 ;最后 P1 的 可完成。
因此当前是安全状态,安全序列为
P0 → P2 → P3 → P1。P1 请求 时:它不超过 ,也不超过 ,试探分配后 ,
但 P1 自己已全部满足( 归零)可立即完成,随后按
P1 → P0 → P2 → P3仍能全部完成,故可以批准)
5. 设内存访问 80 ns、缺页处理 8 ms。若要求有效访问时间不超过 100 ns,缺页率上限是多少?这个结论说明了什么?
(答案:由 解得 ,
即平均每 40 万次访问才允许缺页一次。结论:缺页率必须低到百万分之一量级,
一旦升到千分之一量级,有效访问时间就变成微秒级,性能下降上百倍——这就是抖动(Thrashing)的杀伤力)
6. 请求队列
82, 170, 43, 140, 24, 16, 190,磁头初始在 100 且向磁道号增大方向移动。分别计算 FCFS、SSTF、SCAN、C-SCAN 的磁头移动总量,并说明哪个算法可能出现饥饿。
(答案:FCFS 、SSTF 、SCAN 、C-SCAN 。推导过程:
FCFS 按到达顺序 → ;
SSTF 的访问顺序为 → ;
SCAN 先向增大方向扫到 190 再折返到 16 → ;
C-SCAN 只向增大方向服务(到 190),然后直接跳回最小请求 16 → 。
SSTF 可能饥饿:只要持续有靠近当前磁头的请求到达,远端(如 190 附近)的请求就会被无限推迟;
SCAN 与 C-SCAN 因为会扫过整个方向上的所有请求,不会饿死任何请求)
思考题
7. 为什么 Linux 不用「最短作业优先」而用 CFS(完全公平调度)?从「服务器场景的目标函数」与「运行时间不可预知」两个角度回答。
(要点:① 服务器要优化的是吞吐量、尾延迟与公平性,而不是「最短平均周转时间」;
SJF 会让长任务无限等待(饥饿),而一台机器上既有毫秒级的请求处理、又有小时级的批处理任务,
饿死长任务是不可接受的。② SJF 需要预先知道每个任务的运行时间,这在通用操作系统上根本无法获得;
CFS 用
vruntime(虚拟运行时间,按权重折算的实际运行时间)近似「理想多任务处理器」,无需任何预测信息就能保证长期公平,并让交互任务的延迟保持在可接受范围。
代价是它不追求理论最优的平均周转时间)
8. 你的服务在高并发下
CPU 使用率只有 30%,但load average达到 20(机器 4 核),vmstat显示wa很高。请给出至少三种可能的根因,以及对应的验证命令。
(要点:关键线索是「
wa高 +load高但 CPU 不高」——load average在 Linux 上包含处于不可中断睡眠(D 状态)的进程,所以大量进程卡在 IO 上会让 load 飙升。三种可能根因:
① 内存不足在换页:验证
free -h看available、vmstat 1看si/so是否为 0、cat /proc/<pid>/status | grep VmSwap;② 磁盘本身成为瓶颈:验证
iostat -xz 1看%util是否接近 100、await是否远大于正常值,再用iotop -oP找出写盘最多的进程;③ 锁或同步阻塞导致的 IO 等待(含存储后端慢、NFS 卡住):验证
cat /proc/<pid>/stack、lsof -p <pid>看是否有异常挂载点,或用
strace -f -T -p <pid>看哪个系统调用耗时最长。除此之外还要排查
dmesg -T | tail是否出现磁盘 IO 错误或 OOM Killer 记录)9. 容器(Docker)与虚拟机在「隔离机制」上的本质区别是什么?为什么容器里的
free看到的还是宿主机的总内存?(要点:容器是内核级的隔离——所有容器共享宿主机内核,靠 namespace 隔离视图
(
pid/mnt/net/uts/ipc/user/cgroup),靠 cgroup 限制 CPU、内存等资源用量;虚拟机是硬件级的隔离——由 Hypervisor 虚拟出 CPU/内存/设备,每个虚机跑自己独立的内核,
隔离更彻底(内核漏洞不直接穿透),代价是启动慢、内存开销大。
至于
free:它读的是/proc/meminfo,而/proc是内核暴露的全局视图,并不按 cgroup 过滤,所以容器里看到的是宿主机整机内存。要查看容器受到的真实限制,应读 cgroup 文件,
例如
cat /sys/fs/cgroup/memory.max(cgroup v2)或memory.limit_in_bytes(cgroup v1),以及
cat /sys/fs/cgroup/cpu.max。Java 程序在容器里若未开启UseContainerSupport,会按宿主机内存计算堆大小,正是这个原因导致的经典事故)
十五、常见问题 FAQ
Q1:线程一定比进程快吗?
不一定。创建和切换线程更快;但如果任务本质是 CPU 密集且需要频繁同步,线程间的锁竞争与伪共享会让性能反而不如多进程。
另外 Python 有 GIL,CPU 密集任务用线程几乎无法并行,应改多进程;参考 Python-07-进阶特性 中关于 GIL 的讨论。
选择依据:需要隔离 → 进程;IO 密集高并发 → 线程或异步;CPU 密集 → 进程/多核并行。
Q2:为什么要用虚拟内存,直接操作物理地址不行吗?
三个不可替代的好处:① 隔离:进程无法越界访问他人内存;② 简化:每个进程都从统一地址开始,链接加载不用考虑实际位置;③ 超售:总和大于物理内存的进程也能同时运行。
代价是 TLB 缺失时的多级页表查找,所以 CPU 用 TLB 缓存最近的映射。详见 计算机组成原理 的存储层次章节。
Q3:Optimal 置换算法不可能实现,那它有什么用?
它是最优性基准(Baseline)。评估一个实际算法好坏时,用「与 OPT 的缺页次数差距」来衡量,
例如 LRU 通常比 OPT 差 20%~30%,而 FIFO 可能差一倍。研究新算法时,OPT 是必报的对照组。
Q4:
epoll一定比select快吗?在连接数很多但活跃连接很少时快得多,因为
epoll只返回就绪的 fd,而select每次要遍历并拷贝整个集合。但如果活跃用户占比很高(比如 80% 的 fd 每次都就绪),
epoll的 回调优势就不明显了,瓶颈会转移到
read/write本身。所以「上万连接」不是选epoll的充分理由,活跃比例才是关键。
Q5:怎么判断线上的一个「卡顿」是 CPU、内存还是 IO 引起的?
标准顺序:
uptime看趋势 →vmstat 1 5分流(r列大是 CPU 竞争,si/so非 0 是换页,wa高是 IO)→按分流结果深入
top -H、iostat -xz、iotop。永远先看全局指标再定位到进程,跳过这一步容易查错方向。
Q6:学了操作系统原理,工作中能用上哪些具体东西?
最直接的五项:① 看懂
top/vmstat/iostat的每一项;② 写出正确的并发代码(锁顺序、条件变量、原子性);③ 排查「磁盘满了但删了文件没用」「进程卡死但 CPU 不高」这类经典问题;
④ 理解容器与虚拟机的隔离边界;⑤ 知道为什么网络服务要少用系统调用(批量、缓冲、
io_uring)。
相关笔记
- 计算机组成原理:中断、DMA、Cache 与 CPI 是本篇所有机制的硬件基础
- 计算机网络:套接字、IO 多路复用与 TCP 缓冲在协议栈中的位置
- Python-07-进阶特性:GIL 如何影响多线程与多进程的选择
- CSharp-05-异步编程:async/await 与操作系统调度、线程池的配合方式
- 数据库原理:事务隔离级别、锁与 MVCC 建立在进程同步与内存管理之上
- 工具-02-命令行与Shell:本篇第十二节的命令在 Shell 中的进阶用法
- 00-索引、学习路线图:全库导航与学习顺序
参考来源
- Linux 系统调用总览
syscalls(2)(内核提供的全部系统调用):<https://man7.org/linux/man-pages/man2/syscalls.2.html> pthreads(7)手册页(线程、POSIX 同步原语文档):<https://man7.org/linux/man-pages/man7/pthreads.7.html>epoll_wait(2)手册页(LT/ET 触发模式与正确用法):<https://man7.org/linux/man-pages/man2/epoll_wait.2.html>- Linux 内核官方文档(调度器、内存管理、文件系统、块层):<https://www.kernel.org/doc/html/latest/>
- Linux 内核调度器文档(CFS 与调度类的设计说明):<https://docs.kernel.org/scheduler/index.html>
- POSIX.1-2024 标准(进程、线程、信号、文件接口的规范定义):<https://pubs.opengroup.org/onlinepubs/9799919799/>
- Intel® 64 and IA-32 Architectures Software Developer's Manual(分页与特权级机制):<https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html>
- Silberschatz, Galvin & Gagne, Operating System Concepts(调度、同步、死锁、内存管理的经典教材依据)
版本提示
调度器实现(CFS 与 EEVDF)、页表级数、文件系统默认选项、内核参数默认值等随版本变化,
具体行为请以你所使用发行版与内核版本的官方最新文档为准(
man手册页与内核文档站点优先于二手教程)。