分布式系统P99延迟优化实战：从线程池到分片路由的架构复盘

站在监控大屏前看到那条 P99 曲线的时候，我第一反应是系统被流量冲垮了。可鼠标滑到 QPS 图上，峰值反而比上个月活动低了将近三分之一。这个反差让我冷静下来——分布式系统出了问题，我们总习惯先用“负载太高”来解释，但真正值得警惕的，往往是流量没有那么高、延迟却悄悄恶化的情况。

今天这篇内容，是最近一次分布式系统架构优化的完整复盘。场景是常见的在线交易链路，涉及订单、商品、库存、用户权益等多个服务，部署形态是几十个容器组成的微服务集群，中间件包括 Redis、消息队列和分库分表数据库。文章没有打算堆砌 Service Mesh、单元化、Serverless 这类词，而是按真实排查顺序展开：先讲报警现象和定位过程，再拆读链路、写链路、数据路由三层优化，最后聊灰度验证和复盘经验。所谓前沿架构优化，我的理解不是把流行技术名词全部用上，而是找到系统当前最不舒服的地方，用合适的架构手段解开它。这篇内容适合正在做分布式系统性能治理、想搞清瓶颈到底藏在哪里的读者。

1. 报警很怪：QPS 没涨，P99 却从 80ms 涨到 800ms

1.1 系统背景与业务链路

这套系统是典型的在线交易平台，用户从浏览商品到下单支付，会经过网关、订单服务、商品服务、库存服务和用户权益服务。为了控制篇幅，我先把主链路简化成一张图：客户端请求到网关后，订单服务负责校验和落单，过程中需要调用商品服务拿到最新的价格和活动信息，调用库存服务做预占扣减，下单成功后再触发优惠券、积分和消息通知。数据层用 MySQL 分库分表承载核心订单数据，Redis 缓存热数据，MQ 异步解耦非关键流程。

系统峰值 QPS 大概在每秒万级，这个体量放在互联网行业并不算夸张，但它把分布式系统的共性难点全占齐了：多服务依赖、跨网络调用、缓存一致性、分片后的查询路由、消息重复消费等等。以前性能平稳的时候，我们觉得架构还行，最多偶尔调一调慢 SQL。直到某天晚上收到告警，才意识到平静只是表象。

1.2 第一轮排查为什么扑空

告警显示下单接口的 P99 从平时的 80ms 逐步爬到了 800ms，平均 RT 却只有 150ms 左右。这个数据对比很关键：平均 RT 不高，说明大多数请求是正常的，只有一小部分请求被拖住了。如果此时只盯着平均值，很容易误判成“偶尔抖动，不用处理”。

我们第一轮排障做了常规动作：看 CPU、内存、磁盘 IO、网络包量，全部处于可接受区间；订单服务 CPU 平均只有 35%，数据库连接数也没打满；把单个服务实例拿出来单独压测，P99 只有 120ms。单机没问题，集群有问题，这个矛盾本身就说明问题出在分布式协作层面，而不是某台机器的处理能力。

后来我把监控粒度从分钟级切到秒级，才发现流量并不是均匀分布的。有少量节点 CPU 超过 80%，另外一些节点只有 20% 左右。拉出容器平台的数据后看到，CPU steal 在部分宿主机上达到 12%～18%，也就是说容器在等待宿主机调度时被其他负载挤占了 CPU。这些被打断的请求在进程启动阶段就多花了几十毫秒，再往后叠加 RPC 等待时，直接进入长尾区间。

1.3 平均指标会掩盖真相

这次报警给我最大的教训是：查看分布式系统健康度，不能只看平均 RT。平均 RT 从 80ms 涨到 150ms，看起来只有不到一倍的变化，但 P99 已经翻了十倍。说明只需要 1% 的请求被某个局部问题拖慢，用户体验就会明显变差，而监控图上平均值那条线依然平得像没出事一样。

从那时起，我们把核心接口的告警阈值从“平均 RT 超过 XXX”改成了“P99 超过 XXX”，并且额外加了“最高 RT 超过 XXX”的兜底项。每次排障先从 trace 数据里找慢请求的特征分布，而不是先猜哪个中间件挂了。这个习惯在后面几轮优化里帮了大忙。

2. 全链路追踪铺开后，最扎眼的不是慢方法，而是线程排队和重试放大

2.1 动态采样策略

以前我们不是没接链路追踪，只是采样率固定 10%，慢请求经常被采样规则漏掉。高峰期全量采样又不现实，探针本身的序列化和上报会占用额外 CPU，可能让系统更慢。折中之后，我们把采样策略改成三个维度：正常流量固定 10% 采样，错误请求和耗时超过 200ms 的请求强制 100% 采样，同时在日志里透传 traceId，方便把日志、链路和监控串联起来。

