I/O 密集型高并发实战:Java 服务 10 维优化,从线程打满到 10 万 QPS

I/O 密集型高并发实战:Java 服务 10 维优化,从线程打满到 10 万 QPS

适用场景:以 RPC、数据库、缓存、MQ 等待为主的 Java/Spring Boot 服务。

版本基线:Spring Boot 3.x + Java 21(虚拟线程相关特性会标注版本差异)。

一句话结论:I/O 密集型系统的瓶颈不是 CPU,而是等待。高并发的本质,是管理等待。


0. 一个熟悉的故障现场

周一 09:12,订单查询服务的监控大屏红了:

  • CPU 使用率:32%
  • Tomcat 线程:200 / 200
  • P99:8.4s(平时 180ms)
  • HikariCP pending:47
  • Redis 超时率:12%
  • 网关 5xx:8.7%

值班同学的第一反应是扩容。机器从 12 台加到 24 台,CPU 降到 21%,但 P99 仍然在 6s 以上,Hikari pending 甚至更高了。

为什么?

因为线程不是被 CPU 占满的,是被等待占满的。数据库慢查询、缓存热 Key、下游 RPC 超时,把 Tomcat 线程一个个"挂"在那里;线程池满了,新请求排队;网关超时后重试,流量再翻倍;数据库连接池被占满,更多线程等连接......最后形成一条自我强化的故障链。

说明:以上是一个由多种真实故障模式拼合的典型场景,用于建立问题模型,不代表某一家的线上数据。文中的容量数字,除非特别标注,都是假设推演 或验收目标。


1. 反直觉:CPU 不高,不代表系统有余量

1.1 三个被混淆的指标

指标 含义 为什么容易误判
CPU 使用率 CPU 执行指令的时间占比 I/O 等待不消耗 CPU,CPU 低可能是"全员在等"
线程数 正在处理请求的平台线程 线程是"等待的容器",不是免费的
吞吐量 单位时间完成的请求数 受 Little's Law 约束,不由 CPU 单独决定

在 I/O 密集型服务里,一个请求的生命周期大致是:

text 复制代码
CPU 计算 5ms → 等缓存 2ms → 等 DB 30ms → 等下游 RPC 80ms → 序列化 5ms → 返回

CPU 只占 10ms,剩下 117ms 都在等。此时你看到的 CPU 使用率当然不高,但每个请求都要占着一个线程(或一个异步上下文)等 127ms。

1.2 Little's Law:高并发的第一性原理

text 复制代码
L = λ × W
  • L:系统内平均并发请求数(in-flight)
  • λ:平均吞吐量(QPS)
  • W:平均响应时间(秒)

变形一下:

text 复制代码
吞吐上限 λ = 并发度 L / 平均响应时间 W

举例:某实例平均 RT 为 80ms,Tomcat 最大 200 个请求线程。即使所有线程一直满负荷:

text 复制代码
λ_max ≈ 200 / 0.08 = 2,500 QPS

这还是没有算排队、GC、上下文切换的理论上限。实际能稳定跑到的,通常只有 60%~75%,也就是 1,500~1,900 QPS。如果 P99 是 300ms,峰值时在途请求会更多,200 个线程很快就不够用。

结论:

  • 想提高吞吐,要么降低 W (缓存、索引、减少远程调用、优化序列化),要么提高有效 L (虚拟线程、异步、扩容),要么限制 λ(限流、降级)。
  • 单纯"加线程"只是把排队从线程池挪到数据库连接池,最终把下游打挂。

图为公式推演,不是线上实测。横轴为并发度,纵轴为理论吞吐;RT 越低,同样并发能承载的吞吐越高。

1.3 排队论:70% 利用率是条危险线

把服务粗略看成一个排队系统:

text 复制代码
ρ = λ / (c × μ)
  • ρ:资源利用率
  • c:并行服务能力(线程/连接/分区数)
  • μ:单个资源的服务速率

排队论的一个经典结论是:当利用率逼近 100%,排队时间不是线性增长,而是指数级上升 。现实中还要叠加 GC、锁竞争、网络抖动,所以生产系统通常把目标利用率控制在 60%~70%,给突发流量留余量。

图为 M/M/c 排队模型示意(c=8,平均服务时间 50ms),用于说明"拐点"而非承诺具体延迟。真实系统必须用自己的压测数据校准。

1.4 重试放大:一层 3 次,三层就是 27 次

很多故障不是第一波流量打挂的,而是重试打挂的。

