一、先看结果
同一个接口、同样的下游耗时(50ms),只改实现方式,延迟差了一个数量级:
| 指标 | 同步线程池 | 异步 + 批量合并 |
|---|---|---|
| P50 | 1658.6ms | 78.2ms |
| P99 | 3327.8ms | 105.8ms |
| 最大延迟 | 3370.3ms | 112.5ms |
压测条件:到达率 600 rps、持续 6 秒、共 3675 个请求、下游单次调用 50ms。同步模型并发上限 20,异步模型聚合窗口 5ms、单批上限 50。
这不是"异步就一定快"的故事。同步模型在多一层并发的情况下也能撑住 400 rps;它崩掉的原因是容量只有 400 rps,而流量是 600 rps。
测量方式说明:本机 asyncio 模拟,两条实现跑同一组到达时间(泊松,600 rps,6 秒),延迟从"计划到达时刻"算到"结果返回",因此排队等待被完整计入。同步模型用 Semaphore(20) 模拟 20 个线程的并发上限,异步模型用 5ms 窗口 + 单批上限 50。这些数字不是线上压测,但两个模型之间可直接对比。
二、同步为什么崩
先算一笔最简单的账。吞吐上限约等于"并发数 ÷ 单次耗时":
同步:20 ÷ 0.05s = 400 rps
异步批量:50 ÷ 0.05s = 1000 rps
600 rps 打到 400 rps 的容量上,多出来的 200 rps 不会消失,只会排队。队列长度随时间线性增长,延迟也跟着涨------这就是为什么 P50 都到了 1.6 秒:一半的请求在队列里等了超过 1.5 秒。
实测的 P99 3.3 秒,约等于"队列积压到窗口末尾"的时间。同步模型没有"丢弃"或"降级"机制,所有请求一律排队,所以错误率是 0,延迟却难看至极。
用 Little 定律可以估得更准:平均排队数 = 到达率 × 平均等待时间。到达率 600 rps、容量 400 rps,净积压 200 rps,6 秒就是 1200 个请求堆在队列里;队尾的请求要等前面全部处理完,3.3 秒的 P99 就是这么来的。这个公式的好处是:只要容量小于到达率,等多久只是时间问题,与代码写得多漂亮无关。
这类故障最难解释的地方在于:服务没有报错,监控的 QPS 也正常,只有延迟在涨。值班的人看到的是一堆"慢请求",而不是"错误"。
同步模型还有一个隐性成本:队列里的请求都占着连接与线程栈。20 个线程看似不多,但每个线程 1MB 栈、加上连接对象,积压 1200 个请求意味着大量请求在网关侧排队,超时与重试又会把流量放大 1.5 到 2 倍,进一步压低有效容量。
三、异步批量为什么能救
异步本身不增加容量。把线程换成协程,如果每个请求仍然各自调用一次下游,容量还是 400 rps(甚至更低,因为少了对线程的并行利用)。
真正提升容量的是批量合并:把 5ms 窗口内到达的请求攒成一批,一次下游调用处理 50 个,容量就从"1 ÷ 耗时"变成"批量 ÷ 耗时"。
核心代码只有十几行:
python
async def worker():
while True:
t0, fut = await queue.get()
await asyncio.sleep(WINDOW) # 攒批窗口
batch = [(t0, fut)]
while len(batch) < MAX_BATCH:
try:
batch.append(queue.get_nowait())
except asyncio.QueueEmpty:
break
await asyncio.sleep(DOWNSTREAM) # 一次下游调用
now = loop.time()
for a, f in batch:
f.set_result(now - a) # 同批请求一起返回
代价是每个请求至少多等一个窗口(5ms),换来的是容量提升与延迟可控。这笔交易划不划算,取决于下游是否支持批量------如果下游只能单条查询,批量合并就没有意义,得先改下游。
还有一个反直觉的点:异步本身甚至会让"逐条调用"变慢。协程切换有成本,单线程事件循环里每个请求都要排队执行 Python 字节码,600 rps 下事件循环本身就会成为瓶颈。批量合并之所以有效,是因为它把"600 次调用"压成了"12 次批量调用",省掉的是调用次数,而不是切换方式。
四、数据对比
| 模型 | P99 | 相对同步 |
|---|---|---|
| 同步线程池 | 3327.8ms | 100% |
| 异步 + 批量合并 | 105.8ms | 3.2% |
P99 降到 3.2%,P50 从 1658.6ms 到 78.2ms。两个数字要一起看:如果只看 P50,会误以为"异步让每个请求更快",实际是"队列不再堆积"。