开启这个策略后的第一个小时，数据量涨了不少，但我们很快就从一个明显特征里锁定了方向。大量慢请求并不是分散在各处的，而是集中在订单服务调用库存服务的那一段 RPC 上。

2.2 库存服务自己只要 80ms，调用方却等了 470ms

单独看库存服务的监控，P99 只有 90ms，但订单服务视角下，库存预占这个子 Span 的耗时经常超过 470ms。点开 Trace 的瀑布图才看清楚，库存服务真正处理业务逻辑的时间只有 80ms，剩余时间几乎全部消耗在等线程池里的排队位置。

原因并不复杂。库存服务的 provider 线程池固定 100 个线程，但它承接的不只是下单预占，还包括后台库存查询、营销展示查询、退货入库等场景。下单高峰时，大量营销查询请求把线程池占住，真正关键的下单扣减请求只能在外面排队。更麻烦的是，订单服务侧设置的 RPC 超时是 1000ms，一旦等待时间超过这个阈值，客户端就会自动重试。第一次请求没处理完，第二次重试又进来了，下游线程池压力不减反增，形成了恶性循环。

这种情况不是单纯扩容能解决的。把线程池从 100 调到 200，只会让更多请求同时在内存里排队，线程上下文切换带来的开销反而让 CPU 先被打满。正确的做法是隔离和快速失败。

2.3 线程池隔离、超时收敛、重试退避

我们当时做了三类改动。

第一，按业务场景拆分线程池。库存预占、库存扣减这类核心交易操作走独立的核心池，线程数不必很大但要保证不被其他流量挤占；营销活动查询、后台报表查询走低优先级线程池，并发超高时允许丢弃并返回提示。第二，把核心交易调用的超时时间从 1000ms 调整到 400ms，这样即使下游真的变慢，上游也不会傻等太久。第三，重试策略从“立即重试一次”改成“最多重试一次，且退避 200ms”。

为什么超时时间不建议调得太短？因为像库存预占这种操作，偶尔确实会因为数据库锁等待或网络抖动超过 200ms，太激进的超时会导致大量本可以成功的请求被误判为失败。400ms 是在看了基线数据后定下来的：正常情况下 80ms 内完成，400ms 已经给了五倍缓冲。

仅这一轮改造，下单链路 P99 就从 800ms 降到了 380ms 左右。这个结果让我意识到，分布式系统里很多延迟不是被“慢服务”吃掉的，而是被“等待”和“重试”放大的。

3. 读链路第一刀：热点 Key 和缓存击穿，单分片 CPU 被打满

3.1 缓存命中率 90%，Redis 某个分片却快扛不住了

线程池问题解决后，P99 依然在 200ms 上下波动，没有回到健康水平。继续看 Trace 数据，发现订单服务里 Redis 读取的耗时在部分请求中异常高。当时的缓存命中率大概是 90%，看起来不错，但 Redis Cluster 的监控面板显示，某个分片的 CPU 已经接近 100%。

典型的热点 Key 问题。活动页上某个爆款商品的价格和可售库存被大量用户同时读取，短时间内上万次读写全部落到同一个 Key 上。Redis Cluster 对 Key 做哈希后路由到固定分片，单 Key 的吞吐上限就是单个分片的处理能力，加再多的分片也救不了它。

比缓存穿透更隐蔽的是，大量线程都卡在 Redis GET 命令上等待网络和 CPU 响应，服务线程池被这些长耗时请求占住，接口整体 RT 被抬高。我们通过 Redis 的 slowlog 和业务 Trace 里的 Redis Span 耗时统计，确认了热点集中在几个营销商品 Key 上。

3.2 本地缓存 + singleflight，先把热点流量挡在 JVM 内

对这类超高频率的读请求，合理的做法是在进程内加一层本地缓存。我们用 Caffeine 给热点商品单独建了一个短 TTL 缓存，代码上比全量缓存简单很多：

java复制Cache<String, ProductSnapshot> hotProductCache = Caffeine.newBuilder()
        .maximumSize(10000)
        .expireAfterWrite(5, TimeUnit.SECONDS)
        .build();

ProductSnapshot snapshot = hotProductCache.get(cacheKey, key -> {
    // 回源 Redis 或 DB 加载商品快照
    return loadProductSnapshot(key);
});

注意 expireAfterWrite 设成 5 秒，是刻意接受的“短暂不一致”。商品详情页展示的可售库存允许最多 5 秒误差，用户下单时会走到库存服务和数据库做最终强校验。真实库存扣减不能依赖缓存，必须走数据库的乐观锁更新，比如执行类似“update stock set stock = stock - #{num} where product_id = #{pid} and stock >= #{num}”的语句保证不超卖。