如果网关、服务、RPC 客户端各重试 2 次(总共 3 次尝试),最坏情况下一个用户请求会变成:

text 复制代码
3 × 3 × 3 = 27 次下游调用

公式:

text 复制代码
总尝试次数 = ∏(1 + retry_i)

图:每层最多 3 次尝试时,三层重试最坏会把一个请求放大成 27 次下游调用。

生产原则:

  • 只在一个层次重试,通常在客户端或网关;
  • 只重试幂等请求;
  • 使用指数退避 + 随机抖动;
  • 设置重试预算(例如正常流量的 10%),预算耗尽就快速失败;
  • 超时预算不足时,禁止重试。

1.5 超时预算:不要让每一层都"等 30 秒"

一个 1s SLO 的请求,不能每一层都配 30s 超时。超时应该是一条预算,从入口开始逐层扣减。

环节 预算 说明
客户端网络 + 排队 50ms 含 DNS、TLS、LB
网关 30ms 鉴权、路由、限流
服务排队 50ms 线程池/信号量等待
本地缓存 5ms Caffeine
Redis 20ms 含网络
DB 150ms 单次查询,不含重试
下游 RPC 300ms 含连接池获取
序列化 + 响应 50ms 大对象要单独评估
预留 345ms GC、抖动、重试、未知
合计 1000ms 任何一层超预算,立即失败/降级

实现上,入口生成 deadline,通过 HTTP Header 或 gRPC Deadline 向下传递;每一层在发起调用前检查 remaining = deadline - now,如果剩余时间小于该依赖的最小可用时间,直接走降级,不再发起注定超时的调用。


2. 全局架构:把"等待"分层治理

图:接入层控总量、服务层隔离等待、数据层挡回源、可观测性做闭环。

这张图有三个关键设计:

  1. 入口有闸门:网关做全局限流、鉴权、路由和超时;服务内再做并发隔离,防止一个慢依赖拖垮整个实例。
  2. 每一层都有缓存和背压:本地缓存挡热点,Redis 挡大部分读,DB 只承接确认需要持久化的请求;MQ 用于削峰和解耦,不拿来当 RPC。
  3. 可观测性是横切面:指标、日志、Trace 必须能串起"网关 → 服务 → 连接池 → DB → 下游"的完整等待链路,否则优化只能靠猜。

3. 十维地图:每个维度只记一句话

# 维度 一句话本质 第一动作 关键指标 常见误区
1 流量治理 系统活下来,才有吞吐 入口限流 + 并发隔离 + 超时预算 429/503、排队时长、熔断状态 三层重试叠加
2 线程 线程是等待的容器 虚拟线程 + Semaphore 限流 活跃线程、排队、pin 次数 池化虚拟线程
3 缓存 把大多数读挡在 DB 之前 多级缓存 + SingleFlight 命中率、回源 QPS、热 Key 每次 miss 都加分布式锁
4 DB 连接是共享的稀缺资源 算连接数 + 短事务 + 索引 池 pending、慢查询、锁等待 连接池越大越好
5 事务 事务越长,锁和连接占得越久 缩小事务边界 + Outbox 事务耗时、回滚率、死锁 事务里调 RPC
6 异步 异步不是免费午餐 有界执行器 + 超时 + 上下文 队列深度、拒绝数、任务耗时 用默认执行器
7 序列化 序列化也是 CPU 和带宽 单例 ObjectMapper + DTO 序列化耗时、payload 大小 每次 new ObjectMapper
8 锁 锁的本质是串行化 缩小临界区 + 乐观锁 + Fencing 锁等待、冲突率、死锁 分布式锁不带栅栏令牌
9 JVM GC 停顿会放大尾延迟 容器内存 + G1/ZGC + JFR GC pause、分配速率、RSS 堆越大越好
10 可观测性 没有度量就没有优化 RED/USE + Trace + SLO P99、错误率、饱和度 只看平均 RT

下面逐维展开。每节给出"最小可落地动作",详细代码和取舍见对应深水区文章。


3.1 流量治理:先保证不被打死

本质: 限流不是限制用户,而是保护系统在过载时还能服务高优先级流量。

最小方案:

  1. 入口 QPS 限流:网关按路由/租户/接口限流,阈值 = 压测容量 × 0.8。
  2. 并发限流:对每个下游依赖设置信号量或线程池隔离,防止慢依赖吃光所有线程。
  3. 熔断:失败率或慢调用比例超过阈值,快速失败一段时间,给下游恢复窗口。
  4. 超时 + 重试预算:只在一个层次重试,带抖动,预算耗尽即失败。
  5. 降级:非核心字段、推荐、积分、日志异步化,核心链路保命。
