计算机是怎么长出来的
总目录/ 第 1 部/ 1.6 把程序做出来的一套工具/ 1.6.4

1.6.4 性能分析:程序慢在哪一行

约 0.6 万字 · 6 张图 · 读完你能说清采样和插桩的区别、 火焰图的横轴为什么不是时间、为什么「CPU 只占 5%」是一句危险的话, 以及为什么你自己写的计时器量出来的数字经常是假的

上一节最后问:一个接口慢了 200 毫秒,时间花在哪儿了? 这个问题,猜的准确率低得惊人。

你觉得是那个嵌套循环,花了两小时把它改成哈希表,结果快了 3 毫秒; 真正的问题是一句忘了建索引的查询,占了 180 毫秒。 不是判断力不行,是人的直觉对「时间分布」几乎没有感知能力—— 你只会注意到代码里最复杂的那段,而 CPU 不在乎复杂度,它只在乎被执行了多少次。

所以性能优化有一条铁律:先测量,再动手。 这一节讲的就是「测量」这件事: 性能分析器在原理上是怎么工作的、火焰图该怎么读、 为什么 CPU 忙和 CPU 在等要用两把不同的尺子, 以及为什么你自己写的那个 System.currentTimeMillis() 计时器,量出来的数字经常是假的。

本节的小部分

  1. 1 猜错的概率有多高
  2. 2 两种测法:采样与插桩
  3. 3 采样为什么准
  4. 4 火焰图怎么读
  5. 5 CPU 忙,和 CPU 在等
  6. 6 那 800 毫秒到底花在哪儿
  7. 7 内存:谁在吃,谁在漏
  8. 8 IO 与锁:看不见的等待
  9. 9 微基准的四个陷阱
  10. 10 Amdahl:优化的天花板
  11. 11 什么时候不该优化
  12. 12 收尾:它测不出什么

1.6.4-1猜错的概率有多高

有个流传很广的观察:程序员对自己代码性能的猜测,准确率大约三成。 这不是能力问题,是三件事叠在一起造成的:

一是不知道哪段被执行了多少次。 一行看起来很轻的代码,如果在一个百万次的循环里,它的总耗时可能超过外面那坨复杂的逻辑。

二是不知道编译器做了什么。 你以为的那次函数调用,可能被内联了;你以为的那次内存读,可能在寄存器里;你以为的那个循环,可能被向量化了。

三是不知道硬件在干什么。 同样的指令数,顺序访问内存和随机访问能差十倍;分支可预测和不可预测能差五倍。 这些都不在源码里。

所以性能分析器存在的意义,不是「让程序变快」, 而是把「我以为」换成「数据显示」。 它不优化任何东西,它只是告诉你时间到底花在哪儿。

1.6.4-2两种测法:采样与插桩

所有性能分析器,原理上都归到两类:隔一会儿问一下,或者在每个门口装个计数器。

上半部分是采样:一条时间轴上排着 parse、render、sort、network 四个函数段,每隔一段就有一根红线穿过,表示一次采样;下半部分是插桩:每个函数入口和出口都有记录点,嵌套展示调用关系
图 1.6.4-1 两种测法。采样是「隔十毫秒问一次你在干嘛」,插桩是「进出每个函数都记一笔」。前者的开销小到可以一直开着,后者的精度高到能数清每个函数被调了多少次。代价差了一百倍,所以选哪个不是偏好问题,是能不能承受的问题。
采样插桩
做法定时中断,记下当前指令地址函数入口出口各插一条记录
开销1% 到 3%30% 到 200%,函数越碎越贵
精度统计意义上的占比精确的调用次数与耗时
盲区活不到采样间隔的短函数几乎无盲区,但会改变程序行为
用在哪生产环境常开本地排查、单元级测量

生产环境默认用采样,理由很直接:插桩会把程序变慢一倍,而变慢一倍的系统和真实的系统不是同一个系统。 你测出来的瓶颈,可能是插桩本身造成的。

各语言生态里现成的工具大概是这样:

