接口 410ms,并行之后 145ms,异步首包 28ms

引言

商品详情页,打开要 410ms。产品说"用户划走只要 3 秒,410 毫秒已经吃掉七分之一"。

一个详情页要调 6 个下游:商品基础信息 40ms、库存 60ms、价格 90ms、评价 120ms、推荐 80ms、促销 100ms。串行加起来正好 490ms,实际 410ms——因为有几个调用走的是缓存。

这 6 个调用彼此没有依赖:价格不依赖库存,推荐不依赖评价。"无依赖"就是并行的前提,如果有依赖关系(比如要先拿价格才能算促销),那部分只能串行,能并行的只有后半段。判断一个接口能不能并行,第一件事是画依赖图,不是直接上 CompletableFuture。

改成并行之后,RT 掉到 145ms;再改成异步,首包 28ms。三个数字看着都很美,但后两种方案的代价完全不同:

  • 并行是把"等 6 次"变成"等最慢的那一次",接口语义不变,成本是线程池
  • 异步是让接口先返回、结果后补,RT 从"多久处理完"变成"多久能看到第一屏",成本是状态机

先给结论:串行 410ms、并行 145ms、异步首包 28ms——但并行有线程池上限,异步有状态机成本;能并行的别异步,能缓存的别并行。

一、测试条件:先让数字可复现

环境:Spring Boot 3.2 + JDK 21,4 核 8G 单实例,Tomcat 最大线程 200。

下游用 WireMock 模拟 6 个 HTTP 服务,固定延迟分别是 40 / 60 / 90 / 120 / 80 / 100 ms(P50 = P99)。压测 200 并发、持续 3 分钟,JMeter 开模型,数据全部命中本地缓存与 Redis。

之所以用固定延迟,是为了让三种方案的差异只来自"编排方式",而不是下游抖动。真实环境的绝对数字会更大,但排序不会变。

另外,压测用的并发是 200,而不是"按目标 QPS 反推"。200 并发是闭模型,它会自动降速;真实大促是开模型,涌入速率固定。所以本文的数字适合横向比较三种编排方式,不能直接当成容量结论——容量要按开模型单独压。

二、方案一:串行——RT 就是加法

public DetailVO detail(long skuId) {
    Product p = productClient.get(skuId);        // 40ms
    Stock s = stockClient.get(skuId);            // 60ms
    Price pr = priceClient.get(skuId);           // 90ms
    Review r = reviewClient.get(skuId);          // 120ms
    Recommend rec = recommendClient.get(skuId);  // 80ms
    Promotion promo = promotionClient.get(skuId);// 100ms
    return assemble(p, s, pr, r, rec, promo);
}

实测 P50 = 412ms,P99 = 428ms,吞吐上限 240 QPS(单实例 8G,CPU 并不是瓶颈,瓶颈是每个请求占着一个 Tomcat 线程等 6 次 IO)。

240 QPS 这个数字可以倒推:Tomcat 200 个线程,每个请求占用 0.412 秒,理论吞吐 = 200 ÷ 0.412 ≈ 485 QPS。实测只有一半,因为 200 线程里有一部分被 GC、日志、序列化占着,真正能跑业务的大约 100 个。这就是"RT 越长、线程占用越久"的乘数效应:RT 翻倍,吞吐直接腰斩。

串行的好处是简单、可读、异常处理直观。只要总耗时在业务可接受范围内,串行就是最优解——别为了"显得高级"上并行。

还有一个现实约束:串行的 RT 是"各调用之和",所以任何一个下游变慢,整条链路等比变慢。120ms 的评价服务一旦抖到 300ms,详情页就从 410ms 变成 590ms。并行的抗抖动能力更好——它只看最慢的那一个,其他调用的波动被吸收掉了。

三、方案二:并行——RT 取最长,代价是线程池

3.1 正确写法:自定义线程池 + 超时 + 异常聚合

private static final ThreadPoolExecutor POOL = new ThreadPoolExecutor(
        64, 128, 60, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(256),
        new ThreadFactoryBuilder().setNameFormat("detail-%d").build(),
        new ThreadPoolExecutor.CallerRunsPolicy());

