这一章在做什么

什么时候翻这一章

• 服务慢，CPU 却闲着一大半线程不在 CPU 上：在等锁、等下游、等磁盘。先分清线程时间落在哪种状态，再对「不在 CPU 上」的那部分做 off-CPU 分析。§5.4.5§5.4.2场景手册 →
• 线程加了一倍，吞吐不涨甚至往下掉多半是一把锁让大家排了队。看锁的竞争和持有时间；锁哈希表、按桶分锁是常见的改法。§5.4.6§5.2.5
• %sys 很高，不知道内核在替你干什么做系统调用分析：哪个调用最多、每次多大、从哪段代码发出。注意 strace 本身的开销。§5.4.3§5.5.4
• 火焰图里一片 [unknown]，或者栈只有一两层缺符号和缺栈，原因和补法都在这一章最后。§5.6.1§5.6.2
• CPU 很忙，top 里却找不到是谁可能是一个脚本在循环起短命进程，用 execsnoop 抓新进程。§5.5.5场景手册 →
• 换了版本、换了编译选项后变慢静态调优的那串问题：版本、调试构建、编译器和优化级别、内存分配器、限额。§5.4.7§5.3.1场景手册 →

这一章是第 6 章到第 10 章的入口：应用这一侧查出线程在等 CPU、内存、磁盘或网络，再翻到对应资源的那一章。CPU 剖析和火焰图的细节在第 6 章（§6.5.4、§6.7.3），perf 和 BPF 工具的用法在第 13、15 章。

先用中文过一遍

线程状态：先问时间花在哪一种状态上

作者说，每遇到一个性能问题，他用的第一个方法就是线程状态分析（§5.4.5）：把一个线程的时间分进几种有意义的状态，看哪一种占得最多。最粗的分法是两种：在 CPU 上（on-CPU）和不在 CPU 上（off-CPU）。前者再分用户态、内核态；后者原因就多了：排队等 CPU、等换页、等磁盘、等网络、主动睡、等锁，还有闲着等活儿。书里把它细分成九种，每种指向不同的下一步。

Linux 内核的线程状态里，和这件事相关的主要是三种（书里也只用这三种）：R（在跑或可以跑）、S（可中断睡眠）、D（不可中断睡眠，多半在等磁盘），离九种差得远。所以要拼：/proc/PID/stat 有用户态和内核态时间，/proc/PID/schedstat 的第二个数是排队等 CPU 的累计纳秒，/proc/PID/status 里有两个切换计数。下面这张图说明这两个计数各在什么时候加一：线程自己拿不到锁、等 IO 而睡下去，是主动切换；时间片到了被别人抢下，是被动切换。主动切换涨得飞快、被动切换几乎不动、排队时间也不涨，线程就是在等 CPU 以外的东西。

还要提防一个误读：不在 CPU 上的时间里，常常有一大块是「闲着等活儿」。工作线程在条件变量上等任务、在 socket 上等下一个请求，看起来像等锁、等网络，其实是空闲。书里说，优化的是除空闲以外的每一种状态。

off-CPU 分析：在线程睡下去的那一刻记账

CPU 剖析是定时打断正在跑的线程、记下栈，所以它天生看不见睡着的线程。off-CPU 分析补的就是这一半（§5.4.2）。现在常用的做法是跟踪调度器：线程被切下 CPU 的那一刻记下它的栈和时间戳，切回来时算出睡了多久，按栈累加。睡着的线程不会改自己的栈，所以每次阻塞只要读一次栈。累加出来可以画成 off-CPU 火焰图，宽度是睡着的时间，读法和 CPU 火焰图一样：先看最宽的塔。

代价是开销。CPU 剖析的成本跟 CPU 数和采样频率走；off-CPU 跟的是线程数和调度事件数，书里举的例子是一台机器每秒十万次以上的调度事件。作者的 offcputime 用 BPF 在内核里汇总，只交出不同的栈和总时长，还默认丢掉极短的阻塞，即便如此，他也建议先在测试环境量一量开销再上生产。另一个难处是解读：系统范围的 off-CPU 火焰图往往被闲着的线程占满，要放大到处理请求的那个函数，或者用 -M 丢掉长睡（书里建议试 -M 900000，即丢掉超过 0.9 秒的阻塞，§5.5.3）。