java 复制代码
// Resilience4j:按依赖隔离 + 熔断(示意)
CircuitBreakerConfig cb = CircuitBreakerConfig.custom()
    .failureRateThreshold(50)
    .slowCallRateThreshold(50)
    .slowCallDurationThreshold(Duration.ofMillis(300))
    .minimumNumberOfCalls(20)
    .slidingWindowSize(50)
    .waitDurationInOpenState(Duration.ofSeconds(10))
    .permittedNumberOfCallsInHalfOpenState(5)
    .build();

BulkheadConfig bh = BulkheadConfig.custom()
    .maxConcurrentCalls(32)
    .maxWaitDuration(Duration.ofMillis(50))
    .build();

误区: 只在单机做限流,集群总流量仍然超;熔断器按实例隔离,无法感知全局;重试没有预算,故障时流量翻倍。

📖 深水区:02 · 流量治理:六层防线


3.2 线程:不要用线程数量掩盖下游容量不足

本质: 平台线程很贵(默认栈 1MB),它的数量应该匹配"同时等待的数量",而不是"想达到的 QPS"。

最小方案:

  1. 先用 Little's Law 算目标并发:L = QPS × RT。
  2. I/O 密集型优先评估 Java 21 虚拟线程 :spring.threads.virtual.enabled=true。
  3. 不要池化虚拟线程 ;用 Semaphore 限制对下游的并发,保护 DB/Redis/RPC。
  4. CPU 密集型任务继续用固定大小平台线程池,不要混用。
  5. 监控 pinning(JDK 21 的 synchronized 可能钉住载体线程)。
java 复制代码
// 虚拟线程执行器 + 下游并发闸门
ExecutorService vt = Executors.newVirtualThreadPerTaskExecutor();
Semaphore dbGate = new Semaphore(32);

public Order load(Long id) throws Exception {
    if (!dbGate.tryAcquire(50, TimeUnit.MILLISECONDS)) {
        throw new RejectedExecutionException("db overloaded");
    }
    try {
        return orderRepository.findById(id).orElseThrow();
    } finally {
        dbGate.release();
    }
}

误区: 把虚拟线程放进固定大小池;以为虚拟线程可以无限打 DB;在虚拟线程里大量使用 synchronized 和重 ThreadLocal。

📖 深水区:03 · 线程模型:虚拟线程与并发度


3.3 缓存:挡掉 90% 的读,而不是制造 100% 的不一致

本质: 缓存是用"可接受的一致性"换"更短的等待"。

最小方案:

  1. 两级缓存:Caffeine(毫秒级、进程内)+ Redis(分布式、容量大)。
  2. 缓存穿透:空值缓存 + 参数校验 + 布隆过滤器。
  3. 缓存击穿:SingleFlight(同 Key 只回源一次)或逻辑过期,不要每个请求一把分布式锁。
  4. 缓存雪崩:TTL 加随机抖动、多级缓存、熔断降级、预热。
  5. 一致性:先更新 DB,事务提交后删除缓存;高一致场景用 CDC/binlog 失效,不要"先删缓存再写库"。
java 复制代码
// SingleFlight 的核心:同 Key 的并发 miss 只回源一次
private final ConcurrentHashMap<String, CompletableFuture<User>> inflight = new ConcurrentHashMap<>();

public User get(String id) {
    User local = caffeine.getIfPresent(id);
    if (local != null) return local;

    CompletableFuture<User> f = inflight.computeIfAbsent(id,
        k -> CompletableFuture.supplyAsync(() -> loadThrough(k), executor));
    f.whenComplete((r, e) -> inflight.remove(id, f));
    return f.join(); // 生产环境用 get(timeout),并处理超时
}

误区: 缓存永不失效;空值不设 TTL;先删缓存再写库;热 Key 只靠 Redis 集群;把缓存当唯一数据源。

📖 深水区:04 · 缓存:从三兄弟到生产架构


3.4 数据库:连接池不是越大越好

本质: 数据库连接是全局共享的稀缺资源,连接池大小应该由"DB 能承受的并发"决定,而不是"应用想开多少"。

最小方案:

  1. 用 Little's Law 估算:连接数 ≈ 单实例 QPS × DB 持有时间,再乘安全系数。
  2. 所有实例的连接总数 ≤ max_connections × 0.7,给运维、批处理留余量。
  3. 连接池等待时间要短(1~3s),拿不到连接就快速失败/降级,不要无限等。
  4. 事务只包 DB 操作,不要把 RPC、MQ、文件 IO 放进事务。
  5. 慢 SQL 治理:索引、覆盖索引、游标分页、批量写入、避免 N+1。
