《深入理解计算机系统》（CSAPP）学习笔记：给新手的硬件、操作系统与网络并发入门

Wed, 01 Nov 2017 11:00:00 +0800

《深入理解计算机系统》（CSAPP）学习笔记：给新手的硬件、操作系统与网络并发入门

参考书籍：《深入理解计算机系统》（Computer Systems: A Programmer’s Perspective，简称 CSAPP）
目标读者：想学透计算机底层、准备面试、或者写代码总感觉"知其然不知其所以然"的新手。
阅读建议：这篇文章不讲完 700 页书的全部细节，而是帮你建立主干知识框架，并标注容易踩坑的地方。

一、为什么要学 CSAPP？

很多新手学编程的路径是：

语法 → 框架 → 项目 → 面试八股

但遇到这些问题时往往卡住：

为什么 int 溢出会变成负数？
为什么同样的代码，有时快有时慢？
fork() 之后到底发生了什么？
为什么多线程程序偶尔结果不对？
TCP 连接为什么要三次握手、四次挥手？

CSAPP 就是帮你从"会写代码"进化到"理解代码为什么这样跑"。

二、计算机系统全景图

先把整体结构印在脑子里：

graph TD
    A[应用程序] --> B[操作系统]
    B --> C[硬件层]
    C --> D[CPU / 处理器]
    C --> E[内存 / 主存]
    C --> F[磁盘 / SSD]
    C --> G[网络接口 / I/O 设备]
    B --> H[进程管理]
    B --> I[虚拟内存]
    B --> J[文件系统]
    B --> K[网络协议栈]

核心思想：操作系统是应用程序和硬件之间的中间层。它负责：

让多个程序"同时"运行（进程调度）
给每个程序独立的内存空间（虚拟内存）
统一管理文件、网络、输入输出

三、信息就是位 + 上下文

计算机里所有的信息——数字、文字、图片、声音、代码——最终都是 0 和 1。

flowchart LR
    A[人类可理解的数据] -->|编码| B[二进制位流]
    B -->|解释规则| C[整数 / 浮点数 / 字符 / 指令]
    C -->|上下文| D[有意义的信息]

3.1 整数溢出：新手最常踩的坑

在 C/C++ 中，有符号整数溢出是未定义行为（Undefined Behavior）。

int a = 2147483647;  // int 最大值
int b = a + 1;       // 溢出，结果未定义，通常变成 -2147483648

避坑技巧：

做加法前判断是否接近上限。
涉及大数时用 long long 或任意精度库。
无符号整数运算不会溢出，但会发生回绕（wrap around），同样要小心。

3.2 浮点数精度问题

double a = 0.1;
double b = 0.2;
if (a + b == 0.3) {
    printf("相等\n");
} else {
    printf("不相等！\n");  // 大概率进这里
}

原因：0.1 在二进制浮点中无法精确表示。

避坑技巧：

比较浮点数时用误差范围：fabs(a + b - 0.3) < 1e-9
财务计算避免用 float/double，考虑定点数或专用库。

3.3 大端与小端

多字节数据在内存里怎么放？

flowchart LR
    A[数据 0x12345678] --> B[大端序<br/>内存: 12 34 56 78]
    A --> C[小端序<br/>内存: 78 56 34 12]

大端：高位字节放低地址（像人类读数字）。
小端：低位字节放低地址（x86-64 常用）。

避坑技巧：网络传输用大端序（网络字节序），调用 htonl() / htons() 转换。

四、程序的机器级表示

4.1 从源代码到可执行文件

flowchart LR
    A[源代码 hello.c] -->|预处理器 cpp| B[预处理后的 .i]
    B -->|编译器 cc1| C[汇编代码 .s]
    C -->|汇编器 as| D[目标文件 .o]
    D -->|链接器 ld| E[可执行文件]
    E -->|操作系统加载| F[CPU 执行]

每一步都可能出问题：

阶段	典型错误
预处理	宏展开导致奇怪语法
编译	类型错误、语法错误
汇编	很少直接出错
链接	`undefined reference`、`multiple definition`
运行	段错误、内存泄漏、逻辑错误

4.2 调用栈：函数调用的底层