小知识：Caffeine 的 get(key, mappingFunction) 对同一个 Key 的并发调用，只允许一个线程执行加载逻辑，其余线程会等待同一个结果。这就天然解决了缓存击穿问题，不会出现缓存过期那一瞬间所有请求一起回源数据库的情况。

3.3 缓存更新不能只依赖“删缓存”

后台修改商品价格后，我们需要让本地缓存和 Redis 尽快失效。很多团队的做法是更新数据库后直接删除 Redis Key，这个方案有一个经典风险：如果删除操作因为网络抖动失败，旧数据就会在缓存里残留很久。

我们后来采用版本号配合 MQ 广播的方式。商品表每次变更会把 version 字段加一，后台服务将变更事件写入 MQ，订单服务里的本地缓存消费者收到事件后，对比当前内存里的 version，小于新版本就主动淘汰对应 Key。由于消费端进程都订阅同一个 Topic，即使某个进程重启错过消息，也会因为本地缓存 TTL 5 秒到期而自动回源，不会造成长时间脏读。

看到这里你可能会问，为什么不直接用 Redis Pub/Sub 广播失效消息？原因是进程重启期间订阅关系会丢失，并且 Pub/Sub 没有持久化，消息一旦发出没人消费就永远找不回来。MQ 虽然会带来几秒延迟，但配合短 TTL 已经能把不一致窗口控制在可接受范围内。

4. 写链路第二刀：把非关键步骤从同步链路里摘出去

4.1 同步调用链像多米诺骨牌

下单业务原来是一条很长的同步链：订单服务先落订单，再同步调用商品服务、库存服务、用户权益服务，最后调消息中心发通知。每个服务在低峰期可能只要 20ms～30ms，高峰期则可能到 100ms～300ms，串行叠加之后 P99 很容易突破 500ms。

更糟糕的是，一旦用户权益服务抖动，异常会向上传播，订单服务直接抛错并回滚本地订单。我们统计过一段时间的数据，发现有不少订单其实在主流程上没有任何问题，只是因为积分发放这种非关键动作失败，整笔下单被中断了。这非常不合理。

分布式系统拆分服务时，最容易被忽略的一件事就是定义清楚“用户可见的成功”到底依赖哪些动作。对下单来说，用户关心的核心结果是订单创建成功、价格和库存状态可确认。发券、加积分、发通知这些动作应该在订单成功后再慢慢完成，不应该反过来影响下单结果。

4.2 本地消息表和幂等消费

异步化的技术方案有很多，我们最终选择了“本地消息表 + MQ”的组合。核心逻辑是：在订单库里建一张事件表，订单创建这个本地事务里同时写入一条“订单创建成功”的事件记录，事务提交后，后台任务把事件发给 MQ，由下游消费者去执行发券、积分等动作。

为什么不用先发 MQ 再写订单的方式？因为这两个操作不在同一个事务里，订单写库失败但消息已经发出去，会造成下游凭空处理一笔不存在的订单。为什么不用先写订单再发 MQ？因为消息发送可能失败，订单库提交了但事件没发出去，下游永远感知不到新订单。本地消息表的好处是，订单状态和事件状态在同一个数据库事务里保持一致，后台任务可以扫描并补发还没有投递成功的事件，逻辑非常直白。

消费端必须做幂等。我们用 order_id 加 scene_type 拼成消息处理的唯一业务键，在积分流水表和券实例表里建唯一索引，重复消息投递过来时，要么插入冲突后直接跳过，要么先查重再执行。

4.3 哪些写操作不适合异步化

异步化不是万能的，库存扣减我们就保留了同步调用。原因很简单：用户下单后需要立刻知道“库存是否扣减成功”，如果把库存预占改成异步，用户看到下单成功，但异步任务执行时发现库存已经不足，就会产生大量无法履约的订单。因此库存预占和订单落库是核心强一致动作，即便再慢也必须同步完成。

我们真正异步掉的，是积分、优惠券、消息通知、审计日志这些可以容忍分钟级延迟的动作。压测结果对比很明显：下单核心链路从依赖五个下游调用缩减到两个，P99 从 260ms 降到了 118ms，订单服务线程池的活跃线程峰值也从 198 降到 142。

不过异步化也带来了新问题。消费者故障或消息积压时，用户订单已经成功但优惠券迟迟不到账，客诉会集中爆发。我们为此加了两道保险：一是 MQ 积压告警，积压数量超过阈值就通知值班人员；二是定时对账任务，每 5 分钟扫一次未完成事件，把超过阈值的消息重新投递。

5. 第三刀：分片键重选与路由演进，这是一次要持续推进的改造