yaml 复制代码
spring:
  datasource:
    hikari:
      maximum-pool-size: 20       # 按 DB 容量算,不是拍脑袋
      minimum-idle: 5
      connection-timeout: 2000    # 拿不到连接快速失败
      validation-timeout: 1000
      max-lifetime: 1200000       # 小于 DB wait_timeout
      leak-detection-threshold: 10000

误区: 连接池 100 起步;@Transactional 包住整个方法 including RPC;分库分表后不做跨分片查询治理;把 DB 当队列。

📖 深水区:05 · 数据库:连接池与 SQL 容量


3.5 事务:把事务做短,比选分布式事务更重要

本质: 事务持有数据库连接和锁;事务越长,并发能力越差。

最小方案:

  1. 事务只包"必须原子"的 DB 写操作,控制在毫秒级。
  2. 不在事务里调用 RPC、发 MQ、做文件上传、跑复杂计算。
  3. 跨服务一致性优先用 Outbox + 幂等消费,而不是默认上 2PC。
  4. 明确 rollbackFor、传播行为、只读事务、超时时间。
  5. 幂等键 + 状态机,保证重试安全。
java 复制代码
@Transactional(rollbackFor = Exception.class, timeout = 3)
public void placeOrder(PlaceOrderCmd cmd) {
    Order order = orderRepository.save(Order.create(cmd));
    // 只写本地库:业务表 + Outbox 表在同一个事务
    outboxRepository.save(OutboxEvent.of("order.created", order.getId(), order.payload()));
}
// 事务提交后,由 CDC 或轮询器把 Outbox 投递到 MQ

误区: @Transactional 自调用失效; checked exception 不回滚;事务里发 MQ 导致"消息先到、事务后回滚";REQUIRES_NEW 把连接池打满。

📖 深水区:06 · 事务:短事务与 Outbox


3.6 异步:异步不是免费午餐

本质: 异步把"等待"从线程上挪走,但把复杂度转移给了超时、上下文、背压和幂等。

最小方案:

  1. @Async 必须显式指定有界 执行器,禁止默认的 SimpleAsyncTaskExecutor。
  2. 为异步任务设置超时;CompletableFuture 不要用 commonPool 跑阻塞任务。
  3. 传递 MDC/Trace/SecurityContext;否则日志和链路会断。
  4. 有界队列 + 拒绝策略 + 监控;不要用无界队列掩盖过载。
  5. 跨服务异步优先 MQ,并保证消费者幂等、重试和死信。
java 复制代码
@Bean("bizExecutor")
public AsyncTaskExecutor bizExecutor() {
    return new TaskExecutorAdapter(Executors.newVirtualThreadPerTaskExecutor());
}

@Async("bizExecutor")
public CompletableFuture<Void> audit(Order order) {
    // 方法体已经由 @Async 调度到 bizExecutor,不要再嵌套 commonPool
    auditClient.send(order);
    return CompletableFuture.completedFuture(null);
}

误区: @Async 返回 void 吞异常;自调用导致代理失效;异步任务里再开无界线程池;用 CompletableFuture.allOf 却没有整体超时。

📖 深水区:07 · 异步:@Async 与 CompletableFuture


3.7 序列化:JSON 也会烧 CPU

本质: 序列化发生在每一次跨进程边界;它同时消耗 CPU、内存带宽和网络带宽。

最小方案:

  1. ObjectMapper 单例,配置一次,不要每次 new。
  2. 对外用 DTO,不直接序列化实体;避免双向关联和懒加载字段。
  3. 时间统一 ISO-8601;Long 超过 JS 安全整数时转字符串;BigDecimal 用字符串。
  4. 内部高频 RPC 评估 Protobuf/gRPC;Redis 用明确的字符串/JSON 序列化器。
  5. 大 payload 做分页、字段裁剪、压缩;小 payload 不要盲目 gzip。
java 复制代码
@Bean
ObjectMapper objectMapper() {
    return JsonMapper.builder()
        .addModule(new JavaTimeModule())
        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
        .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
        .build();
}

误区: 每次请求 new ObjectMapper;用 Java 原生序列化做缓存;Fastjson autoType 直接反序列化不可信数据;日志里 toString() 大对象。

📖 深水区:08 · 序列化:Jackson 到 Protobuf


3.8 锁:锁的本质是串行化