public DetailVO detail(long skuId) {
    CompletableFuture<Product> f1 = supply(POOL, () -> productClient.get(skuId));
    CompletableFuture<Stock> f2 = supply(POOL, () -> stockClient.get(skuId));
    CompletableFuture<Price> f3 = supply(POOL, () -> priceClient.get(skuId));
    // ... 其余三个

    CompletableFuture.allOf(f1, f2, f3, f4, f5, f6)
            .orTimeout(300, TimeUnit.MILLISECONDS)      // 整体超时
            .join();
    return assemble(f1.join(), f2.join(), f3.join(), f4.join(), f5.join(), f6.join());
}

private static <T> CompletableFuture<T> supply(Executor e, Supplier<T> s) {
    return CompletableFuture.supplyAsync(s, e)
            .exceptionally(ex -> null);   // 单个失败降级为 null,不拖垮整体
}

三个细节决定了这段代码能不能上生产:

第一,必须用自己的线程池。 默认的 ForkJoinPool.commonPool() 并行度是 CPU - 1,4 核机器只有 3 个线程;更糟的是它是全 JVM 共享的,一个业务的阻塞 IO 会拖慢所有用 parallelStream 的地方。

第二,allOf 不会抛出异常。 任意一个 future 异常,allOf 返回的 future 依然是"正常完成",只有 join() 里那个 future 才抛。必须逐个子任务做降级,否则一个评价服务超时,整个详情页 500。

降级不是简单返回 null——assemble 方法要能处理 null 并给出默认值(评价显示"暂无评价"、推荐返回空列表)。能降级的字段和不能降级的字段要提前分类:价格、库存返回 null 会让用户下错单,这类必须整体失败;评价、推荐可以降级。并行代码里最容易被忽略的,就是这套"哪些能降、哪些不能降"的约定。

第三,超时要设在"整体"上。 六个调用各自 200ms 超时,整体最长可能 200ms(并行),但如果线程池排队,实际耗时会翻几倍。orTimeout 放在 allOf 上,才能覆盖"排队 + 执行"的总时长。

还有一个容易踩的点:并行任务里的数据库事务是无效的。 事务绑定在发起线程上,supplyAsync 里的 SQL 走的是另一条连接、另一个事务;子任务失败时主事务根本不知道。并行只适合"只读聚合",带写操作的场景必须在主线程串行执行,否则回滚逻辑会完全错乱。

3.2 实测与容量:并行度不是越大越好

线程池大小P50P99吞吐观察
24156ms890ms410 QPS排队严重,P99 抖动大
48148ms218ms780 QPS基本稳定
64145ms186ms900 QPS最优区间
96152ms205ms860 QPS开始有上下文切换损耗
128168ms320ms720 QPS上下文切换增加

最优在 64 左右。算法:并发需求 = QPS × RT,900 QPS × 0.145s ≈ 130 个在途请求,每个请求并行 6 个调用 → 理论上要 780 个线程。显然不可能,所以真实答案是"线程池会反过来限制吞吐"——64 个线程跑满时,吞吐就是 64 / 0.145 ≈ 440 QPS 的并行能力,加上排队,最终稳定在 900 QPS。

并行带来 3 倍提速,但也把"Tomcat 线程数"的瓶颈换成了"业务线程池大小"的瓶颈。 这是必须提前算清的一笔账。

128 线程那档的退化很典型:线程数上去了,但每个下游连接池上限只有 50,多出来的线程全在等连接。并行改造前必须先确认下游的连接池容量,否则线程池再大,也只是让更多线程一起排队。

四、方案三:异步——首包 28ms,代价是状态机

public TaskVO submit(long skuId) {
    String taskId = UUID.randomUUID().toString();
    taskRepo.save(taskId, TaskState.PENDING);          // 落库,防丢
    queue.offer(new DetailTask(taskId, skuId));        // 内存队列,快速返回
    return new TaskVO(taskId, "/detail/result?taskId=" + taskId);
}

接口从 410ms 变成 28ms(落库 + 入队)。前端拿到 taskId 后轮询结果,或者用 SSE 推。

代价清单:

  • 状态机:PENDING → RUNNING → SUCCESS / FAILED / TIMEOUT,每个状态都要有入口和出口
  • 结果存储:结果放 Redis,TTL 30 分钟,超时未取视为放弃
  • 幂等:前端重试提交要返回同一个 taskId,否则一次点击生成三个任务
  • 失败补偿:队列满了怎么办?落库后入队失败,必须有"扫描补偿"把 PENDING 捞起来重投