5.1 用 user_id 分片，导致数据偏斜和广播查询

订单库原来的拆分方式是 user_id % 128 分片，早期设计时考虑的是“用户查看我的订单”这个高频查询，同一个用户的数据天然落在一个分片上，查起来很舒服。但随着业务发展，后台运营和商家需要按商家维度查看订单列表，按 user_id 取模根本无法路由，只能把请求广播到全部 128 个分片，再将结果合并。这种广播查询对数据库连接数和 CPU 消耗极大，每次触发都会带来明显的延迟尖刺。

另一个问题是数据倾斜。某个头部商家的订单量非常大，但这个商家绑定的 user_id 只有一个，按照取模规则，它永远只落在某一个分片上。于是那一个分片的磁盘空间和写入负载明显高出其他分片好几倍，形成了一个无解的“热分片”。

这件事给我的启发是：分片键没有绝对的好坏，关键在于是否跟随业务最重要的访问模式。当业务出现全新的查询维度时，说明当初的分片设计已经需要升级了。

5.2 索引表 + 双写 + 校验，逐步迁移而不是原地重构

改动分片键最怕的就是直接把现有表重新哈希，风险和成本都太高。我们采用的方案是引入订单索引表，记录 user_id、merchant_id、order_id 到实际物理分片位置的映射关系。

新写入的订单，仍然按规则落到某个主分片，但会同步往索引服务里写入一条映射记录。用户查询订单时，先根据 user_id 从索引服务拿分片路由，再去对应分片取数据；商家查询订单时，先根据 merchant_id 拿映射结果，避免广播查询。

历史数据的迁移用了双写加校验策略：先开启双写，让新旧两套存储都有数据；再用一个回放任务按用户范围分批扫描旧库，把历史订单补写到新索引体系里；整个过程用 binlog 监听增量同步，两端数据校验通过后，才把流量从旧路由切到新路由。

这里有一个不想让你踩的坑：不要先切流量再补数据。我们见过不少团队把顺序反过来，结果新旧分片数据不一致，用户发现订单在“我的列表”里失踪了，对账又要花很长时间。最好是数据校验工具每天跑，连续几天确认差异为零，再开始灰度切换。

5.3 分片调整后，别急着引分布式事务

订单、库存、资金这些数据分布在不同的分片和不同的服务里，跨分片操作已经不能依赖数据库本地事务。这个阶段很多团队会直接引入分布式事务框架，我们权衡之后没有这么做，原因是大多数互联网业务场景真正需要的不是强一致，而是“最终一致 + 对账兜底”。

下单主流程用本地消息表保证事件不丢，库存扣减用数据库乐观锁保证不超卖，跨服务数据差异靠定时对账任务发现并修复。这套组合避免了分布式事务锁带来的性能和稳定性损耗，也保证了出现问题时能及时发现。

如果你也在纠结要不要引入强一致的分布式事务，可以先问自己一个问题：当数据出现不一致时，你的对账机制能不能在几分钟内发现并修复？如果不能，引入重事务框架只是把出错时间延后，并没有消除风险。反之，如果对账通道很完善，弱一致性方案往往会比分布式事务更顺手。

6. 灰度验证与复盘：哪些改动真正有效，哪些地方差点翻车

6.1 灰度放量过程与实测对比

所有优化没有一次性全量上线，我们按内部流量验证、1% 用户、5% 用户、20% 用户、全量这样的顺序逐步放量。每一步都看三件事：P99 是否回落、错误率是否有上升、缓存命中率和 MQ 积压量是否在合理范围。

这些数字只代表我们这套系统的变化趋势，不建议直接拿去做其他项目的基准，毕竟业务模型、数据规模和依赖复杂度都不一样。但有一点是通用的：每一轮改动都要能独立验证效果，如果多个改动混在一起上线，出了问题你根本不知道是哪一步引入的。

6.2 压测和演练中容易被忽略的场景

第一类容易漏掉的是热点数据压测。很多压测工具生成的数据分布非常均匀，热 Key 问题在压测环境里根本不会被触发。我们后来专门写了一个小工具，模拟少量商品 Key 集中访问，把流量倾斜到这个维度后再看 Redis 分片和服务线程池的表现。只有在这种场景下通过测试，上线后才不会被打个措手不及。

第二类是 fallback 逻辑的压测。熔断器触发时，系统会走 fallback 返回降级结果。我们曾经在一个值班群里看到过非常经典的翻车现场：某个服务熔断后，fallback 里又发起了一次远程调用去拿兜底数据，结果下游已经故障，这次调用又超时，最终用户的等待时间比直接调用还长。降级逻辑必须是纯本地动作，最好连数据库都别查，直接返回预设的默认值或提示文案，才能真正兜底。

6.3