锁：等的人是在转圈，还是在睡

多线程程序的锁，一旦成了瓶颈，拿锁的线程就串成一队一个一个过。要分析锁，书里只问两件事：现在有没有竞争，持有时间是不是太长（今天不是问题，负载上去就是）。对剖析来说，关键是等锁的人在干什么。自旋锁（spin lock）的等待者在 CPU 上转圈，等待时间显示成 CPU 时间，CPU 剖析一眼就能看到；互斥锁（mutex）的等待者睡下去，不占 CPU，剖析里几乎没有它。Linux 内核的 mutex 是两者的混合，分三条路走，见下图（§5.2.5）。

改锁的思路也在 §5.2.5：一把全局锁最简单，但所有线程排一队；每份数据一把锁，竞争最少，却要为每把锁付内存和创建销毁的钱；中间是锁哈希表（hash table of locks），固定若干把锁，按数据地址的哈希挑一把，桶数最好不少于 CPU 数。还有一个 C/C++ 程序员会撞上的坑：一排锁挨着放在内存里，两把锁落进同一条缓存行，两个 CPU 改不同的锁也会互相作废对方的缓存，这叫伪共享（false sharing），用填充把每把锁隔到自己的缓存行里。

栈为什么会断，函数名为什么没了

剖析器拿到的是一串指令地址，要变成函数名得查符号表（§5.6.1）。发行版的二进制大多 strip 过，符号表被剥掉，你看到的就是十六进制地址或 [unknown]；补法是构建时别剥，或者另装调试信息（Debian 上是 -dbg、-dbgsym 包）。

栈断了是另一回事（§5.6.2）。perf 和 BPF 工具默认靠帧指针回溯：x86-64 上 RBP 寄存器指向当前栈帧，帧里存着上一帧的 RBP 和返回地址，一路读下去就是调用链。可是编译器为了多一个通用寄存器，常常把帧指针省掉（本站查过 gcc 14：从 -O1 起默认开着 -fomit-frame-pointer），RBP 里就成了随便什么数。运气好，回溯工具查不到它，打印 [unknown]；运气差，它碰巧落在某个函数的地址范围里，你看到一个根本没被调用过的函数名。libc 通常是不带帧指针编译的，所以经过 libc 的栈特别容易断。书里给的补法：自己的代码加 -fno-omit-frame-pointer 重编，开销常常量出来不到 1%；或者换不靠帧指针的回溯方式，比如 perf 的 DWARF 回溯。

方法：按什么顺序查

书里列了八种方法，建议按表里的顺序试：CPU 剖析、off-CPU 分析、系统调用分析、USE、线程状态分析、锁分析、静态调优、分布式跟踪（§5.4）。可作者又说，线程状态分析是他每次的第一步（§5.4.5）。两句话不矛盾：先用几个便宜的数分清时间落在 CPU 上还是 CPU 外，再决定走剖析还是走 off-CPU。本站按这个思路排成下面几步。

1. 线程的时间在 CPU 上，还是不在？

   pidstat -u -w -t -p PID 1 看每个线程的 %usr + %system 和 cswch/s；perf stat -e task-clock -p PID -- sleep 10 看「CPUs utilized」。干活的线程有 8 个、却只用了一两个 CPU，切换又以主动的为主，就是在等；%wait 高才是等 CPU，去第 6 章。§5.4.5

2. 在 CPU 上：哪段代码？

   perf record -F 99 -g，画火焰图，先看最宽的塔和平台。顺便找「脚印」：火焰图里搜 utex、tcp、blk、ext4，能看出锁、网络、块设备、文件系统有没有参与，但看不出等了多久。§5.4.1