环境工具能测什么
Linux 通用perf record / perf reportCPU 采样,任何语言都能用,不需要改代码
C / C++perf、gprof、ValgrindCPU 热点、调用次数、内存错误
GopprofCPU、堆、goroutine 阻塞、锁竞争,一个工具全包
Javaasync-profiler、JFRCPU、分配、锁、GC,能画出混合火焰图
Pythonpy-spy、cProfile前者能直接 attach 到运行中的进程,不用改代码
浏览器 / NodeDevTools 的 Performance 面板JS 执行、渲染、网络,按时间轴对齐

挑工具的原则只有一条:先确定要测哪一层,再挑对应那一层的工具。 拿 perf 去查一个在等数据库的接口,你会看到 CPU 一片空闲, 然后误以为「没有瓶颈」——这个坑前面刚讲过,但每年还是有人掉进去。

1.6.4-3采样为什么准

「每隔十毫秒随便看一眼」,听起来很不靠谱。它准是因为大数定律。

假设一个函数占了总时间的 30%。那么随机看 1000 次,落在它里面的次数大约是 300 次, 误差在 ±3% 左右(大致是 1/√n 的量级)。 想看更准就多采——采一万次,误差降到 1%。

这个「随机」是有保证的:采样是由定时器触发的,落点和你代码的执行节奏没有关系。 所以它天然是均匀抽样,不需要任何技巧。

它确实有一个盲区:活不到一个采样间隔的函数,一次都采不到。 间隔是 10 毫秒,一个只跑 1 毫秒的函数,被采到的概率是 10%—— 跑十次能碰上一次。如果一个函数只被调用一次、只花 0.5 毫秒, 它在报告上就完全不存在。

所以采样报告里的「没看到」不等于「不慢」。 它只说明「在采到的那些瞬间,CPU 没在它里面」。 要抓这类短命的热点,得把采样间隔调小(比如 1 毫秒), 或者换插桩,或者用「先看总体、再针对可疑区域精确测」的两段式打法。

1.6.4-4火焰图怎么读

采样结果最后通常画成一张火焰图。它的形状很唬人,但规则只有三条。

火焰图:底层是 main 100%,往上依次是 handle_request 74% 和 log 26%,再往上是 parse_json 43% 和 validate 31%,最上层最宽的一块是 scan_string 37%,用红色标出
图 1.6.4-2 火焰图。每一层的宽度是这个函数占用的时间比例,不是它在时间轴上的位置。最上面那一层没有子块、又很宽的那一段(图里的 scan_string),就是真正在干活的地方——它下面没有更细的分解了,说明时间就消耗在它自己身上。

规则一:横轴是「占比」,不是时间。 这是最常见的误读。左边不等于「先执行」,右边不等于「后执行」, 同一层里两个块挨在一起也不代表它们有先后关系。 横轴唯一的含义是「宽度 = 多少比例的时间」。

规则二:纵轴是调用栈深度。 自下而上是「谁调用了谁」。下面的块一定比上面的宽,因为它包含上面所有子块的时间。

规则三:找「平顶」。 一个块如果很宽、下面没有子块,说明时间就花在它自己身上,而不是它调用的东西上。 这就是优化的下手处。反过来,一个块很宽但下面还有很宽的子块, 说明它只是个「过路」的,真正的时间在更深处。

顺便打消一个常见的困惑:火焰图里的颜色没有任何含义。 红黄绿只是用来区分相邻的块,方便眼睛跟踪边界;有些工具按函数名哈希上色, 有些按模块上色,但都不是「越红越热」。真正要看的只有宽度。

还有一种变体叫冰柱图(icicle graph),形状上下颠倒,根在顶上。 以及一个更有用的变体:off-CPU 火焰图—— 它画的不是「CPU 在跑什么」,而是「线程被阻塞在哪儿」。 排查「等锁」「等 IO」这类问题时,后者才是对的图。下一节就讲这个区别。

1.6.4-5CPU 忙,和 CPU 在等

前面所有内容都建立在一个隐含前提上:时间花在 CPU 上。 可真实系统里,大量的时间是「等」出来的。