flowchart TB
    subgraph 栈内存["栈内存（从高地址向低地址增长）"]
        A[调用者栈帧] --> B[返回地址]
        B --> C[被调用者局部变量]
        C --> D[被调用者参数空间]
    end

关键概念：

栈帧（Stack Frame）：每次函数调用都会在栈上分配一块空间。
返回地址：函数执行完后要回到哪里。
缓冲区溢出：局部数组写越界，可能覆盖返回地址，导致程序崩溃或被攻击。

4.3 缓冲区溢出：经典安全漏洞

void vulnerable() {
    char buf[8];
    gets(buf);  // 危险！不检查长度
}

避坑技巧：

永远不要用 gets()。
用 fgets()、snprintf()、strncpy() 等带长度限制的函数。
编译时开启保护：-fstack-protector-strong、-D_FORTIFY_SOURCE=2。

五、内存层次结构

5.1 速度像金字塔

flowchart TB
    A[寄存器<br/>最快 / 容量最小] --> B[L1 缓存]
    B --> C[L2 缓存]
    C --> D[L3 缓存]
    D --> E[主存 / 内存]
    E --> F[磁盘 / SSD]
    F --> G[网络存储]

核心规律：越靠近 CPU，速度越快，容量越小，价格越贵。

5.2 局部性原理

程序倾向于重复使用最近用过的数据和指令：

时间局部性：刚访问的数据很可能再次被访问。
空间局部性：访问某个地址后，附近地址很可能被访问。

优化例子：

// 缓存不友好：按列访问
for (int j = 0; j < n; j++)
    for (int i = 0; i < n; i++)
        sum += a[i][j];

// 缓存友好：按行访问
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        sum += a[i][j];

避坑技巧：写循环时注意数据访问顺序，尽量连续访问内存。

5.3 Cache 未命中

CPU 先去缓存找数据，没找到再去内存找，这就是 Cache Miss，会带来几十到几百个时钟周期的延迟。

减少 Cache Miss 的方法：

数据紧凑排列，减少结构体填充。
避免伪共享（多线程中不同变量落在同一缓存行）。
按行遍历二维数组。

六、链接

链接器把多个 .o 文件拼成一个可执行文件。

6.1 静态链接 vs 动态链接

flowchart TB
    A[静态链接] --> B[库代码复制进可执行文件]
    B --> C[优点: 独立运行]
    B --> D[缺点: 体积大 / 更新麻烦]
    
    E[动态链接] --> F[运行时才加载共享库]
    F --> G[优点: 体积小 / 共享内存]
    F --> H[缺点: 依赖环境 .so 文件]

6.2 常见链接错误

错误	原因	解决
`undefined reference to 'xxx'`	函数声明了但没找到定义	检查是否漏链接库文件
`multiple definition of 'xxx'`	全局变量/函数在多个文件定义	用 `extern` 声明，只在一个 `.c` 中定义
`cannot find -lxxx`	链接器找不到库	用 `-L` 指定库路径

避坑技巧：头文件只放声明，定义放在 .c 文件里；全局变量尽量用 static 限制作用域。

七、异常控制流：进程与信号

7.1 进程是什么？

进程是操作系统资源分配的基本单位。每个进程有自己的：

地址空间（代码、数据、堆、栈）
打开的文件描述符
寄存器状态

flowchart TB
    subgraph 进程地址空间["进程地址空间"]
        A[内核空间] 
        B[栈]
        C[堆]
        D[数据段]
        E[代码段]
    end
    A --> B --> C --> D --> E

7.2 fork / exec / wait：Unix 进程三件套

sequenceDiagram
    participant P as 父进程
    participant C as 子进程
    participant K as 内核
    P->>K: fork()
    K-->>P: 返回子进程 PID
    K-->>C: 返回 0
    C->>K: execve("/bin/ls", ...)
    K->>C: 替换为 ls 程序
    C-->>P: 退出状态
    P->>K: waitpid()
    K-->>P: 回收子进程

关键注意点：

fork() 后，父进程和子进程独立运行，各自有独立地址空间。
exec() 会替换当前进程的代码和数据，PID 不变。
父进程必须用 wait()/waitpid() 回收子进程，否则会产生僵尸进程。

7.3 僵尸进程与孤儿进程

僵尸进程：子进程已结束，但父进程没回收，占用进程表资源。
孤儿进程：父进程先结束，子进程被 init 进程收养。