这条补偿链路最容易漏:save 成功、offer 返回 false,任务就永远停在 PENDING。必须有定时任务扫描超过 5 分钟仍是 PENDING 的记录并重投,重投次数入库存档,超过 3 次转人工。

  • 用户体验:首屏只能先渲染骨架,这不是"变快",是"把等待挪到别处"

异步适合"结果不是立刻需要"的场景:导出、报表、批量对账、消息推送。详情页这种"用户盯着看"的场景用异步,本质是把 410ms 的等待拆成"28ms + 若干次轮询",总耗时反而更长。

轮询本身也有成本:前端每 500ms 问一次,2,400 QPS 的提交量意味着一万多 QPS 的查询请求,这个"查询接口"的压力往往比原接口更大。所以真要做异步,优先用 SSE 或 WebSocket 推,而不是轮询;轮询一定要加退避(500ms → 1s → 2s),避免打爆自己。

五、三方案对比与选型边界

方案P50P99吞吐代码复杂度适用场景
串行412ms428ms240 QPS低调用 ≤2 个,或总耗时 <100ms
缓存 + 串行62ms95ms1,600 QPS低数据可缓存、变更不频繁
并行145ms186ms900 QPS中多个独立 IO 聚合,结果同步返回
异步28ms(首包)45ms2,400 QPS高结果可延后,如导出/报表/通知
混合90ms140ms1,100 QPS中高关键字段同步、非关键字段异步

选型只看一个问题:这个接口的返回值,用户是不是必须立刻拿到?

必须立刻拿到 → 串行或并行(看调用数量和耗时可接受度)。可以延后 → 异步。

实际决策顺序建议按这个来:先问能不能缓存(成本最低、收益最大),再问能不能砍调用(合并接口、字段裁剪),再看能不能并行,最后才考虑异步。 很多人一上来就上并行或异步,结果发现真正的耗时来自"调了三个根本用不上的接口"——砍掉它们,比任何编排优化都有效。

混合方案是最常见的落地形态:商品基础信息、价格、库存同步返回(3 个关键字段并行),评价、推荐、促销异步补齐,前端先渲染主信息、后补次要模块。这比"全异步"体验好,也比"全并行"RT 低。

再补一条边界:能用缓存解决的,不要用并行。 6 个下游里如果 4 个可以本地缓存,串行也能压到 60ms——并行的 3 倍提速,缓存能给你 7 倍,而且不增加任何线程成本。

混合方案的落地顺序也值得说一句:先把"不影响主信息展示"的字段挑出来(评价、推荐、促销默认值),再让前端按"主信息先到、次要模块后补"渲染。这需要前端配合改渲染逻辑,不是后端单方面能完成的改造,所以排期时要把这份依赖算进去。

避坑清单:

  • 别用 commonPool,并行度 = CPU - 1 且全 JVM 共享,一个阻塞调用拖垮全局。
  • allOf 不抛异常,逐个子任务降级,否则一个下游挂掉整页 500。
  • 超时设在整体上,orTimeout 挂在 allOf,覆盖排队 + 执行。
  • ThreadLocal 会丢,用户上下文、traceId 要显式透传(TransmittableThreadLocal)。
  • 并行度按 QPS × RT 算,64 线程撑 900 QPS 是这批下游的结果,换环境要重算。
  • 异步必须落库 + 补偿,内存队列丢了任务没人知道。
  • 异步接口要幂等,同一个业务键重复提交返回同一个 taskId。
  • 并行前先画依赖图,有依赖的那段只能串行,硬并行会拿到不完整的数据。

收尾

串行、并行、异步不是"三代技术",而是三种取舍:串行买简单,并行买线程,异步买复杂度——先问"结果能不能晚点给",再问"能不能缓存",最后才轮到并行。

你们详情页这类接口是串行还是并行?异步方案上线后,前端轮询的体验能接受吗?

关注我,每周拆一个真实生产故障。


标题:接口 410ms,并行之后 145ms,异步首包 28ms
作者:jiangyi
地址:http://jiangyi.space/articles/2026/11/10/1794147444380.html
公众号:服务端技术精选
    评论
    0 评论
avatar

取消