两条横条对比:上面是墙上时钟 800 毫秒全长,下面是 CPU 时间只有 60 毫秒,标注出剩下 740 毫秒都在等数据库、等锁、等网络
图 1.6.4-3 同一个接口的两个数字。墙上时钟 800 毫秒,CPU 真正干活只有 60 毫秒,差 13 倍。CPU profiler 采的是「CPU 正在执行哪条指令」,CPU 在等 IO 的时候它没东西可采——在你眼里就是一片空白。所以拿它去查一个 IO 密集的接口,结论会是「哪儿都不慢」。

这就是那句话危险的原因:「CPU 占用只有 5%,所以没问题」。 CPU 闲,恰恰可能是因为它在等——等数据库、等锁、等网络、等磁盘。 系统的瓶颈不在 CPU 上,不代表没有瓶颈。

对应的工具也不同:

你想知道该用的工具它看的是什么
CPU 算得累不累CPU profiler(采样)CPU 正在执行哪条指令
线程等了多久wall clock profiler线程当前在等什么
卡在哪个系统调用strace / perf trace每一次进出内核
锁竞争多严重锁分析器 / 线程 dump谁占着锁、谁在排队
数据库慢在哪慢查询日志 / EXPLAIN每条 SQL 的执行计划

1.6.4-6那 800 毫秒到底花在哪儿

把刚才那个接口拆开,时间分布是这样的:

堆叠条形图,总长 800 毫秒,分成五段:CPU 60 毫秒、等数据库 520 毫秒、等锁 120 毫秒、GC 40 毫秒、网络 60 毫秒
图 1.6.4-4 同样的 800 毫秒,拆成五段。真正在算的只占 7.5%,其余的都在等。这四类「等」在 CPU 火焰图上全是空白:等数据库要看慢查询日志,等锁要看线程状态,GC 要看回收日志,网络要看系统调用。每一种都有自己的尺子,用错尺子就找不到瓶颈。

这个分布解释了一件事:优化 CPU 代码,最多只能省下那 60 毫秒。 就算你把计算部分优化到零,接口也只从 800 变成 740——用户根本感觉不到。 真正该动的是那 520 毫秒的查询:加一个索引,可能直接降到 5 毫秒。

这就是 Amdahl 定律的直觉版本(第 10 节细说): 你只能优化你测到的那部分,而最大收益永远在占比最大的那一段。

1.6.4-7内存:谁在吃,谁在漏

内存问题分两类,排查方法完全不同。

一类是「占用高但不漏」。 程序合理地把大量数据放在内存里(缓存、索引、缓冲区),这没问题。 要看的是分配热点:哪些代码在疯狂申请对象。 分配本身很快,但分配多了会触发 GC,GC 一停,所有线程都停。

另一类是「真的在漏」。 对象该被回收却没被回收,内存一路涨到 OOM。 排查方法是拍两次堆快照,对比差集: 跑一段时间拍一张,再跑一段时间拍第二张,两张之间「多出来的那些对象」就是嫌疑犯。 直接看总量没意义,因为正常业务也会涨。

对用户来说,内存问题最终都表现为同一个东西:GC 停顿。 堆越大、活对象越多,一次回收要扫描的范围越大,停得越久。 一个每秒处理几千请求的服务,如果每十秒停 200 毫秒, 那么每十秒就有两百毫秒的请求全部超时——这比平均慢 10% 严重得多。

看 GC 要看三个数: 停顿时间(一次停多久)、频率(多久停一次)、 停顿占的比例(总时间里有百分之几在停)。 第三个数字最直观:低于 1% 基本无感,超过 5% 用户能明显感觉到卡。 吞吐量、总回收次数这些数字,对体验的影响远没有这三个大。

1.6.4-8IO 与锁:看不见的等待

这两类等待有个共同点:它们不在你的代码里。 所以你盯着源码看一辈子也看不出来。

IO 的排查从系统调用开始。 strace 能把进程每一次进出内核都打出来: 打开了哪个文件、读了多少字节、等了多久。 常见的坑是「小 IO 太多」——一次读 4 KB,读一千次,就是一千次系统调用, 每次都要用户态内核态来回切换。改成一次读 4 MB,次数少一千倍。