图 4 · 数据对比
细看异步批量的 P50:78.2ms,约等于"5ms 窗口 + 50ms 下游 + 排队"。这个延迟的地板由下游耗时决定,压不到 50ms 以下。如果业务要求 P99 在 20ms 内,批量合并帮不上忙,得从下游本身想办法。
还有两个容易被忽略的收益:
- 队列稳定:异步批量的队列长度基本恒定(窗口内到达数),不会随时间爆炸;
- 过载可预测:超过容量后,批量模型会先增加批大小、后增加延迟,而不是无限排队。
五、改造要点
- 先确认下游能不能批量。 数据库的
IN (...)、缓存的MGET、RPC 的 batch 接口都行;只能单条调用的下游,先改下游再谈合并。 - 窗口与批量上限要一起定。 窗口太小攒不到批,窗口太大增加无谓延迟;经验起点是"P50 下游耗时的 10%",本例 50ms 对应 5ms。
- 保留同步路径兜底。 批量服务不可用时能退回逐条调用,避免整条链路一起挂。
- 按批次超时,不按请求超时。 一批里任何一条超时都应该让整批快速失败,否则排队会传染给下一批。
- 监控批大小分布。 平均批大小突然掉到 1,说明窗口或流量变了,容量会瞬间退回同步水平。
第五条是最隐蔽的回归:某次流量下降导致批大小变成 1,容量悄悄从 1000 rps 退回 400 rps,直到下一次峰值才爆发。
再补一条工程细节:批量接口的返回必须能对上请求。用索引数组或请求 ID 都可以,但不要依赖"返回顺序一定与请求顺序一致"------多数批量 API 不保证这一点,一旦错位,数据就串了。
六、实施五步
- 量化现状。 拿到当前 P50/P99、下游耗时、并发上限,算出容量,和峰值流量对比。
- 确认批量能力。 下游接口是否支持批、单批上限多少、是否有序返回。
- 改造请求路径。 引入队列与聚合窗口,先只对读接口灰度,写接口暂不动。
- 压测对比。 用同一到达率、同一持续时间跑新旧两条路径,比较 P50/P99 与队列长度。
- 加回归监控。 批大小、队列长度、下游超时率三个指标一起看,任一异常就回滚。
第四步必须用同一组参数。到达率一改,两组数据就不可比,很容易得出"改造无效"的误判。

图 5 · 执行流程
七、这个方案不适用的三种情况
- 下游不支持批量。 只能逐条查询的接口,先改下游;在下游没准备好的时候硬做聚合,只会得到"每批 1 条"的假批量。
- 请求之间不能混合。 比如权限差异极大、连接不同数据库分片、或者同一用户有顺序要求,合并会带来串数据或乱序的风险。
- 延迟极度敏感。 批量合并的最小延迟是"窗口 + 下游耗时",窗口 5ms 就意味着 P50 至少多 5ms;对 10ms 级 SLA 的接口,这点代价也不能接受。
这三种情况之外,剩余场景大多能从批量合并里拿到收益。判断方法还是那个:先算容量,再看下游有没有 batch 能力。
九、一个对照观察
同样的代码,把到达率从 600 rps 降到 300 rps 再跑一遍同步模型,P99 会回到 200ms 以内------同步模型不是"慢",是"容量不够时慢"。这也解释了很多线上争论:同一段代码,有人说不慢、有人说慢到不可用,差别往往只在流量。
所以优化之前先确认峰值到达率,别拿低谷时的体感来判断容量。

图 3 · 要点速览
十、收尾
这次改造没有用任何高深技术:一个队列、一个窗口、一次批量调用。真正难的判断是"容量够不够"------同步模型的 400 rps 在峰值 600 rps 面前注定要排队,换什么写法都一样。
所以优化的顺序应该是:先算容量,再看实现。用一句话概括这次的改动:把"每个请求等 50ms"换成"每批请求等 50ms",容量随批大小线性放大。容量不够时,异步与批量解决的是"能不能一次多干点";容量够时,改它只会增加复杂度。
参考资料:

图 1 · 全文章节导览