本质: 锁把并行变成串行;锁的范围越大、持有越久,吞吐越低。

最小方案:

  1. 缩小临界区,锁内不做 I/O、不调用远程服务。
  2. 读多写少用读写锁/StampedLock;计数用 LongAdder;分片用 Striped Lock。
  3. 能用乐观锁(version/CAS)就不要悲观锁。
  4. 分布式锁必须有过期时间、唯一 owner、Lua 释放;长任务要续约。
  5. 高风险资源使用 Fencing Token,防止 GC 停顿/网络分区导致"旧锁主"继续写。
java 复制代码
// 资源侧校验栅栏令牌:只接受更大的 token
public void update(long accountId, long fencingToken, Money delta) {
    if (fencingToken <= currentToken(accountId)) {
        throw new StaleTokenException("stale lock owner");
    }
    // 执行更新,并推进 currentToken
}

误区: 锁过期时间小于业务执行时间;释放锁不校验 owner;分布式锁解决一切并发;在 synchronized 里调用 RPC。

📖 深水区:09 · 锁:本地锁到分布式 Fencing


3.9 JVM:GC 停顿会放大尾延迟

本质: 对 I/O 密集型服务,JVM 调优的目标不是"GC 次数最少",而是"尾延迟稳定、内存不超容器限制"。

最小方案:

  1. 容器内用 -XX:MaxRAMPercentage=70,不要写死超过 limit 的 -Xmx。
  2. 低延迟优先 G1;对 P99 极敏感且堆较大时评估 ZGC(注意 JDK 版本差异)。
  3. 关注分配速率:JSON、日志、DTO、字符串拼接是常见垃圾来源。
  4. 开启 GC 日志、JFR、NMT;先测量再调参。
  5. 虚拟线程场景关注载体线程数、pinning、direct memory。
bash 复制代码
# 容器内 JVM 参数示例(按实际版本/负载调整)
-XX:MaxRAMPercentage=70
-XX:+UseG1GC
-XX:MaxGCPauseMillis=100
-Xlog:gc*:file=/opt/app/logs/gc.log:time,uptime,level,tags:filecount=10,filesize=50M
-XX:NativeMemoryTracking=summary

误区: 堆越大越好;只看 GC 次数不看 pause;容器 limit 和 -Xmx 不匹配;忽略 Netty direct memory 和线程栈。

📖 深水区:10 · JVM:GC 与尾延迟


3.10 可观测性:没有度量就没有优化

本质: 高并发优化是闭环:度量 → 假设 → 实验 → 验证 → 固化。

最小方案:

  1. 指标:RED(Rate、Errors、Duration)+ USE(Utilization、Saturation、Errors)。
  2. Trace:OpenTelemetry 贯穿网关、服务、DB、Redis、MQ;异步/虚拟线程要传上下文。
  3. 日志:结构化 JSON,带 traceId/spanId;异步 Appender 有界队列;热路径不打大对象。
  4. Profiling:async-profiler / JFR,定位 CPU、分配、锁、wall time。
  5. SLO:按 P99/错误率/饱和度告警,不用平均 RT。
yaml 复制代码
management:
  tracing:
    sampling:
      probability: 0.1   # 生产按流量调,排查时可临时提高
  otlp:
    tracing:
      endpoint: http://otel-collector:4318/v1/traces

误区: 只看平均 RT;Trace 采样 100% 导致开销;日志同步写磁盘;指标标签带 userId 导致基数爆炸;告警只看原因不看症状。

📖 深水区:11 · 可观测性:指标、追踪与压测


4. 端到端案例:订单查询服务的 10 维改造

4.1 现状与故障链

假设一个订单查询服务:

  • 8 个实例,每实例 Tomcat 200 线程;
  • HikariCP maximumPoolSize=50;
  • Redis 集群,MySQL 主从;
  • 峰值 6,000 QPS,平均 RT 120ms,P99 2.5s;
  • 大促峰值预估 12,000 QPS。