避坑技巧：

父进程捕获 SIGCHLD 信号，在信号处理函数中调用 waitpid()。
或者用 signal(SIGCHLD, SIG_IGN)（在 Linux 上可自动回收）。

7.4 信号

信号是 Unix 的异步通知机制：

信号	含义	常见场景
SIGINT	中断（Ctrl+C）	终止前台进程
SIGSEGV	段错误	访问非法内存
SIGKILL	强制终止	无法捕获、无法忽略
SIGTERM	正常终止	可以被捕获处理

避坑技巧：SIGKILL 和 SIGSTOP 不能被捕获或忽略，不要试图拦截它们。

八、虚拟内存

8.1 为什么需要虚拟内存？

flowchart LR
    A[进程A虚拟地址] -->|页表| C[物理内存]
    B[进程B虚拟地址] -->|页表| C
    C --> D[磁盘交换区]

虚拟内存的好处：

隔离：每个进程以为自己在独占内存，互不干扰。
简化：程序使用连续虚拟地址，实际物理内存可以离散。
共享：不同进程可以映射同一块物理内存（如共享库）。

8.2 地址翻译：页表与 TLB

flowchart LR
    A[虚拟地址] --> B[页号 + 页内偏移]
    B --> C{TLB 命中?}
    C -->|是| D[直接得到物理地址]
    C -->|否| E[查页表]
    E --> F[得到物理地址]

页表：虚拟页到物理页的映射表。
TLB：页表的缓存，加速地址翻译。

避坑技巧：频繁访问大量不连续内存会导致大量 TLB Miss，性能骤降。

8.3 malloc / free 的底层

void *p = malloc(1024);
free(p);

malloc 不一定每次都向操作系统申请内存，它通常先向 ptmalloc / jemalloc 等内存分配器请求，分配器管理一个堆内存池。

常见内存问题：

问题	表现	解决
内存泄漏	程序运行越久内存越大	配对使用 malloc/free，用 Valgrind/ASan 检测
重复释放	`double free` 崩溃	free 后将指针置 NULL
越界写	破坏堆结构，后续 malloc/free 崩溃	边界检查，用 ASan
使用已释放内存	use-after-free	释放后置 NULL，或换智能指针

九、系统级 I/O

9.1 文件描述符

Unix 中一切都是文件：普通文件、管道、socket、设备，都用一个整数 文件描述符（fd） 表示。

int fd = open("file.txt", O_RDONLY);
read(fd, buf, sizeof(buf));
close(fd);

标准文件描述符：

fd	含义
0	标准输入 stdin
1	标准输出 stdout
2	标准错误 stderr

9.2 RIO 包：健壮的 I/O

CSAPP 推荐用 RIO（Robust I/O）处理短计数和网络读写：

// 读取一行或指定字节数
rio_readn(fd, buf, n);   // 读到 n 字节或 EOF
rio_readlineb(fd, buf, maxlen);  // 读一行
rio_writen(fd, buf, n);  // 写 n 字节

避坑技巧：

read()/write() 不保证一次读写完请求的字节数，要处理短计数（short count）。
网络编程中尤其要注意：TCP 是字节流，没有消息边界。

十、Unix 网络编程核心

10.1 客户端 / 服务器模型

flowchart LR
    A[客户端] -->|请求| B[服务器]
    B -->|响应| A

10.2 Socket 编程流程

sequenceDiagram
    participant S as 服务器
    participant C as 客户端
    participant K as 内核
    
    S->>K: socket()
    S->>K: bind()
    S->>K: listen()
    C->>K: socket()
    C->>K: connect()
    K-->>S: 连接请求
    S->>K: accept()
    S->>K: read/write
    C->>K: read/write
    S->>K: close()
    C->>K: close()

10.3 TCP 三次握手与四次挥手

sequenceDiagram
    participant C as 客户端
    participant S as 服务器
    C->>S: SYN
    S->>C: SYN + ACK
    C->>S: ACK
    Note over C,S: 连接建立，可以传数据
    C->>S: FIN
    S->>C: ACK
    S->>C: FIN
    C->>S: ACK
    Note over C,S: 连接关闭

为什么是三次握手？ 防止历史重复连接初始化造成混乱，同时确认双方收发能力正常。