锁的排查要看线程状态。 一个线程在等锁的时候,状态是 BLOCKED 或 WAITING, CPU 占用是 0,所有 profiler 都看不见它。 这时候要拍线程 dump:把所有线程的调用栈打出来, 看看有多少个线程卡在同一个位置——如果一百个线程都停在「等这把锁」, 那瓶颈就不言而喻了。

「100 个线程,97 个卡在这一行」
    at com.example.Cache.get(Cache.java:42)
    - waiting to lock <0x000000076b5a8c08> (a java.util.HashMap)

剩下 3 个在干嘛?其中一个正拿着这把锁做一件很慢的事。
锁的粒度太粗了 —— 整张表一把锁,所有读都被串起来。

数据库的排查靠慢查询日志和执行计划。 这一条在 1.5.3 讲过:一条没走索引的查询,扫两百万行要几百毫秒; 加上索引之后是几毫秒。这种差距不是「优化代码」能弥补的, 因为瓶颈根本不在代码里,在数据怎么被取出来。

1.6.4-9微基准的四个陷阱

有时候你想测的不是整个程序,而是「这两行写法哪个快」。 于是写一个小循环,前后各取一次时间戳,跑一百万次,得出结论。 这个结论大概率是错的。

折线图:横轴是对数刻度的调用次数,纵轴是每次耗时微秒,曲线从 200 微秒开始快速下降,到一千次之后稳定在 5 微秒左右
图 1.6.4-5 JIT 预热曲线。同一段代码,刚启动时慢 40 倍。前一百次是解释执行,之后 JIT 才开始编译热点代码,编译完才降到真实速度。所以「跑一千次取平均」这种做法,测出来的是「预热阶段的平均」,比稳态慢好几倍。正经的基准框架要跑几千轮、丢弃前面的预热段。

四个陷阱,一个比一个隐蔽:

一是 JIT 预热。就是图里那条曲线。 你的测量窗口如果落在下降段上,测出来的数字既不是解释执行的速度,也不是稳态速度, 而是两者之间某个说不清的值。

二是死代码消除。你测「算一百万次哈希要多久」, 可如果算出来的哈希没人用,编译器会认定这些计算没有副作用, 把整个循环删掉。于是你测出来「一百万次哈希只要 0.3 纳秒」—— 那是空循环的时间。防法是把结果写进一个 volatile 变量或者打日志。

三是缓存预热。第一次访问一块内存要几百纳秒,之后都在缓存里, 只要几纳秒。你的循环跑到第二遍时,数据已经全在缓存里了, 测出来的速度比真实场景快得多——真实场景里数据是散的、冷的。

四是测量本身的开销。在循环里每次都取时间戳, 这个动作本身就要几十纳秒,可能比你测的那行代码还贵。 正确做法是在循环外面取两次时间,中间不夹任何测量代码。

所以正经的基准测试要用框架: JMH(Java)、criterion(Rust)、benchmark.js(JS)这些工具做的, 就是替你处理上面四件事:自动预热、自动丢弃异常值、防止死代码消除、统计置信区间。 手写计时器不是「简陋版」,是「基本无效版」。

1.6.4-10Amdahl:优化的天花板

假设你找到了热点,它占了总时间的一半,你把它优化到了无限快。 整体能快多少?最多两倍。因为另一半时间一点没动。

三条曲线:可优化比例 50% 时上限是 2 倍,90% 时上限是 10 倍,95% 时上限是 20 倍,三条虚线画出各自的天花板
图 1.6.4-6 Amdahl 定律。净加速的上限是 1/(1−可优化比例),和你怎么优化、优化得多好都无关。热点占 50%,天花板就是 2 倍;占 90%,天花板是 10 倍。所以「整体想快一倍」这个问题,答案往往不是「把热点优化得更好」,而是「先让热点占比变大」——也就是把不热的部分也干掉。

这条定律有三个直接的操作含义:

一是别在 5% 的地方使劲。 把占 5% 的代码优化到零,整体只快 5%——用户感觉不到,但你花了一周。