故障链如下:
下游 RPC MySQL Redis 订单服务 网关 客户端 下游 RPC MySQL Redis 订单服务 网关 客户端 #mermaid-svg-WGal20Ljsjn2cSem{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-WGal20Ljsjn2cSem .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-WGal20Ljsjn2cSem .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-WGal20Ljsjn2cSem .error-icon{fill:#552222;}#mermaid-svg-WGal20Ljsjn2cSem .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-WGal20Ljsjn2cSem .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-WGal20Ljsjn2cSem .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-WGal20Ljsjn2cSem .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-WGal20Ljsjn2cSem .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-WGal20Ljsjn2cSem .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-WGal20Ljsjn2cSem .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-WGal20Ljsjn2cSem .marker{fill:#333333;stroke:#333333;}#mermaid-svg-WGal20Ljsjn2cSem .marker.cross{stroke:#333333;}#mermaid-svg-WGal20Ljsjn2cSem svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-WGal20Ljsjn2cSem p{margin:0;}#mermaid-svg-WGal20Ljsjn2cSem .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-WGal20Ljsjn2cSem text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-WGal20Ljsjn2cSem .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-WGal20Ljsjn2cSem .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-WGal20Ljsjn2cSem .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-WGal20Ljsjn2cSem .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-WGal20Ljsjn2cSem #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-WGal20Ljsjn2cSem .sequenceNumber{fill:white;}#mermaid-svg-WGal20Ljsjn2cSem #sequencenumber{fill:#333;}#mermaid-svg-WGal20Ljsjn2cSem #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-WGal20Ljsjn2cSem .messageText{fill:#333;stroke:none;}#mermaid-svg-WGal20Ljsjn2cSem .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-WGal20Ljsjn2cSem .labelText,#mermaid-svg-WGal20Ljsjn2cSem .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-WGal20Ljsjn2cSem .loopText,#mermaid-svg-WGal20Ljsjn2cSem .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-WGal20Ljsjn2cSem .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-WGal20Ljsjn2cSem .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-WGal20Ljsjn2cSem .noteText,#mermaid-svg-WGal20Ljsjn2cSem .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-WGal20Ljsjn2cSem .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-WGal20Ljsjn2cSem .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-WGal20Ljsjn2cSem .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-WGal20Ljsjn2cSem .actorPopupMenu{position:absolute;}#mermaid-svg-WGal20Ljsjn2cSem .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-WGal20Ljsjn2cSem .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-WGal20Ljsjn2cSem .actor-man circle,#mermaid-svg-WGal20Ljsjn2cSem line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-WGal20Ljsjn2cSem :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} Tomcat 线程被占满 排队加剧,Hikari pending 上升 查询订单 1 转发(超时 3s) 2 读缓存 3 热 Key 超时 4 回源查询(慢 SQL) 5 800ms 6 查物流(超时 1s) 7 1.2s 超时 8 网关重试(第 2 次) 9 5s 超时 10 504 11

4.2 改造清单

维度 改造 预期作用
流量 网关按路由限流 12k QPS;服务内 DB 并发 32;下游 RPC 并发 64 过载时快速失败,不排队雪崩
线程 开启虚拟线程;DB/RPC 用 Semaphore 限流 同样内存承载更多等待
缓存 Caffeine 5s + Redis 5min;SingleFlight;TTL 抖动 热 Key 只回源一次
DB 慢 SQL 加联合索引;Hikari 降到 20;游标分页 降低持有时间与连接占用
事务 查询走只读事务;下单事务只包 DB 写 + Outbox 事务从 300ms 降到 <20ms
异步 审计、积分、通知走 MQ;@Async 有界执行器 主链路去掉非核心等待
序列化 DTO + 单例 ObjectMapper;内部 RPC 评估 Protobuf 降低 CPU 与 payload
锁 库存扣减用乐观锁 + Fencing Token 避免锁过期导致超卖
JVM 堆 4G、G1、GC 日志、JFR P99 GC 停顿可控
可观测 OTel + Prometheus + Grafana;连接池/线程池/缓存指标 5 分钟内定位瓶颈

4.3 容量推演(假设,不是实测)

假设改造后目标:

  • 峰值 12,000 QPS,10 个实例 → 单实例 1,200 QPS;
  • 平均 RT 目标 80ms → 平均在途 L = 1200 × 0.08 = 96;
  • P99 目标 300ms,峰值按 3 倍平均在途预留 → 约 288;
  • 单实例并发上限设为 400,超过则快速拒绝/降级。

DB:

  • 缓存命中率 90%,单实例回源 120 QPS;
  • 单次查询平均持有连接 5ms → 平均连接 120 × 0.005 = 0.6;
  • 考虑 P99 50ms、突发 3 倍 → 120 × 3 × 0.05 = 18;
  • Hikari 设为 20~30,配合 DB 总连接数上限校验。

这些数字是容量模型的输入示例。真实值必须用压测和 APM 数据替换。

4.4 改造后的请求时序