为什么是四次挥手？ TCP 是全双工的，双方都要各自关闭发送通道，所以多了一次。

10.4 Echo 服务器示例

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define MAXLINE 8192
#define PORT 12345

void echo(int connfd) {
    size_t n;
    char buf[MAXLINE];
    while ((n = read(connfd, buf, MAXLINE)) > 0) {
        write(connfd, buf, n);  // 把收到的数据回写
    }
}

int main() {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(PORT);
    
    bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    listen(listenfd, 1024);
    
    printf("Server listening on port %d\n", PORT);
    
    while (1) {
        struct sockaddr_in cli_addr;
        socklen_t len = sizeof(cli_addr);
        int connfd = accept(listenfd, (struct sockaddr *)&cli_addr, &len);
        echo(connfd);
        close(connfd);
    }
    
    return 0;
}

注意：上面的代码是迭代服务器，一次只能处理一个客户端。实际生产环境要用多进程、多线程或 I/O 多路复用。

10.5 网络编程避坑清单

坑	说明	避免方法
忘记字节序转换	大端小端混用	网络传输前用 `htonl`/`htons`，接收后用 `ntohl`/`ntohs`
忽略 `read`/`write` 返回值	可能只读写了一部分	循环处理，直到处理完所有字节
没有处理 `SIGPIPE`	向已关闭的 socket 写会触发信号	忽略 `SIGPIPE`，或检查返回值
端口复用问题	服务器重启时 bind 失败	设置 `SO_REUSEADDR`
长连接粘包/拆包	TCP 无消息边界	设计应用层协议：固定长度、分隔符、长度前缀

十一、并发编程

11.1 三种并发模型

flowchart TB
    A[并发模型] --> B[多进程]
    A --> C[多线程]
    A --> D[I/O 多路复用]
    
    B --> B1[进程独立 / 安全]
    B --> B2[切换开销大 / 共享数据麻烦]
    
    C --> C1[共享地址空间 / 切换快]
    C --> C2[需要同步 / 容易出 bug]
    
    D --> D1[单线程处理多个 fd]
    D --> D2[事件驱动 / 编程复杂]

11.2 线程同步三件套

flowchart LR
    A[互斥锁 Mutex] -->|保护临界区| B[保证同一时间只有一个线程访问]
    C[条件变量 Condition Variable] -->|等待某个条件| D[配合 mutex 使用]
    E[信号量 Semaphore] -->|计数器| F[控制同时访问的线程数量]

11.3 生产者 - 消费者模型

flowchart LR
    A[生产者线程] -->|写入缓冲区| B[共享缓冲区]
    B -->|读取| C[消费者线程]
    D[Mutex] -->|保护| B
    E[条件变量<br/>not_full] -->|通知| A
    F[条件变量<br/>not_empty] -->|通知| C

11.4 死锁：并发程序的噩梦

死锁产生的四个必要条件：

flowchart TB
    A[死锁四条件] --> B[互斥]
    A --> C[占有且等待]
    A --> D[不可抢占]
    A --> E[循环等待]

避免死锁的方法：

按固定顺序获取锁。
使用超时机制（try_lock）。
尽量减少锁的粒度。
避免在持有锁时调用可能阻塞的函数。

11.5 并发编程避坑清单

坑	说明	避免方法
数据竞争	多个线程同时读写共享数据	加锁、原子操作、线程局部存储
死锁	互相等待对方释放锁	统一加锁顺序、超时、死锁检测
竞态条件	执行顺序影响结果	用同步原语保护关键区域
伪共享	两个变量在同一缓存行被不同 CPU 修改	按缓存行对齐变量
线程泄露	创建线程不 join 或 detach	管理好线程生命周期

十二、典型问题与调试技巧

12.1 段错误（Segmentation Fault）

常见原因：

访问 NULL 指针
数组越界
使用已释放的内存
栈溢出

调试流程：

flowchart TD
    A[程序崩溃 / 段错误] --> B[用 gdb 启动或 attach]
    B --> C[查看 backtrace]
    C --> D{能否定位?}
    D -->|能| E[修复代码]
    D -->|不能| F[用 ASan / Valgrind 检测]
    F --> G[定位内存错误]
    G --> E

12.2 内存泄漏检测