二是一次只改一个变量。 同时改三处,测出来快了 20%,你不知道是哪一处起的作用, 也不知道其中有没有一处其实在拖后腿。

三是改完必须复测。 因为你优化了 A,B 的占比就变大了,下一个瓶颈可能换人了。 性能优化是个循环,不是一次性动作:测量 → 改一处 → 复测 → 找新瓶颈。

把上面的东西串起来,一次完整的排查大概是这样七步:

1. 复现     找到一个能稳定跑出「慢」的场景(不能复现就没法验证改没改对)
2. 分层     先判断是 CPU 忙、还是在等(看 CPU 占用率是最快的初筛)
3. 选工具   CPU 忙 → CPU profiler;在等 → wall clock / strace / 锁分析 / GC 日志
4. 定位     从火焰图的平顶、或线程 dump 的公共栈,找到具体那一行
5. 改一处   只改这一处,别顺手重构
6. 复测     同样的场景再跑一遍,看数字动了多少
7. 记录     把「原来多少、改了什么、现在多少」写进提交信息

第 7 步经常被跳过,但它决定了下一个人能不能看懂你的改动。 半年后有人看到这段「看起来很怪但没注释」的代码,第一反应是把它改回「正常写法」—— 性能就又回去了。一行注释写清「这里为什么这么写、省了多少毫秒」,能救它一命。

1.6.4-11什么时候不该优化

Knuth 那句「过早优化是万恶之源」经常被引用,但经常被引用错。 完整的意思是:

原话(大意): 我们应该忘掉小的效率提升,在 97% 的情况下说「过早优化是万恶之源」。 但我们不该放过那关键的 3% 的机会。 一个聪明的程序员应该用测量工具找出那 3%,而不是凭直觉猜。

所以这句话不是「不要优化」,是「不要凭直觉优化」。 它反对的是「我觉得这里可能慢,先改一改」,支持的是「我测出这里占 40%,改它」。

具体判断该不该动手,有四个问题可以问:

问题不该优化的信号
这段在热路径上吗一天跑一次,或者只在启动时跑
它占多少时间不到 5%,改了用户也感觉不到
改完还看得懂吗要把三层循环拆成位运算,还得加注释解释
硬件会不会替你把问题解决掉三年后机器快一倍,需求未必涨一倍

最后一条值得展开:性能问题和数据量一样,是有「自然增长率」的。 业务量每年涨 30%,硬件每年快 20%,这个差距要三四年才积累出一次危机。 而一个为了省 5 毫秒写出来的复杂实现,从今天开始就要一直维护。 用复杂度换性能,是一笔要还很多年的贷款。

1.6.4-12收尾:它测不出什么

性能分析器很强,但它的边界也很清楚,三条:

它测不出「用户觉得快不快」。 你把接口从 800 毫秒优化到 300 毫秒,数据上快了 2.7 倍, 但如果页面在等这个接口的时候什么都不显示,用户依然觉得「卡」。 感知性能和测量性能是两个指标:前者靠骨架屏、进度条、乐观更新, 后者靠 profiler。两者的优化手段完全不同。

它测不出「数据量涨十倍会怎样」。 profiler 只反映你当下跑的这一批数据。 一个在十万条数据上表现良好的算法,在一亿条上可能慢一百倍(1.5.4 讲过的阶)。 要回答「以后会不会慢」,得算复杂度,不是看 profiler。

它测不出分布式系统的整体瓶颈。 单机 profiler 只看得到自己这台机器。 一个请求经过五个服务,每个服务都觉得自己很快(各 20 毫秒), 可用户等了 3 秒——时间花在服务之间的网络、重试、排队上。 这需要分布式追踪:给每个请求打一个 ID,把跨服务的调用串成一条时间线。

1.6 这一章到这里就结束了。 四件工具看起来毫不相干,底下的原理却反复出现同样几样东西: 一份文本要变成结构(编辑器解析代码)、 一个地址要翻译回源码(调试器查 DWARF)、 一次运行要留下证据(测试写下断言、profiler 采下样本)。 它们都在做同一件事:把机器世界里的一堆数字,翻译成人能理解的东西。