MQ MySQL Redis Caffeine 订单服务 网关 客户端 MQ MySQL Redis Caffeine 订单服务 网关 客户端 #mermaid-svg-PPTgEK8KCPjaPi5L{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-PPTgEK8KCPjaPi5L .error-icon{fill:#552222;}#mermaid-svg-PPTgEK8KCPjaPi5L .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-PPTgEK8KCPjaPi5L .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-PPTgEK8KCPjaPi5L .marker{fill:#333333;stroke:#333333;}#mermaid-svg-PPTgEK8KCPjaPi5L .marker.cross{stroke:#333333;}#mermaid-svg-PPTgEK8KCPjaPi5L svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-PPTgEK8KCPjaPi5L p{margin:0;}#mermaid-svg-PPTgEK8KCPjaPi5L .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-PPTgEK8KCPjaPi5L text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-PPTgEK8KCPjaPi5L .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-PPTgEK8KCPjaPi5L .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-PPTgEK8KCPjaPi5L .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-PPTgEK8KCPjaPi5L .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-PPTgEK8KCPjaPi5L #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-PPTgEK8KCPjaPi5L .sequenceNumber{fill:white;}#mermaid-svg-PPTgEK8KCPjaPi5L #sequencenumber{fill:#333;}#mermaid-svg-PPTgEK8KCPjaPi5L #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-PPTgEK8KCPjaPi5L .messageText{fill:#333;stroke:none;}#mermaid-svg-PPTgEK8KCPjaPi5L .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-PPTgEK8KCPjaPi5L .labelText,#mermaid-svg-PPTgEK8KCPjaPi5L .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-PPTgEK8KCPjaPi5L .loopText,#mermaid-svg-PPTgEK8KCPjaPi5L .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-PPTgEK8KCPjaPi5L .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-PPTgEK8KCPjaPi5L .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-PPTgEK8KCPjaPi5L .noteText,#mermaid-svg-PPTgEK8KCPjaPi5L .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-PPTgEK8KCPjaPi5L .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-PPTgEK8KCPjaPi5L .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-PPTgEK8KCPjaPi5L .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-PPTgEK8KCPjaPi5L .actorPopupMenu{position:absolute;}#mermaid-svg-PPTgEK8KCPjaPi5L .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-PPTgEK8KCPjaPi5L .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-PPTgEK8KCPjaPi5L .actor-man circle,#mermaid-svg-PPTgEK8KCPjaPi5L line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-PPTgEK8KCPjaPi5L :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} alt Redis 命中 Redis miss alt 本地命中 本地 miss 查询订单(deadline=800ms) 1 限流 / 鉴权 / 计算剩余预算 2 转发(剩余 720ms) 3 本地缓存 4 返回 5 读 Redis 6 返回并回填本地 7 SingleFlight 合并回源 8 查询(超时 150ms) 9 返回 10 回填(TTL + 抖动) 11 回填(短 TTL) 12 响应 13 200 14 Outbox/异步审计(不阻塞响应) 15

4.5 验收指标

指标 目标 采集方式
P99 RT < 300ms Micrometer/APM
错误率 < 0.1% 网关 + 服务
DB 连接池 pending 0(P99) Hikari metrics
缓存命中率 > 90% Caffeine/Redis
GC pause P99 < 50ms GC log/JFR
线程池拒绝率 < 0.5% Executor metrics
单实例 CPU < 65% 容器监控
故障注入恢复 < 30s Chaos Blast

5. 30 / 60 / 90 天落地路线

第 1 个月:止血与度量

  • 全链路超时、重试预算、入口限流;
  • Hikari/线程池/Redis 连接池参数按容量模型调整;
  • 慢 SQL Top 20 治理;
  • 建立 4 张核心看板:入口、服务、依赖、资源;
  • 明确 P99/错误率/SLO,不再只看平均 RT。

第 2 个月:降等待

  • 多级缓存 + SingleFlight + TTL 抖动;
  • 事务边界治理,RPC/MQ 移出事务;
  • 异步任务有界化、上下文传递、异常处理;
  • 虚拟线程小流量试点,观察 pinning 和 DB 并发;
  • 序列化 DTO 化、ObjectMapper 单例、大 payload 治理。

第 3 个月:提并发与稳定性

  • 虚拟线程全量或按接口灰度;
  • 锁粒度优化、乐观锁/Fencing;
  • JVM 容器参数、GC 日志、JFR 常态化;
  • 混沌演练:下游超时、Redis 故障、DB 主从切换;
  • 容量压测与成本复盘,形成团队基线。

优先级矩阵