3. 不在 CPU 上：睡在哪？

   有 root 就用 offcputime-bpfcc -p PID 10，画 off-CPU 火焰图；先放大到处理请求的函数，或者用 -M 丢掉闲着等活儿的长睡。没有 root 时，cat /proc/PID/task/*/wchan 能看到每个线程睡在哪个内核函数上，futex 开头的就是锁或条件变量。§5.4.2§5.5.3

4. %sys 高或者 IO 很碎：发了哪些系统调用？

   先汇总，再逐条：strace -f -c（加 -w 算墙钟时间），看次数和每次的大小。strace 每个系统调用都要停两次，只在测试环境或很短的时间里用；生产上用 syscount-bpfcc、perf trace -s。一次几十字节、成千上万次的读写，就去改缓冲和 IO 大小。§5.4.3§5.2.1

5. 在等锁：哪把锁，谁拿着不放？

   自旋在 CPU 剖析里看得见；睡眠要用 off-CPU 或锁跟踪（pmlock.bt 看拿锁等了多久，pmheld.bt 看持有了多久，都要 root）。找到锁以后问：能不能缩短临界区、能不能分成几把、锁之间有没有伪共享。§5.4.6§5.5.7

6. 把应用内部的池子也当资源查

   线程池：忙着的线程占几成（利用率）、请求队列多长（饱和度）、拒了多少（错误）；文件描述符：用了上限的几成、有没有 EMFILE。这些数应用多半自己有，没有就加上。§5.4.4

7. 别漏掉配置

   是不是调试构建、用的什么编译器和优化选项、哪个内存分配器、线程池和缓存多大、有没有 CPU 或内存限额、版本有没有已知的性能 bug。这些剖析里不显眼，却常常是答案。§5.4.7

工具速查

pidstat 在 sysstat 包里；perf 在 Debian 上是 linux-perf 包；strace 是同名的包；带 -bpfcc 后缀的是 bpfcc-tools 包里的 BCC 工具，要 root；pmlock.bt、pmheld.bt 是作者 bpf-perf-tools-book 仓库里的 bpftrace 脚本，要先装 bpftrace，也要 root。不要 root 的：perf 剖析自己启动的程序、pidstat、/proc 下自己进程的文件、strace 跟踪自己启动的程序（挂到已经在跑的进程上要 ptrace 权限）。常用的几个：pidstat、perf、strace、offcputime、profile、syscount、execsnoop、bpftrace。

动手：在自己的机器上试

// lock.c：8 个线程更新一张共享的计数表，每次更新都要先拿锁
// 用法：./lock 锁的个数（1 = 一把全局锁；8 = 按桶分的 8 把锁）
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define NOINLINE __attribute__((noinline))
#define NTHREADS 8
#define NBUCKETS 64
#define ROUNDS   10000

// 每把锁填充到 64 字节，各占一条缓存行，免得伪共享
static struct {
    pthread_mutex_t m;
    char pad[64 - sizeof(pthread_mutex_t) % 64];
} locks[NBUCKETS];
static unsigned long table[NBUCKETS][64];
static int nlocks = 1;

NOINLINE static void update(unsigned long *row, unsigned key) {
    for (int k = 0; k < 1024; k++)            // 在锁里做一段活，几十微秒
        for (int i = 0; i < 64; i++)
            row[i] = row[i] * 31 + key + k;
}

NOINLINE static void *worker(void *arg) {
    unsigned key = (unsigned)(long)arg;
    for (int r = 0; r < ROUNDS; r++) {
        key = key * 1103515245u + 12345u;     // 换一个桶
        unsigned b = key % NBUCKETS;
        pthread_mutex_t *m = &locks[b % nlocks].m;
        pthread_mutex_lock(m);
        update(table[b], key);
        pthread_mutex_unlock(m);
    }
    return NULL;
}

int main(int argc, char **argv) {
    if (argc > 1) nlocks = atoi(argv[1]);
    if (nlocks < 1 || nlocks > NBUCKETS) nlocks = 1;
    for (int i = 0; i < NBUCKETS; i++) pthread_mutex_init(&locks[i].m, NULL);
    pthread_t t[NTHREADS];
    for (long i = 0; i < NTHREADS; i++) pthread_create(&t[i], NULL, worker, (void *)i);
    for (int i = 0; i < NTHREADS; i++) pthread_join(t[i], NULL);
    printf("locks=%d done, table[0][0]=%lu\n", nlocks, table[0][0]);
    return 0;
}

# 第一步：它用了几个 CPU？
$ gcc -O2 -g -fno-omit-frame-pointer -pthread lock.c -o lock
$ perf stat -e task-clock ./lock 1
$ perf stat -e task-clock ./lock 8
# 第二步：程序跑着的时候，看每个线程的状态、睡在哪、切换了多少次
$ ./lock 1 & sleep 1
$ P=$(pgrep -n -x lock); for t in /proc/$P/task/*; do echo ${t##*/} $(cut -d' ' -f3 $t/stat) $(cat $t/wchan) $(awk '/ctxt/{print $2}' $t/status); done
$ ./lock 1 & sleep 0.5; pidstat -u -w -t -p $(pgrep -n -x lock) 1 1
# 第三步：它们在发什么系统调用（-w：按墙钟时间统计）
$ strace -f -w -c ./lock 1
# 第四步：CPU 剖析能看到什么
$ perf record -F 99 -g ./lock 1
$ perf report --stdio --no-children
$ perf record -F 99 --call-graph dwarf ./lock 1
$ perf report --stdio --no-children

