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. 全局架构:把"等待"分层治理

图:接入层控总量、服务层隔离等待、数据层挡回源、可观测性做闭环。
这张图有三个关键设计:
- 入口有闸门:网关做全局限流、鉴权、路由和超时;服务内再做并发隔离,防止一个慢依赖拖垮整个实例。
- 每一层都有缓存和背压:本地缓存挡热点,Redis 挡大部分读,DB 只承接确认需要持久化的请求;MQ 用于削峰和解耦,不拿来当 RPC。
- 可观测性是横切面:指标、日志、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 流量治理:先保证不被打死
本质: 限流不是限制用户,而是保护系统在过载时还能服务高优先级流量。
最小方案:
- 入口 QPS 限流:网关按路由/租户/接口限流,阈值 = 压测容量 × 0.8。
- 并发限流:对每个下游依赖设置信号量或线程池隔离,防止慢依赖吃光所有线程。
- 熔断:失败率或慢调用比例超过阈值,快速失败一段时间,给下游恢复窗口。
- 超时 + 重试预算:只在一个层次重试,带抖动,预算耗尽即失败。
- 降级:非核心字段、推荐、积分、日志异步化,核心链路保命。
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"。
最小方案:
- 先用 Little's Law 算目标并发:
L = QPS × RT。 - I/O 密集型优先评估 Java 21 虚拟线程 :
spring.threads.virtual.enabled=true。 - 不要池化虚拟线程 ;用
Semaphore限制对下游的并发,保护 DB/Redis/RPC。 - CPU 密集型任务继续用固定大小平台线程池,不要混用。
- 监控 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% 的不一致
本质: 缓存是用"可接受的一致性"换"更短的等待"。
最小方案:
- 两级缓存:Caffeine(毫秒级、进程内)+ Redis(分布式、容量大)。
- 缓存穿透:空值缓存 + 参数校验 + 布隆过滤器。
- 缓存击穿:SingleFlight(同 Key 只回源一次)或逻辑过期,不要每个请求一把分布式锁。
- 缓存雪崩:TTL 加随机抖动、多级缓存、熔断降级、预热。
- 一致性:先更新 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 能承受的并发"决定,而不是"应用想开多少"。
最小方案:
- 用 Little's Law 估算:
连接数 ≈ 单实例 QPS × DB 持有时间,再乘安全系数。 - 所有实例的连接总数 ≤
max_connections × 0.7,给运维、批处理留余量。 - 连接池等待时间要短(1~3s),拿不到连接就快速失败/降级,不要无限等。
- 事务只包 DB 操作,不要把 RPC、MQ、文件 IO 放进事务。
- 慢 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 事务:把事务做短,比选分布式事务更重要
本质: 事务持有数据库连接和锁;事务越长,并发能力越差。
最小方案:
- 事务只包"必须原子"的 DB 写操作,控制在毫秒级。
- 不在事务里调用 RPC、发 MQ、做文件上传、跑复杂计算。
- 跨服务一致性优先用 Outbox + 幂等消费,而不是默认上 2PC。
- 明确
rollbackFor、传播行为、只读事务、超时时间。 - 幂等键 + 状态机,保证重试安全。
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 异步:异步不是免费午餐
本质: 异步把"等待"从线程上挪走,但把复杂度转移给了超时、上下文、背压和幂等。
最小方案:
@Async必须显式指定有界 执行器,禁止默认的SimpleAsyncTaskExecutor。- 为异步任务设置超时;
CompletableFuture不要用 commonPool 跑阻塞任务。 - 传递 MDC/Trace/SecurityContext;否则日志和链路会断。
- 有界队列 + 拒绝策略 + 监控;不要用无界队列掩盖过载。
- 跨服务异步优先 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、内存带宽和网络带宽。
最小方案:
ObjectMapper单例,配置一次,不要每次new。- 对外用 DTO,不直接序列化实体;避免双向关联和懒加载字段。
- 时间统一 ISO-8601;
Long超过 JS 安全整数时转字符串;BigDecimal用字符串。 - 内部高频 RPC 评估 Protobuf/gRPC;Redis 用明确的字符串/JSON 序列化器。
- 大 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 锁:锁的本质是串行化
本质: 锁把并行变成串行;锁的范围越大、持有越久,吞吐越低。
最小方案:
- 缩小临界区,锁内不做 I/O、不调用远程服务。
- 读多写少用读写锁/StampedLock;计数用 LongAdder;分片用 Striped Lock。
- 能用乐观锁(version/CAS)就不要悲观锁。
- 分布式锁必须有过期时间、唯一 owner、Lua 释放;长任务要续约。
- 高风险资源使用 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 次数最少",而是"尾延迟稳定、内存不超容器限制"。
最小方案:
- 容器内用
-XX:MaxRAMPercentage=70,不要写死超过 limit 的-Xmx。 - 低延迟优先 G1;对 P99 极敏感且堆较大时评估 ZGC(注意 JDK 版本差异)。
- 关注分配速率:JSON、日志、DTO、字符串拼接是常见垃圾来源。
- 开启 GC 日志、JFR、NMT;先测量再调参。
- 虚拟线程场景关注载体线程数、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 可观测性:没有度量就没有优化
本质: 高并发优化是闭环:度量 → 假设 → 实验 → 验证 → 固化。
最小方案:
- 指标:RED(Rate、Errors、Duration)+ USE(Utilization、Saturation、Errors)。
- Trace:OpenTelemetry 贯穿网关、服务、DB、Redis、MQ;异步/虚拟线程要传上下文。
- 日志:结构化 JSON,带 traceId/spanId;异步 Appender 有界队列;热路径不打大对象。
- Profiling:async-profiler / JFR,定位 CPU、分配、锁、wall time。
- 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 条常见误区
- 加机器能解决所有高并发问题。
- 线程池越大,吞吐越高。
- 虚拟线程可以无限并发,不用限流。
- 连接池 100 起步,反正数据库能扛。
- 缓存击穿就加分布式锁,每个 miss 都加。
- 先删缓存再写库,保证"绝对一致"。
@Transactional包住整个业务方法,包括 RPC。@Async不指定执行器,用默认的。CompletableFuture默认用 commonPool 跑阻塞任务。- 三层都加重试,觉得"更可靠"。
- 超时只配一边,下游等 30s,上游等 3s。
- 限流只做单机,集群总量仍然超。
- 熔断器按实例隔离,却以为全局生效。
- 用 Java 原生序列化做 Redis 缓存。
- 每次请求
new ObjectMapper。 - 分布式锁不设过期时间,或过期时间小于业务时间。
- 锁释放不校验 owner,误删别人的锁。
- 堆越大越好,GC 停顿无所谓。
- 只看平均 RT,不看 P99/P999。
- 没有压测、没有故障注入,直接上大促。
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 流量 / 2 线程 / 3 缓存 / 4 DB / 5 事务 / 6 异步 / 7 序列化 / 8 锁 / 9 JVM / 10 可观测性
- 你遇到过最诡异的 P99 抖动是什么?后来定位到了哪一层?
- 下一篇想先看"虚拟线程实战"还是"缓存击穿"?留言区投票,我按票数加更。
如果这篇帮你建立了 I/O 密集型系统的全局框架,建议先收藏,再按目录挑一篇深水区落地。