动作 影响 成本 优先级
超时/限流/重试预算 高 低 P0
慢 SQL/索引 高 低 P0
连接池/线程池按公式调整 高 低 P0
多级缓存 + SingleFlight 高 中 P1
事务缩短 + Outbox 高 中 P1
虚拟线程 中高 中 P1
序列化/协议升级 中 中高 P2
JVM 深度调优 中 中 P2
全链路压测/混沌 高 高 P2

6. 20 条常见误区

  1. 加机器能解决所有高并发问题。
  2. 线程池越大,吞吐越高。
  3. 虚拟线程可以无限并发,不用限流。
  4. 连接池 100 起步,反正数据库能扛。
  5. 缓存击穿就加分布式锁,每个 miss 都加。
  6. 先删缓存再写库,保证"绝对一致"。
  7. @Transactional 包住整个业务方法,包括 RPC。
  8. @Async 不指定执行器,用默认的。
  9. CompletableFuture 默认用 commonPool 跑阻塞任务。
  10. 三层都加重试,觉得"更可靠"。
  11. 超时只配一边,下游等 30s,上游等 3s。
  12. 限流只做单机,集群总量仍然超。
  13. 熔断器按实例隔离,却以为全局生效。
  14. 用 Java 原生序列化做 Redis 缓存。
  15. 每次请求 new ObjectMapper。
  16. 分布式锁不设过期时间,或过期时间小于业务时间。
  17. 锁释放不校验 owner,误删别人的锁。
  18. 堆越大越好,GC 停顿无所谓。
  19. 只看平均 RT,不看 P99/P999。
  20. 没有压测、没有故障注入,直接上大促。

7. 上线 Checklist(可复制)

text 复制代码
[ ] 每个外部调用都有连接/读取/总超时
[ ] 入口有 QPS 或并发限流,阈值来自压测
[ ] 每个强依赖有熔断/隔离,失败可降级
[ ] 重试只在一层,幂等,退避 + 抖动 + 预算
[ ] 线程池/连接池有界,拒绝策略明确,指标可观测
[ ] 虚拟线程未池化,DB/RPC 有 Semaphore 闸门
[ ] 缓存有 TTL 抖动、空值保护、SingleFlight
[ ] 缓存更新在事务提交后,或走 CDC
[ ] 事务内无 RPC/MQ/文件 IO,超时明确
[ ] 跨服务一致性有 Outbox/幂等/补偿方案
[ ] 异步任务有超时、上下文、异常处理、拒绝监控
[ ] 序列化使用 DTO,ObjectMapper 单例
[ ] 分布式锁有 owner、过期、续约、Fencing
[ ] JVM 容器参数与 limit 匹配,GC 日志开启
[ ] P99/错误率/饱和度有看板与告警
[ ] 压测覆盖峰值 1.5 倍,故障注入通过

8. 三个问题,评论区见

  1. 你线上最常见的瓶颈是哪个维度?1 流量 / 2 线程 / 3 缓存 / 4 DB / 5 事务 / 6 异步 / 7 序列化 / 8 锁 / 9 JVM / 10 可观测性
  2. 你遇到过最诡异的 P99 抖动是什么?后来定位到了哪一层?
  3. 下一篇想先看"虚拟线程实战"还是"缓存击穿"?留言区投票,我按票数加更。

如果这篇帮你建立了 I/O 密集型系统的全局框架,建议先收藏,再按目录挑一篇深水区落地。

相关推荐
吃我一窝jio1 小时前
Python与Go线程模型深度对比
java·开发语言·python
这个昵称不容易1 小时前
SpringBoot 购物推荐网站的设计与实现:120 个 Java 文件、147 个接口、13 张表,附真实运行截图
java·springboot·毕设
文丑颜不良啊1 小时前
LeetCode3041~3060题目解析
java·leetcode
文丑颜不良啊3 小时前
LeetCode3101~3120题目解析
java·leetcode
Resean02233 小时前
SpringMVC 6+源码分析(十一)视图渲染与异步请求(收尾篇)
java·spring·springmvc
靠沿4 小时前
MySQL数据库进阶——存储过程和触发器
java·数据库·mysql
码少女5 小时前
MySQL--库与表的增删改查基础
java·数据库·mysql
隔窗听雨眠5 小时前
Spring Boot启动提速的机制剖析与调优路径
性能优化·springboot·后端开发
码间留白5 小时前
AI 给的两个方案都被我否了:把 startIcon 与启动遮罩做成同一张图,鸿蒙 APP 冷启动零白屏
性能优化·uni-app·ai编程·harmonyos