perf stat, 1 把锁:   4,497.27 msec task-clock  #  1.434 CPUs utilized
                     3.137 seconds time elapsed
perf stat, 8 把锁:   3,783.51 msec task-clock  #  5.561 CPUs utilized
                     0.680 seconds time elapsed

/proc（TID、状态、wchan、主动切换、被动切换）:
        3720900 S futex_wait_queue 3074 0
        3720901 S futex_wait_queue 2993 0
        3720902 R 0 3269 0

pidstat:    TID    %usr %system   %wait    %CPU
        3701529    9.90    4.95    0.00   14.85
            TID   cswch/s nvcswch/s
        3701529   2957.43      0.00

strace: % time     seconds  usecs/call     calls    errors syscall
         99.94   17.454654         161    107829     46913 futex

perf report（帧指针）:   94.94%  lock  lock  [.] update
                          ---update
                             0x70e9de596b7b
perf report（dwarf）:    97.36%  lock  lock  [.] update
                          ---update
                             worker

// smallio.c：写 20 万条日志记录
// 用法：./smallio raw 文件名   每条记录一次 write(2)
//       ./smallio buf 文件名   先攒进 64 KB 的缓冲区，满了再写
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#define NREC 200000
#define RECSZ 32

int main(int argc, char **argv) {
    if (argc < 3) return 1;
    int raw = strcmp(argv[1], "raw") == 0;
    int fd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) return 1;
    static char buf[64 * 1024];
    size_t used = 0;
    char rec[RECSZ];
    for (int i = 0; i < NREC; i++) {
        int n = snprintf(rec, sizeof rec, "%09d level=info msg=ok\n", i);
        if (raw) { write(fd, rec, n); continue; }
        if (used + n > sizeof buf) { write(fd, buf, used); used = 0; }
        memcpy(buf + used, rec, n); used += n;
    }
    if (used) write(fd, buf, used);
    close(fd);
    return 0;
}

$ gcc -O2 -g smallio.c -o smallio
$ time ./smallio raw out.log
$ time ./smallio buf out.log
$ strace -c ./smallio raw out.log
$ strace -c ./smallio buf out.log
# strace 自己的代价：同一个程序，挂上 strace 再计时
$ time strace -o /dev/null ./smallio raw out.log
$ time strace -e trace=openat -o /dev/null ./smallio raw out.log
$ time strace --seccomp-bpf -f -e trace=openat -o /dev/null ./smallio raw out.log
$ rm out.log

raw:  real 0m0.225s   user 0m0.016s   sys 0m0.209s
buf:  real 0m0.019s

strace -c, raw:   calls 200000  write
strace -c, buf:   calls     86  write

不挂 strace:                       real  0.22s
strace（全跟）:                    real 24.8s
strace -e trace=openat:            real 21.3s
strace --seccomp-bpf -e openat:    real  0.24s