下一章换个话题。这一章讲的是「一个人怎么把程序做出来」, 下一章讲的是「一群人怎么把同一个程序做出来」—— 版本控制、分支、合并冲突,以及为什么两个改不同文件的人也会撞车。 第一件要讲的东西,是那个几乎所有程序员每天都在用、却很少有人想过它内部长什么样的工具:Git。

自测:能答上 6 题,这一节就算过了

  1. 为什么程序员对性能的直觉准确率很低?说出三个原因。
  2. 采样和插桩的核心区别是什么?为什么生产环境用采样?
  3. 采样为什么能准?它的盲区在哪儿?
  4. 火焰图的横轴代表什么?最常见的误读是什么?
  5. 什么叫「平顶」?为什么它才是优化的下手处?
  6. 「CPU 占用只有 5%,所以没问题」这句话错在哪儿?
  7. 一个接口 800 毫秒,CPU 只占 60 毫秒,该先优化什么?
  8. 查内存泄漏为什么要拍两次堆快照?
  9. 看 GC 该看哪三个数?为什么不是看吞吐量?
  10. 手写计时器测出来的数字为什么会假?说出三个原因。
  11. Amdahl 定律说什么?它带来哪三条操作含义?
  12. 「过早优化是万恶之源」的完整意思是什么?
点开看答案(先自己想,别急着点)
  1. 不知道哪段被执行了多少次(轻代码在百万次循环里)、不知道编译器做了什么(内联、向量化)、不知道硬件在干什么(缓存、分支预测)。这三样都不在源码里。
  2. 采样是定时中断看 CPU 在干嘛,开销 1%~3%;插桩是在每个函数入口出口埋点,开销 30%~200%。生产环境用采样,因为插桩会把程序变慢一倍,而变慢一倍的系统和真实的系统不是同一个系统。
  3. 靠大数定律:随机采一千次,占 30% 的函数大约被采到 300 次,误差 ±3%。盲区是活不到一个采样间隔的短函数——10 毫秒采一次,只跑 0.5 毫秒的函数基本采不到。
  4. 代表「占比」,不是时间轴。最常见的误读是把它当成时间轴,以为左边先执行、越往右越晚。实际上同一层块的位置没有任何时间含义。
  5. 一个块很宽、下面没有子块,说明时间就花在它自己身上,不是花在它调用的东西上。这种块就是真正在干活的地方,改它才有用。
  6. CPU 闲可能是因为它在等——等数据库、等锁、等网络。CPU profiler 采的是「CPU 正在执行哪条指令」,等待的时候没东西可采,于是就显示「哪儿都不慢」,可用户明明等了很久。
  7. 先看那 520 毫秒的数据库查询。CPU 只占 60 毫秒,就算优化到零也只省 7.5%,用户感觉不到;而一个索引可能把 520 毫秒降到 5 毫秒。
  8. 因为总量涨是正常的(业务在跑、缓存温起来),单张快照看不出哪个该回收没回收。两张快照做差集,「多出来的那些对象」才是嫌疑犯。
  9. 停顿时间(一次停多久)、频率(多久停一次)、停顿占比(总时间百分之几在停)。因为用户感知到的是「卡了一下」,不是「吞吐量低了」——吞吐量的损失是停顿造成的,看根因才有用。
  10. JIT 预热(前一千次慢几十倍)、死代码消除(结果没人用,整个循环被删掉)、缓存预热(第二遍数据全在缓存里)、测量代码本身的开销(取时间戳可能比被测代码还贵)。
  11. 净加速上限是 1/(1−可优化比例),热点占 50% 最多快 2 倍。三条含义:别在 5% 的地方使劲;一次只改一个变量;改完必须复测,因为瓶颈会换人。
  12. 不是「不要优化」,是「不要凭直觉优化」。完整版是:97% 的情况下可以忽略小的效率提升,但那关键的 3% 不能放过,而找这 3% 要靠测量工具,不是靠猜。
← 1.6.3 测试:单元、集成与压测