# 用 AddressSanitizer 编译
gcc -fsanitize=address -g program.c -o program
./program

# 或用 Valgrind
valgrind --leak-check=full ./program

12.3 死锁排查

# Linux 下查看线程堆栈
pstack <pid>
# 或
gdb -p <pid>
info threads
thread apply all bt

12.4 性能分析

# CPU 热点分析
perf top -p <pid>
perf record -g ./program
perf report

# 火焰图
perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

12.5 常见面试题速查

问题	核心要点
进程和线程的区别	进程是资源分配单位，线程是调度单位
虚拟内存的作用	隔离、简化、共享
TCP 为什么三次握手	防止历史连接、确认双工能力
死锁四条件	互斥、占有且等待、不可抢占、循环等待
局部性原理	时间局部性、空间局部性
静态链接 vs 动态链接	独立运行 vs 共享节省

十三、学习路线建议

flowchart LR
    A[C 语言基础] --> B[CSAPP 第 1-3 章<br/>信息表示与汇编]
    B --> C[第 4-6 章<br/>处理器 / 缓存 / 链接]
    C --> D[第 7-9 章<br/>进程 / 信号 / 虚拟内存]
    D --> E[第 10-12 章<br/>I/O / 网络 / 并发]
    E --> F[写一个小 Web 服务器]
    F --> G[看 Linux 内核 / 源码]

配套练习：

用 C 写一个简单的 shell（支持 fork/exec/pipe）。
实现一个基于线程池的 HTTP 服务器。
用 epoll 实现高并发 echo 服务器。
用 Valgrind 和 ASan 检查自己的项目。

十四、总结

CSAPP 不是一本"看完就忘"的书，它提供的是理解计算机系统的思维框架：

数据最终都是位，理解编码才能避免溢出和精度问题。
程序跑在 CPU 上，理解汇编和栈才能避免安全漏洞。
内存是分层的，理解缓存和局部性才能写出高性能代码。
操作系统通过进程、虚拟内存、文件系统管理资源。
网络编程要理解 TCP 字节流和 socket 生命周期。
并发编程的核心是同步与避免竞态条件。

最重要的学习方法是：边看书边写代码。把书中的例子跑起来，改一改，看看会发生什么。只有亲手踩过坑，才能真正理解这些知识。

这篇文章是笔者学习 CSAPP 和实践中的总结，难免有疏漏。如果有疑问或建议，欢迎留言交流。

Unix on 方糖猫Blog

《深入理解计算机系统》（CSAPP）学习笔记：给新手的硬件、操作系统与网络并发入门

《深入理解计算机系统》（CSAPP）学习笔记：给新手的硬件、操作系统与网络并发入门

一、为什么要学 CSAPP？

二、计算机系统全景图

三、信息就是位 + 上下文

3.1 整数溢出：新手最常踩的坑

3.2 浮点数精度问题

3.3 大端与小端

四、程序的机器级表示

4.1 从源代码到可执行文件

4.2 调用栈：函数调用的底层

4.3 缓冲区溢出：经典安全漏洞

五、内存层次结构

5.1 速度像金字塔

5.2 局部性原理

5.3 Cache 未命中

六、链接

6.1 静态链接 vs 动态链接

6.2 常见链接错误

七、异常控制流：进程与信号

7.1 进程是什么？

7.2 fork / exec / wait：Unix 进程三件套

7.3 僵尸进程与孤儿进程

7.4 信号

八、虚拟内存

8.1 为什么需要虚拟内存？

8.2 地址翻译：页表与 TLB

8.3 malloc / free 的底层

九、系统级 I/O

9.1 文件描述符

9.2 RIO 包：健壮的 I/O

十、Unix 网络编程核心

10.1 客户端 / 服务器模型

10.2 Socket 编程流程

10.3 TCP 三次握手与四次挥手

10.4 Echo 服务器示例

10.5 网络编程避坑清单

十一、并发编程

11.1 三种并发模型

11.2 线程同步三件套

11.3 生产者 - 消费者模型

11.4 死锁：并发程序的噩梦

11.5 并发编程避坑清单

十二、典型问题与调试技巧

12.1 段错误（Segmentation Fault）

12.2 内存泄漏检测

12.3 死锁排查

12.4 性能分析

12.5 常见面试题速查

十三、学习路线建议

十四、总结