成书之后

分节地图

这一章先讲应用的背景和常用的性能技术（§5.1–5.3），再讲方法（§5.4）和工具（§5.5），最后是缺符号、缺栈（§5.6）。上手只需要方法里的五节、编译型语言一节和最后两节的坑；技术部分 C/C++ 程序员大多熟悉，用到时再查，各个 BPF 工具也是。

1. Performance is best tuned closest…约 200 词开篇为什么从应用查起，以及这一章的学习目标。
2. Application Basics约 600 词应用基础接手一个陌生应用时先问的一串问题：它干什么、怎么配置、有哪些指标和日志。
3. Objectives约 400 词目标延迟、吞吐、资源利用率、价格四类目标，怎样写成能量化的数；Apdex。
4. Optimize the Common Case约 200 词优化常见路径先找生产负载下最常走的代码路径。
5. Observability约 100 词可观测性为什么看得见内部的应用，长期来看很可能比跑分快一成的应用更好。
6. Big O Notation约 200 词大 O 记法算法复杂度的复习，C/C++ 程序员都学过。
7. Application Performance Techniques约 100 词应用的性能技术七种技术的引子。
8. Selecting an I/O Size约 200 词选 IO 大小大块省固定开销，太大又浪费和拖延迟。
9. Caching约 100 词缓存部署时查清有哪些缓存、各多大。
10. Buffering约 100 词缓冲攒批写提高效率，代价是第一笔要等；环形缓冲区。
11. Polling约 200 词轮询轮询的两种代价；poll 为什么在连接多时变慢，epoll 怎么避开。
12. Concurrency and Parallelism约 1500 词并发与并行协程和事件驱动、三种线程池模型、同步原语、锁哈希表和伪共享。改锁之前读。
13. Non-Blocking I/O约 200 词非阻塞 IO一个连接一个线程的两个问题；几种异步接口，含 io_uring。
14. Processor Binding约 200 词绑定处理器绑核换局部性；容器里多个租户绑到同一批核的坑。
15. Performance Mantras约 100 词性能箴言指回第 2 章那串从「别做」开始的调优顺序。
16. Programming Languages约 200 词编程语言所谓语言的性能优化，多半是运行时的。
17. Compiled Languages约 500 词编译型语言符号表、优化级别、为什么要保留帧指针和 -g；临时降优化级别为什么靠不住。
18. Interpreted Languages约 200 词解释型语言剖析脚本时只看见解释器自己的函数。
19. Virtual Machines约 200 词语言虚拟机JVM 一类，C/C++ 读者用不到；要剖析 Java 时再来。
20. Garbage Collection约 300 词垃圾回收C/C++ 没有 GC；用 Java、Go 时再看。
21. Methodology约 100 词方法八种方法的总表和建议的顺序。
22. CPU Profiling约 800 词CPU 剖析为什么先用内核里的剖析器；读不懂函数名怎么办；从火焰图里找 off-CPU 的脚印。
23. Off-CPU Analysis约 900 词off-CPU 分析三种做法和各自的开销；off-CPU 火焰图；怎样滤掉闲着等活儿的时间。
24. Syscall Analysis约 200 词系统调用分析跟新进程、剖析 IO、解释内核态时间三个用处。
25. USE Method约 300 词USE 方法把线程池、文件描述符这类软件资源也当资源查。
26. Thread State Analysis约 1400 词线程状态分析九种状态各指向哪一步；在 Linux 上用线索、off-CPU、直接测量三种办法拼出来。
27. Lock Analysis约 200 词锁分析竞争和持有时间；自旋锁和自适应锁在 CPU 剖析里的样子。
28. Static Performance Tuning约 300 词静态性能调优一串检查配置的问题：版本、调试构建、编译选项、分配器、大页、限额。
29. Distributed Tracing约 300 词分布式跟踪跨服务的请求怎么拆开看；头部采样和尾部采样。
30. Observability Tools约 200 词观测工具工具总表；栈里出现 [unknown] 时先翻 §5.6。
31. perf约 600 词perfCPU 剖析、火焰图、perf trace 跟系统调用和它比 strace 好在哪。
32. profile约 100 词profileBCC 的定时采样剖析器，细节在第 6 章。
33. offcputime约 300 词offcputime按栈汇总阻塞时间；-m、-M 两个阈值；画 off-CPU 火焰图。
34. strace约 500 词strace常用选项、-c 的各列，以及它的开销为什么大。
35. execsnoop约 200 词execsnoop跟踪新进程，抓循环启动的短命进程。
36. syscount约 100 词syscount全系统按调用或按进程数系统调用。
37. bpftrace约 900 词bpftrace跟信号、IO 大小和延迟直方图、pthread 锁的等待和持有、USDT 和 uprobes。
38. Gotchas约 100 词常见的坑缺符号和缺栈的引子。
39. Missing Symbols约 400 词缺符号ELF 二进制被 strip；JIT 运行时的符号表和 perf map 文件。
40. Missing Stacks约 400 词缺栈栈为什么只剩一两层，帧指针和其他回溯方式。C/C++ 读者必读。
41. Exercises约 400 词习题习题；动手部分本页已经给了替代。

