慢不是一个数,是一个分布:性能问题的鉴别诊断学

作者:

在

调试系列写到这里,已经有三句话:

崩溃在空间上撒谎,卡死在时间上撒谎,慢在统计里撒谎。

第一句讲的是堆腐烂:崩溃点不是案发第一现场;第二句讲的是卡死:不动是一个读数,不是机理;这一篇补第三句——慢不是一个数,是一个分布。三句话合起来,说的是同一件事:你把观测到的现象当成系统的属性,就把诊断做成了猜谜。

先说清楚这篇的边界。下面的所有输出都是本机实录,没有修饰,也没有挑选”好看的那次”:

  • 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”这个说法把它们都掩盖了。

所以第一个判据不是”快不快”,而是分布是什么形状。工程上常见的三种形状:

  1. 平移:整条分布往右移,p50 和 p99 同比例变差。通常是资源整体变慢(CPU 降频、下游整体变慢、网络 RTT 增加)。
  2. 尾部:p50 不动,p99 变差。通常出现了慢路径、排队、重试、GC、缓存击穿,或者观测者本身。
  3. 双峰:分布中间出现凹陷,或者 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.501.0平均排队时间等于一次服务时间
0.702.3排队时间是服务时间的 2.3 倍
0.909.09 倍
0.9519.019 倍
0.9849.049 倍

这就是”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 当成”代码慢”的同义词,是所有性能误判里最常见的一个。

四、观测:你测到的不是原来的系统

现在把尺子本身放到台面上。

观测至少有三种效应:

  1. 打点成本:每一次读时钟、写日志、加计数,都要花时间;
  2. 采样偏差:采样频率决定了你能看见什么,也决定了你看不见什么;
  3. 观测者占资源:观测线程占 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 等待长得一模一样。

三个必须记住的公式:

  1. Little 定律:L = λW。并发数 = 到达率 × 停留时间。10 万 QPS、平均 100ms,就需要 1 万个并发请求在系统里;如果线程池只有 200,排队是必然的。
  2. CPU 需求:CPU 时间 = QPS × 单次 CPU 时间。1000 QPS、每次 2ms CPU,就是 2 个核满载。
  3. 容量:ρ = λ / (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 估算,提前扩容或限流

五条常见误判:

  1. “CPU 不高,所以不是性能问题”——CPU 只覆盖在算。
  2. “平均值没变,所以没退化”——均值可以把 2% 的灾难摊平。
  3. “火焰图没热点,所以没得优化”——热点可能不在 CPU 上。
  4. “加机器就好了”——如果瓶颈是单分区/单锁,加机器只会让更多请求排队到同一个 μ 上。
  5. “压测通过了”——压测的 ρ、方差、观测开销,和线上往往不是同一组。

七、主案例:一个”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 使用率是”在算”的度量,不是”在排”的度量。

按五步法走一遍:

  1. 定分母:SLO 是 p99 < 200ms,发布后 785ms,明确超标。
  2. 画分布:双峰,p50 20ms,p99 785ms,说明不是整体变慢。
  3. 拆三态:CPU/墙钟比只有 12%,主要在等;等待集中在串行段。
  4. 归因:算串行段的 ρ,从 0.94 涨到 0.987;agent 的 4.8% 占用是导火索。
  5. 对拍:

    – 停掉 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。 观测者不是站在系统外面看,它站在因果链里面。

八、预防:把性能做成门禁

性能不是”优化出来的”,是”守住出来的”。下面是一套可以直接落地的纪律。

  1. SLO 只用分位数。 不要写”平均延迟小于 100ms”,要写”p99 小于 200ms,p999 小于 500ms”。平均值可以作为辅助,不能作为承诺。
  2. 报告必须带分布。 至少 p50/p90/p99/max,最好附直方图。只有均值的数据,无法区分平移、尾部与双峰。
  3. 样本量要够。 估 p99 至少要有万级样本;估 p999 要有十万级。样本不够时,报告置信区间,而不是一个点。
  4. 基准测试要轮转。 每个配置跑 5 次,轮转顺序,取中位数;报告最小值与最大值。固定顺序会让 CPU 频率爬升和热漂移污染结论。
  5. 容量按 ρ 规划,不按均值。 目标 ρ ≤ 0.7;方差大的服务目标更低。扩容前先确认瓶颈是”总量”还是”单分区”。
  6. 算观测预算。 单次打点成本 × QPS × 打点数;日志按级别采样;高频计数器注意 cache line 隔离。
  7. 回归门禁用 p99 + 绝对阈值。 例如”p99 相对基线上升 20% 且绝对值超过 200ms,连续 3 次触发”。单次噪声不应该让人加班。
  8. 记录环境指纹。 操作系统版本、编译器版本、CPU 型号、虚拟化层、定时器精度、电源策略。没有这些,”复现不了”就只是一句废话。

最小检查清单:

  • [ ] 这次测量,时钟分辨率是多少?
  • [ ] 单次打点成本是多少?每秒打多少次?
  • [ ] 观测者占了多少 CPU / 抢了哪些 cache line?
  • [ ] 样本量够不够支撑 p99 / p999?
  • [ ] CPU/墙钟比是多少?瓶颈在算、在等、还是在排?
  • [ ] ρ 是多少?目标是 0.7 还是更低?
  • [ ] 方差有多大?重试会不会放大它?
  • [ ] 结论能否用一次只改一个变量的对拍复现?

九、边界:分布论什么时候不适用

分布论不是万能的,至少四种情况要小心:

  1. 单次事件:一次性批处理、冷启动、迁移。没有分布可谈,只有时间线。
  2. 硬实时系统:关心的是最坏情况执行时间(WCET),不是分位数。p99 再好,只要有一个超时就是失败。
  3. 分布不可比:不同负载、不同代码路径、不同数据分布的 p99 放在一起比较,是没有意义的。比较之前先确认是同一类请求。
  4. 观测本身就是业务:审计日志、计费流水、安全事件。这些不能为了性能而采样,只能换更高效的写入路径。

另外,排队模型也有前提:泊松到达、指数服务、单服务台。现实系统往往不满足。但它的价值不在于精确预测,而在于给出方向与量级:利用率接近 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:双平台测量命令对照

目的WindowsLinux
单调时钟QueryPerformanceCounterclock_gettime(CLOCK_MONOTONIC)
进程 CPU 时间GetProcessTimesgetrusage(RUSAGE_SELF)
线程 CPU 时间GetThreadTimesclock_gettime(CLOCK_THREAD_CPUTIME_ID)
睡眠Sleepnanosleep
高精度定时器CreateWaitableTimerEx(HIGH_RESOLUTION)timerfd / clock_nanosleep
CPU 采样ETW + WPA、PerfView、VTuneperf record / perf report
调度与等待ETW 等待分析、WPAperf sched、offcputime
系统调用Process Monitorstrace
锁分析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

注意两点:

  1. Windows 的 QueryPerformanceFrequency 只读一次并缓存,否则每次取时都会多两次 API 调用,测量开销被放大(本文第一版就踩过这个坑)。
  2. 分位数用排序后线性插值;样本量不足时,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

相关文章