调试系列写到这里,已经有三句话:
崩溃在空间上撒谎,卡死在时间上撒谎,慢在统计里撒谎。
第一句讲的是堆腐烂:崩溃点不是案发第一现场;第二句讲的是卡死:不动是一个读数,不是机理;这一篇补第三句——慢不是一个数,是一个分布。三句话合起来,说的是同一件事:你把观测到的现象当成系统的属性,就把诊断做成了猜谜。
先说清楚这篇的边界。下面的所有输出都是本机实录,没有修饰,也没有挑选”好看的那次”:
- Windows 11(10.0.26300),MSVC 19.51.36260 x64,8 vCPU;
- WSL2 Ubuntu 24.04.1,gcc 13.3.0,内核 6.18.33.2,8 vCPU;
唯一不是实录的是第七节的主案例。它是一个合成的示意案例,参数按 M/M/1 公式和本机实测同量级构造,用来演示归因路径,不是某次真实事故的复盘。这一点我会在案例开头再声明一次。
一、先拆一个前提:性能不是属性,是分布
工程里说”这个接口 20ms”,通常省略了一个定语:哪一种统计量。是平均值?中位数?还是 p99?省略之后,团队会默认彼此说的是同一个东西,而实际上经常不是。
我写了一个最小实验:三段代码,每段模拟 2000 次请求的服务时间。A 和 B 的期望均值都是 6ms,但形状完全不同;C 的均值更低,却有一条更重的尾巴。
- A 稳定型:每次都 6ms;
- B 尖刺型:98% 的请求 3ms,2% 的请求 151.5ms,均值仍约 6ms;
- C 长尾型:90% 为 2ms,9% 为 20ms,1% 为 100ms。
Windows 实测:
hist: same mean, different distribution (all values in ms)
A-stable n=2000 mean= 6.03 p50= 6.00 p90= 6.00 p99= 6.44 p999= 14.36 max= 21.39
B-spiky n=2000 mean= 5.98 p50= 3.00 p90= 3.00 p99= 151.50 p999= 151.50 max= 151.51
C-longtail n=2000 mean= 4.41 p50= 2.00 p90= 20.00 p99= 20.00 p999= 100.00 max= 100.00
Linux 实测:
A-stable n=2000 mean= 6.03 p50= 6.00 p90= 6.00 p99= 6.55 p999= 10.41 max= 16.81
B-spiky n=2000 mean= 6.04 p50= 3.00 p90= 3.02 p99= 151.50 p999= 151.51 max= 152.35
C-longtail n=2000 mean= 4.43 p50= 2.00 p90= 20.00 p99= 20.06 p999= 100.00 max= 100.00
先看 A 和 B。两者的均值是 6.03 和 5.98,差 0.8%,在任何看板上都属于”没有变化”。但:
- B 的中位数是 3ms,比 A 快一倍;
- B 的 p99 是 151.5ms,比 A 差 23 倍;
- B 的 max 和 p99 几乎相等,说明这不是偶发抖动,而是稳定存在的第二条路径。
如果你只看均值,会得出”两个系统差不多”的结论;如果你只看 p50,会得出”B 更好”的结论;只有看 p99,才知道 B 有 2% 的用户在等 151ms。均值把那 2% 的灾难摊平成了 3ms 的增量,看起来像”稍微慢了一点”。
再看 C。它的均值最低(4.41ms),但它是三者里最不可承诺的系统:90% 的请求在 20ms 内,1% 要 100ms,p999 直接跳到 100ms。均值低,是因为大部分请求很快;p999 高,是因为慢路径真实存在。这两件事同时为真,而”平均 4.4ms”这个说法把它们都掩盖了。
所以第一个判据不是”快不快”,而是分布是什么形状。工程上常见的三种形状:
- 平移:整条分布往右移,p50 和 p99 同比例变差。通常是资源整体变慢(CPU 降频、下游整体变慢、网络 RTT 增加)。
- 尾部:p50 不动,p99 变差。通常出现了慢路径、排队、重试、GC、缓存击穿,或者观测者本身。
- 双峰:分布中间出现凹陷,或者 p90 与 p99 之间有一个平台。通常是两条代码路径(命中/未命中、热/冷、同步/异步)被混在同一个指标里。
先判形状,再谈优化。形状不对,优化就是蒙。
二、慢的三种物理形态:在算、在等、在排
“慢”在物理上不是一种状态,至少是三种:
- 在算(on-CPU):线程在 CPU 上执行指令;
- 在等(off-CPU):线程被阻塞,等 I/O、等锁、等下游、等定时器;
- 在排(queued):请求已经到达,但还没有开始被处理,排在队列里。
这三种状态的墙钟时间可以完全一样,但优化手段完全不同。区分它们只需要一个比值:进程(或线程)消耗的 CPU 时间 / 墙钟时间。
我用同一份代码做了三段:
- A:100 次计算,每次 4ms;
- B:40 次等待,每次 10ms;
- C:100 次计算(每次 4ms),每次计算后多等 1ms。
Windows 实测:
A-on-CPU wall= 400.0ms user= 390.6ms sys= 15.6ms cpu_total= 406.2ms cpu/wall=101.6%
B-off-CPU wall= 630.4ms user= 0.0ms sys= 0.0ms cpu_total= 0.0ms cpu/wall= 0.0%
C-cpu-plus-wait wall= 1561.0ms user= 296.9ms sys= 0.0ms cpu_total= 296.9ms cpu/wall= 19.0%
Linux 实测:
A-on-CPU wall= 792.9ms user= 793.0ms sys= 0.0ms cpu_total= 793.0ms cpu/wall=100.0%
B-off-CPU wall= 406.5ms user= 1.5ms sys= 0.0ms cpu_total= 1.5ms cpu/wall= 0.4%
C-cpu-plus-wait wall= 793.3ms user= 682.3ms sys= 0.0ms cpu_total= 682.3ms cpu/wall= 86.0%
这里有几个值得停一下的地方。
第一,B 的墙钟是 630ms,CPU 时间是 0。它确实”慢了 630ms”,但没有任何一行代码在计算。你拿 CPU profiler 去采样,会看到一片空白——不是没采到,是本来就没有东西可采。火焰图上没有峰,不代表没有耗时;它可能只是不在 CPU 上。
第二,C 的墙钟是 A 的 3.9 倍,但 CPU 时间并没有跟着涨:A 是 406ms,C 只有 297ms(同一量级),墙钟却从 400ms 涨到了 1561ms。换句话说,慢的来源不是计算变多了,而是等待被插了进来。如果你按”CPU 时间”做容量规划,会得出”没问题”的结论;如果你按墙钟做 SLO,会发现已经超时。
第三,同一份 C 代码,Windows 的 CPU/墙钟是 19%,Linux 是 86%。原因不在代码,在睡眠粒度:Windows 的 1ms 睡眠实际是 15.6ms,Linux 是 1.1ms(第四节有实测)。同一份代码跑在两个不同的物理系统上,这不是比喻,是字面意思。
补充两点:Windows 的 A 阶段 CPU/墙钟略高于 100%,是计时开销与 CPU 时间统计口径造成的正常偏差;Linux 的 A 阶段墙钟偏大(793ms 对 400ms 的设计值),是 WSL2 在宿主负载下的调度抖动,但 CPU 时间仍约等于墙钟,比值结论不受影响。
三种形态对应的工具也不同:
| 形态 | 直接证据 | 常用工具 | 优化方向 |
|---|---|---|---|
| 在算 | CPU 时间高,采样有热点 | perf record、VTune、ETW/WPA、Visual Studio 诊断工具 | 算法、指令、缓存、并行度 |
| 在等 | CPU 时间低,线程处于阻塞态 | perf sched、offcputime、ETW 等待分析、strace、锁分析 | 减少等待次数、批量、异步、超时与重试策略 |
| 在排 | CPU 不高,队列长度/等待时间高 | 线程池指标、连接池指标、排队论模型 | 提高并行度、削峰、限流、扩容 |
一个常见的误判是:看到 CPU 只有 45%,就说”资源还很空闲”。CPU 空闲只说明没有在算,不说明没有在等或在排。单实例的一把全局锁、一个连接池、一个分区,都可以在 8 核只用了 3 核的情况下把 p99 打到 800ms。第五节给公式,第七节给案例。
三、排队:非线性不是 bug,是数学
单服务台是最小模型:请求按泊松过程到达(速率 λ),服务时间服从指数分布(速率 μ),只有一个服务台。定义利用率:
ρ = λ / μ
排队等待时间的期望是:
E[Wq] = ρ / (μ(1 − ρ))
等待时间在 0 处还有一个原子概率(1 − ρ),连续部分才是指数分布,所以 p99 不是简单的 4.6 倍均值,而是:
p99 = ln(100ρ) / (μ − λ)
我写了一个 100 万客户的离散事件模拟,并用上面的公式对拍。两个平台的结果逐位一致(确定性随机数),下表是 Windows 实录,Linux 完全相同:
rho mean_wait p99_wait theory_mean theory_p99
0.50 1.00ms 7.82ms 1.00ms 7.82ms
0.80 3.96ms 21.66ms 4.00ms 21.91ms
0.90 9.07ms 45.41ms 9.00ms 45.00ms
0.95 19.56ms 97.33ms 19.00ms 91.08ms
0.98 53.48ms 262.95ms 49.00ms 229.25ms
先看均值:ρ 从 0.5 到 0.98,平均排队时间从 1ms 涨到 53ms——50 倍。再看 p99:从 7.8ms 涨到 263ms——34 倍。而 ρ 本身只增加了不到一倍。
ρ=0.98 那一行,模拟的 p99 比理论高 15%(263ms 对 229ms)。这是抽样误差,不是公式错了:100 万样本里只有约 1 万个点落在 p99 以上,极端分位数本身就不稳定。这也顺带说明了第六步为什么要看样本量。
把”排队时间 / 服务时间”单独拎出来看,会更直观:
| ρ | ρ/(1−ρ) | 含义 |
|---|---|---|
| 0.50 | 1.0 | 平均排队时间等于一次服务时间 |
| 0.70 | 2.3 | 排队时间是服务时间的 2.3 倍 |
| 0.90 | 9.0 | 9 倍 |
| 0.95 | 19.0 | 19 倍 |
| 0.98 | 49.0 | 49 倍 |
这就是”70% 法则”的来源:利用率超过 70% 之后,等待时间开始以 1/(1−ρ) 的速度发散。注意它是发散,不是线性增长。容量规划里最常见的错误,是把”还剩 20% CPU”理解成”还能再加 20% 流量”。在 ρ=0.8 的基础上再加 20% 流量,ρ 会到 0.96,p99 不是涨 20%,是涨约 5 倍。
第三个变量是方差。M/M/1 假设服务时间是指数分布;现实里服务时间方差更大(长尾、重试、GC),此时用 Kingman 近似:
E[Wq] ≈ (ρ / (1 − ρ)) × ((c_a² + c_s²) / 2) × E[S]
其中 c_a 和 c_s 是到达间隔与服务时间的变异系数。这个公式解释了一个常见困惑:一个”平均 1ms”的服务,p99 可以是 100ms。因为 p99 不只由均值决定,还由利用率与方差共同决定。你优化了平均服务时间,但方差没降,p99 可能几乎不动。
所以 p99 是系统属性,不是函数属性。它由三样东西共同决定:利用率、方差、容量。把 p99 当成”代码慢”的同义词,是所有性能误判里最常见的一个。
四、观测:你测到的不是原来的系统
现在把尺子本身放到台面上。
观测至少有三种效应:
- 打点成本:每一次读时钟、写日志、加计数,都要花时间;
- 采样偏差:采样频率决定了你能看见什么,也决定了你看不见什么;
- 观测者占资源:观测线程占 CPU、抢 cache line、写日志占 I/O。
先说打点成本。我写了一个固定工作负载(5000 万次整数运算),然后用四种粒度打点:
- 不打点;
- 每 1000 次打一次;
- 每 100 次打一次;
- 每次都打。
Windows 实测:
clock-read cost = 24.3 ns/call (20000000 calls in 486.7 ms)
no-instrumentation median= 81.9ms overhead= +0.0%
clock-every-1000 median= 85.0ms overhead= +3.8%
clock-every-100 median= 103.3ms overhead= +26.1%
clock-every-1 median= 1232.5ms overhead=+1404.9%
Linux 实测:
clock-read cost = 47.1 ns/call (20000000 calls in 941.8 ms)
no-instrumentation median= 115.2ms overhead= +0.0%
clock-every-1000 median= 125.9ms overhead= +9.3%
clock-every-100 median= 146.5ms overhead= +27.1%
clock-every-1 median= 2268.1ms overhead=+1868.2%
这里最重要的不是 1404% 这个数字,而是它的来源:单位错配。被观测的工作单位只有约 1.6ns(81.9ms / 5000 万次),而一次时钟读取要 24ns(Windows)或 47ns(Linux)。观测器的粒度比被测对象大一个数量级,于是”每单位都观测”必然把系统放大十几倍。
这个道理放到真实系统里,要换成真实单位来算。假设每笔请求打两个点,单次成本 30ns:
- 1 万 QPS:2 × 30ns × 10⁴ = 0.6ms/s,约 0.06% 的 CPU,可以忽略;
- 100 万 QPS:60ms/s,约 6% 的 CPU,已经开始要算账;
- 如果打点变成”每请求一行日志”(格式化 + 写文件,微秒到毫秒级),1 万 QPS 就是每秒 10ms 到 10s 的开销,直接改变系统。
所以”可观测性”不是免费的,也不是越细越好。观测预算 = 单次成本 × 每秒观测次数,这是要在设计时算的,不是上线后拍脑袋的。
第二种效应是采样偏差。一个 1kHz 的采样 profiler,每 1ms 采一次栈。它能看见持续几十毫秒的热点,但:
- 短于 1ms 的尖刺可能整段漏掉;
- 阻塞在 I/O、锁、定时器上的线程没有 CPU 栈,采不到;
- 采样点落在哪个线程上,受调度影响,不是均匀的。
这就是为什么”火焰图很平”和”p99 很高”可以同时成立。火焰图回答的是”CPU 在哪儿烧”,不是”时间在哪儿等”。
第三种效应是观测者占资源。监控线程本身要占一个核;如果它读的计数器与业务数据在同一条 cache line 上,每次读都会把这条线从”已修改”打回”共享”,写入方下一次写就要重新申请独占。这个成本在低频抓取时可以忽略,在高频抓取时会变成实打实的吞吐损失。它和打点成本是同一种东西:观测者的动作进入了被观测系统的因果链。
最后是定时器粒度。同一行”睡 1ms”,两个平台的实测:
Windows:
default n=300 mean= 15.57ms p50= 15.60ms p90= 16.07ms p99= 16.50ms max= 16.77ms <2ms: 0.0%
timer-1ms n=300 mean= 1.80ms p50= 1.96ms p90= 2.19ms p99= 2.94ms max= 3.50ms <2ms: 65.3%
Linux:
default n=300 mean= 1.12ms p50= 1.12ms p90= 1.16ms p99= 1.22ms max= 1.30ms <2ms:100.0%
Windows 默认的睡眠粒度是 15.6ms,所以你写 1ms,实际拿到 15.6ms;Linux 是 1.1ms。这个差异会直接改写上一节 C 实验的 CPU 占比(19% 对 86%),也会改写任何”超时 1ms”的逻辑。
我还试了显式请求 1ms 定时器精度(timeBeginPeriod)。在同一台机器上,它有时把 p50 降到 1.96ms,有时仍然是 15.5ms。也就是说,连”把尺子调准”这件事本身都不稳定。这不是 API 的 bug,而是提醒:测量环境是一个会变的系统,不是恒定的背景。
结论很朴素:先测尺子,再测系统。至少要记录三件事——时钟分辨率、单次观测成本、观测器自身占用的资源。否则你报告的是”系统 + 尺子”的联合分布,却把它当成了系统。
五、单位错配:三种时间与三个公式
性能讨论里最容易被混用的,是三种时间:
- 墙钟时间(wall):用户感知的时间;
- CPU 时间(user + sys):进程真正占用处理器的时间;
- 等待时间(wall − CPU):阻塞、排队、睡眠的时间。
此外还有两种”看不见的时间”:虚拟化环境里的 steal time(VM 被宿主机抢占),以及容器里的 CPU throttling(配额用完后被强制挂起)。它们都表现为”墙钟变长、CPU 不变”,和 off-CPU 等待长得一模一样。
三个必须记住的公式:
- Little 定律:L = λW。并发数 = 到达率 × 停留时间。10 万 QPS、平均 100ms,就需要 1 万个并发请求在系统里;如果线程池只有 200,排队是必然的。
- CPU 需求:CPU 时间 = QPS × 单次 CPU 时间。1000 QPS、每次 2ms CPU,就是 2 个核满载。
- 容量:ρ = λ / (c × μ),c 是并行度。目标 ρ 不超过 0.7;方差越大,目标越低。
三个常见错误:
- 用 CPU 使用率解释延迟。CPU 45% 只说明”在算的部分不多”,不说明”没有排队”。
- 用平均值算并发。Little 定律里的 W 是平均停留时间,但 SLO 看的是 p99;用平均值算出来的并发,会系统性低估长尾时段的真实占用。
- 用墙钟算 CPU 预算。一个请求墙钟 100ms、CPU 5ms,你按 100ms 买机器,会多买 20 倍。
六、鉴别诊断五步法
把上面的东西收成一套可执行的流程。
第一步:定分母。 慢是相对什么慢?SLO 是 p99 小于 200ms,还是”比昨天慢”?分母不同,结论可能相反。先把比较对象写下来:SLO、基线版本、同类请求、同机对照。
第二步:画分布。 至少要有 p50、p90、p99、p999、max,最好有直方图。先判断是平移、尾部还是双峰。样本量要够:要稳定估计 p99,样本量至少是 1/(1−p) 的百倍量级;1 万样本估 p99 已经勉强,估 p999 需要 10 万以上。
第三步:拆三态。 取同一时间窗口的 CPU 时间与墙钟时间,算 CPU/墙钟比。高于 80% 主要在算;低于 20% 主要在等;中间是混合。再把”等”拆成排队、锁、I/O、下游、定时器。
第四步:归因到共享资源。 单实例的瓶颈通常不是”CPU 总量”,而是某一把锁、某一个连接池、某一个分区、某一个下游。找到那个 μ,算它的 ρ,而不是算整机的 ρ。
第五步:对拍。 一次只改一个变量,看分布的哪一段动了。停掉观测者、把连接池加倍、把采样率降十倍、把流量减半——每次只动一个,记录 p50 和 p99 的变化。如果 p50 不动而 p99 动了,问题在尾部;如果两者同比例动,问题在整体。
判读表:
| 现象 | 最可能的机理 | 下一步 |
|---|---|---|
| p50 和 p99 同比例上升 | 整体资源变慢 | 查 CPU 频率、下游 RTT、网络、磁盘 |
| p50 不动,p99 上升 | 排队、慢路径、重试、GC | 算 ρ;查慢请求的调用链;看重试次数 |
| p99 高但 CPU 低 | off-CPU 等待或排队 | 查锁、连接池、I/O、下游;看等待时间 |
| 均值下降但 p99 上升 | 快路径变快,慢路径变慢 | 分开统计两条路径,不要混在一个指标里 |
| 监控开启后变慢 | 观测者效应 | 算观测预算;降采样;检查 cache line 与日志 |
| 只在高峰出现 | 利用率进入非线性区 | 用 ρ 与 Kingman 估算,提前扩容或限流 |
五条常见误判:
- “CPU 不高,所以不是性能问题”——CPU 只覆盖在算。
- “平均值没变,所以没退化”——均值可以把 2% 的灾难摊平。
- “火焰图没热点,所以没得优化”——热点可能不在 CPU 上。
- “加机器就好了”——如果瓶颈是单分区/单锁,加机器只会让更多请求排队到同一个 μ 上。
- “压测通过了”——压测的 ρ、方差、观测开销,和线上往往不是同一组。
七、主案例:一个”CPU 只有 45%”的 p99 事故
再声明一次:下面是合成案例。参数按 M/M/1 公式与本机实测同量级构造,用于演示归因路径,不是真实事故复盘。
某订单服务,4 个实例,每实例 8 核。请求要经过一段串行化资源:一把全局统计锁 + 一个单连接池。该串行段的处理能力 μ = 500 次/秒。发布前单实例流量 λ = 470/秒。
先算发布前:
- ρ = 470 / 500 = 0.94;
- 平均排队时间 = ρ / (μ(1−ρ)) = 0.94 / (500 × 0.06) = 31ms;
- p99 排队时间 = ln(100 × 0.94) / (500 × 0.06) = 151ms;
- 加上 20ms 的基础处理,p50 约 20ms,均值约 51ms,p99 约 171ms。
发布内容:新增一个 metrics agent,每 100ms 抓取一次统计信息,每次持有同一把锁 4.8ms。它对容量的占用是每秒 48ms,也就是 4.8%。
直觉会说:4.8% 而已,能有多大影响?
实际算一下:
- 串行段有效能力 μ_eff = 500 × (1 − 4.8%) ≈ 476/秒;
- ρ = 470 / 476 = 0.987;
- 平均排队时间 = 0.987 / (476 × 0.013) = 165ms;
- p99 排队时间 = ln(98.7) / (476 × 0.013) ≈ 765ms;
- 加上 20ms 基础处理,p50 仍是 20ms,均值约 185ms,p99 约 785ms。
于是看板上出现了一个非常典型的组合:p50 没变,均值涨了 3.6 倍,p99 从 171ms 涨到 785ms,而整机 CPU 只有 45%。
为什么 CPU 只有 45%?因为瓶颈不是 8 个核,是那一个串行段。其他 7 个核在等它。CPU 使用率是”在算”的度量,不是”在排”的度量。
按五步法走一遍:
- 定分母:SLO 是 p99 < 200ms,发布后 785ms,明确超标。
- 画分布:双峰,p50 20ms,p99 785ms,说明不是整体变慢。
- 拆三态:CPU/墙钟比只有 12%,主要在等;等待集中在串行段。
- 归因:算串行段的 ρ,从 0.94 涨到 0.987;agent 的 4.8% 占用是导火索。
- 对拍:
– 停掉 agent:ρ 回到 0.94,p99 回到 171ms;
– 连接池 1 → 2(μ 翻倍到 1000):ρ = 0.47,p99 排队时间降到约 7ms(总延迟约 27ms);
– agent 采样从 100ms 放宽到 1s:占用降到 0.48%,ρ = 0.945,p99 回到约 185ms,回到基线的同一量级。
复盘的归因大致是:排队贡献 70%,观测者贡献 20%,剩下的 10% 是发布带来的额外抖动。三个数字里,只有 10% 是”代码变慢”,另外 90% 是系统在高利用率下对扰动的放大。
这个案例想说明的不是”agent 很坏”,而是:在 ρ 接近 1 的系统里,任何几个百分点的额外占用都可能被放大成数倍的 p99。 观测者不是站在系统外面看,它站在因果链里面。
八、预防:把性能做成门禁
性能不是”优化出来的”,是”守住出来的”。下面是一套可以直接落地的纪律。
- SLO 只用分位数。 不要写”平均延迟小于 100ms”,要写”p99 小于 200ms,p999 小于 500ms”。平均值可以作为辅助,不能作为承诺。
- 报告必须带分布。 至少 p50/p90/p99/max,最好附直方图。只有均值的数据,无法区分平移、尾部与双峰。
- 样本量要够。 估 p99 至少要有万级样本;估 p999 要有十万级。样本不够时,报告置信区间,而不是一个点。
- 基准测试要轮转。 每个配置跑 5 次,轮转顺序,取中位数;报告最小值与最大值。固定顺序会让 CPU 频率爬升和热漂移污染结论。
- 容量按 ρ 规划,不按均值。 目标 ρ ≤ 0.7;方差大的服务目标更低。扩容前先确认瓶颈是”总量”还是”单分区”。
- 算观测预算。 单次打点成本 × QPS × 打点数;日志按级别采样;高频计数器注意 cache line 隔离。
- 回归门禁用 p99 + 绝对阈值。 例如”p99 相对基线上升 20% 且绝对值超过 200ms,连续 3 次触发”。单次噪声不应该让人加班。
- 记录环境指纹。 操作系统版本、编译器版本、CPU 型号、虚拟化层、定时器精度、电源策略。没有这些,”复现不了”就只是一句废话。
最小检查清单:
- [ ] 这次测量,时钟分辨率是多少?
- [ ] 单次打点成本是多少?每秒打多少次?
- [ ] 观测者占了多少 CPU / 抢了哪些 cache line?
- [ ] 样本量够不够支撑 p99 / p999?
- [ ] CPU/墙钟比是多少?瓶颈在算、在等、还是在排?
- [ ] ρ 是多少?目标是 0.7 还是更低?
- [ ] 方差有多大?重试会不会放大它?
- [ ] 结论能否用一次只改一个变量的对拍复现?
九、边界:分布论什么时候不适用
分布论不是万能的,至少四种情况要小心:
- 单次事件:一次性批处理、冷启动、迁移。没有分布可谈,只有时间线。
- 硬实时系统:关心的是最坏情况执行时间(WCET),不是分位数。p99 再好,只要有一个超时就是失败。
- 分布不可比:不同负载、不同代码路径、不同数据分布的 p99 放在一起比较,是没有意义的。比较之前先确认是同一类请求。
- 观测本身就是业务:审计日志、计费流水、安全事件。这些不能为了性能而采样,只能换更高效的写入路径。
另外,排队模型也有前提:泊松到达、指数服务、单服务台。现实系统往往不满足。但它的价值不在于精确预测,而在于给出方向与量级:利用率接近 1 时,等待时间一定会非线性发散;方差越大,发散越早。这个结论不依赖具体分布。
十、结语:优化不是让代码更快,是让分布更窄
回到开头那三句话。
崩溃在空间上撒谎,因为崩溃点指向的是受害者,不是凶手;卡死在时间上撒谎,因为”不动”是一个读数,不是机理;慢在统计里撒谎,因为均值、中位数、p99 描述的是三个不同的系统,而你往往只问了其中一个。
性能工作的目标,不是把某一个数字压下去,而是让分布变得更窄、更可预测:
- 把 2% 的 151ms 尖刺消掉,比把均值从 6ms 降到 5ms 更有价值;
- 把 ρ 从 0.98 降到 0.7,比换一台更快的机器更有效;
- 把观测开销从”每请求”降到”每千请求”,比多买两个核更便宜;
- 把等待从 600ms 降到 60ms,比把计算从 400ms 降到 350ms 更能改善体验。
最后一句话,留给所有做性能排查的人:
你以为你在测系统,其实你在测”系统 + 你的测法”。先把测法测一遍,再谈系统。
附录 A:分位数判读速查表
| 观察 | 判读 | 第一动作 |
|---|---|---|
| p50 上升,p99 同比例上升 | 整体平移 | 查资源整体变慢:频率、下游、网络、磁盘 |
| p50 稳定,p99 上升 | 尾部问题 | 查排队、慢路径、重试、GC、观测者 |
| p50 上升,p99 稳定 | 快路径变慢 | 查公共前置:鉴权、序列化、连接建立 |
| 均值下降,p99 上升 | 两条路径分化 | 分开统计,别混在一个指标里 |
| p99 高,CPU 低 | off-CPU 或排队 | 查锁、连接池、I/O、下游、队列 |
| 高峰才出现 | 利用率进入非线性区 | 算 ρ;限流、扩容、降方差 |
| 开启监控后出现 | 观测者效应 | 算观测预算;降采样;隔离 cache line |
| 两平台表现不同 | 环境差异 | 查定时器粒度、调度、虚拟化、编译选项 |
附录 B:双平台测量命令对照
| 目的 | Windows | Linux |
|---|---|---|
| 单调时钟 | QueryPerformanceCounter | clock_gettime(CLOCK_MONOTONIC) |
| 进程 CPU 时间 | GetProcessTimes | getrusage(RUSAGE_SELF) |
| 线程 CPU 时间 | GetThreadTimes | clock_gettime(CLOCK_THREAD_CPUTIME_ID) |
| 睡眠 | Sleep | nanosleep |
| 高精度定时器 | CreateWaitableTimerEx(HIGH_RESOLUTION) | timerfd / clock_nanosleep |
| CPU 采样 | ETW + WPA、PerfView、VTune | perf record / perf report |
| 调度与等待 | ETW 等待分析、WPA | perf sched、offcputime |
| 系统调用 | Process Monitor | strace |
| 锁分析 | ETW、Visual Studio 并行堆栈 | perf lock、gdb、TSan |
| 容器配额 | Job Object / 处理器组 | cgroup v2 cpu.max |
附录 C:复现环境与脚本
源码在 scripts/latency/:
bench_common.h 双平台时钟、CPU 时间、睡眠、分位数
hist.c 同一均值、三种分布
queue.c M/M/1 模拟与理论对拍
oncpu.c 在算、在等、混合三种形态
observer.c 观测粒度与打点成本
sleeptest.c 定时器粒度
build_win.bat MSVC 构建(/O2 /std:c11 /utf-8)
build_linux.sh gcc 构建(-O2 -std=c11)
Windows:
cd scripts\latency
build_win.bat
hist.exe & queue.exe & oncpu.exe & observer.exe & sleeptest.exe
Linux:
cd scripts/latency
./build_linux.sh
./hist && ./queue && ./oncpu && ./observer && ./sleeptest
最小测量骨架(与 bench_common.h 等价):
#ifdef _WIN32
static double now_us(void) {
static double freq = 0.0;
if (freq == 0.0) { LARGE_INTEGER f; QueryPerformanceFrequency(&f); freq = (double)f.QuadPart; }
LARGE_INTEGER c; QueryPerformanceCounter(&c);
return (double)c.QuadPart * 1e6 / freq;
}
#else
static double now_us(void) {
struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec * 1e6 + (double)ts.tv_nsec / 1e3;
}
#endif
注意两点:
- Windows 的 QueryPerformanceFrequency 只读一次并缓存,否则每次取时都会多两次 API 调用,测量开销被放大(本文第一版就踩过这个坑)。
- 分位数用排序后线性插值;样本量不足时,p999 的数字只能当趋势看,不能当承诺。
附录 D:环境指纹
Windows: 10.0.26300 (Windows 11)
Compiler: Microsoft (R) C/C++ Optimizing Compiler 19.51.36260 x64
Linux: Ubuntu 24.04.1 LTS, kernel 6.18.33.2-microsoft-standard-WSL2
Compiler: gcc 13.3.0
CPU: 8 vCPU (WSL2)
Timer: Windows default ~15.6ms; Linux ~1.1ms