词与短语

只收先读和用到再查两档的节。斜体那一行是原句里连续的几个词，在电子书里搜它就能找到那一句。

§5.1.1 Objectives

§5.1.3 Observability

§5.2.1 Selecting an I/O Size

§5.2.5 Concurrency and Parallelism

§5.2.7 Processor Binding

§5.3 Programming Languages

§5.3.1 Compiled Languages

§5.3.2 Interpreted Languages

§5.4.1 CPU Profiling

§5.4.2 Off-CPU Analysis

§5.4.5 Thread State Analysis

§5.4.6 Lock Analysis

§5.5.1 perf

§5.5.4 strace

§5.5.5 execsnoop

§5.6.1 Missing Symbols

§5.6.2 Missing Stacks

诊断题：换成你来查

场景和输出都是本站编的。先自己判断，再点选项看解释。

   TID   %usr  %system  %wait  cswch/s  nvcswch/s
 21877    4.0      3.0    0.0   2810.0        0.0
 21878    5.0      2.0    0.0   2944.0        1.0
 21879    4.0      3.0    0.0   2776.0        0.0
 (其余线程相近)

perf stat:    1.31 CPUs utilized
perf report:  91.2%  encode_block
               1.5%  pthread_mutex_lock

  12.4%  [.] __send
         |
         ---__send
            [unknown]

% time    calls  syscall
  97.30    48210  write
   1.10      120  read

    pthread_cond_wait
    pool_wait_task
    worker_main
    start_thread
        -   worker (21901)
        870412311   (us, 32 个线程合计)

值得停下来的句子

This is the first methodology I use for every performance issue, but it is also an advanced activity on Linux.— §5.4.5。本站译：每个性能问题，我用的第一个方法都是它；可在 Linux 上，这也是一件高级的活儿。

「第一个」和「高级」放在一句里，说的是 Linux 的现状：内核给出的主要是 R、S、D 这几种状态，离九种差得远，要靠几样工具拼。可拼起来并不难：本页的实验里，perf stat 的一个数、/proc 里的两个切换计数和 wchan，几分钟就把时间落到了「等锁」这一格。先问状态，就不会对着一张 CPU 火焰图去优化一个根本不是瓶颈的函数。

the benefits of being able to use stack traces to find performance wins usually far outweigh this cost.— §5.6.2。本站译：能用调用栈找到性能收益，这个好处通常远远超过（保留帧指针的）代价。

省掉帧指针换来的那一点性能，是现在就能拿到的；栈断了丢掉的收益，是以后才发现拿不到的。对 C/C++ 程序员，这句话直接落到构建脚本上：发布版也加 -fno-omit-frame-pointer，加 -g 再把调试信息单独存一份（§5.3.1 的脚注建议做成 debuginfo 包）。等到线上出问题再重编，往往已经复现不了。

带走的几条

一句话：先问线程在不在 CPU 上：在，就剖析；不在，就去找它在等什么。