外观
01 - 服务一拆就变慢:一次请求在分布式系统中经历了什么
摘要
同一段业务逻辑从单体拆到多个服务后,延迟为何上升,故障为何变多?本文沿一次订单请求拆解网关、RPC、线程池、连接池、缓存、数据库和消息队列,解释远程调用的真实成本,并用 Java 17 复现超时与“结果未知”。
1. 场景引入:代码没变复杂,接口却从 40 ms 变成 800 ms
某订单接口在单体应用中大致做三件事:校验库存、创建订单、发放积分。单体应用把这些业务模块放在同一个进程中,模块之间可以直接调用方法。业务增长后,团队把它拆成订单、库存、会员三个服务,又在入口增加 API Gateway(API 网关,负责接收并转发外部请求),用 Redis 缓存商品信息,用消息队列异步发积分。
拆分后,各服务作为独立进程运行,通过网络交换请求和响应,这就形成了分布式系统。调用方称为上游,被调用方称为下游;例如订单服务是库存服务的上游。理解这条链路,可以先抓住三个问题:接口返回前要等谁,等待时占用了什么资源,没收到响应时还能确认什么。
上线后出现了几个看似矛盾的现象:
- 每个下游服务的监控耗时都“不算高”,入口接口的 P99(第 99 百分位耗时)却明显上升;
- 客户端收到超时,订单库里有时已经创建了订单;
- 库存服务只是短暂变慢,订单服务的线程池和连接池却很快耗尽;
- 重试让成功率短暂回升,几分钟后整个链路反而雪崩;
- 日志里每个组件都声称自己成功,却无法回答用户请求最终是否成功。
问题不一定出在某个“性能很差”的组件。真正的变化是:原来一次进程内的方法调用,被替换成了多次跨进程通信。每跨过一次网络边界,就新增一组延迟、资源和失败状态。
2. 先看完整链路:一次下单不是一条线
先把典型请求画出来:
图表将在阅读到此处时加载…
图中的 RPC(Remote Procedure Call,远程过程调用)表示跨进程调用;消息队列中的 Produce 和 Consume 分别表示发送和消费消息。这张图表达的是逻辑依赖,并不表示所有步骤都串行执行,也不表示订单接口必须等积分到账才能返回。
实际通信还可能涉及 DNS(把域名解析为地址)、负载均衡(选择服务实例)、容器网络和 TLS(加密通信)。此外,请求需要编码为字节,并等待连接和处理线程。这些成本会随部署方式和连接复用情况变化,不是每次调用都要重新解析域名或完成握手。
2.1 同步路径与异步路径
同步路径是接口返回前必须等待的步骤;异步路径是可以在返回后继续处理的工作。同步关键路径决定了接口最早何时能够返回:串行步骤要逐个等待,并行步骤若都必需完成,则要等最慢的分支。
text
同步关键路径:客户端 → 网关 → 订单 → 库存 → 订单数据库 → 返回
异步后续路径:订单 → 消息队列 → 会员服务 → 会员数据库上面的路径是简化视图:库存服务内部还要访问库存数据库;若 Redis 查询和消息发送确认也必须在返回前完成,它们同样属于同步路径。
把积分改成消息队列,改变的是“接口成功”所承诺的完成范围:
- 接口成功可能只表示“订单已创建,积分消息已被可靠接收”;
- 积分什么时候到账由消费延迟决定;
- 消息发送失败、重复投递和消费失败需要单独处理;
- 如果数据库提交成功但消息未发送,仍然会产生一致性问题。
所以分析接口耗时时,先画出同步关键路径;分析业务最终结果时,还要把异步路径补回来。
3. 本地调用和远程调用,差别不只是多了一段网络
3.1 本地调用的失败边界相对清楚
一次普通 Java 方法调用大致是:
java
Order order = orderService.create(command);调用方和被调用方通常处于同一进程:
- 参数以对象引用或值的形式传递;
- 调用依靠线程栈和直接/间接方法调用;
- 返回值仍是进程内对象;
- 抛出的异常可以沿调用栈传播;
- 如果进程在执行中崩溃,调用方通常也一起消失。
这里也会遇到锁竞争、GC Pause(垃圾回收暂停)、线程调度和内存不足,但调用双方共享同一进程的生存状态。这个对比只针对进程内调用本身;如果方法内部已经访问外部数据库或服务,仍需处理远程通信的失败。
3.2 远程调用必须把“调用”变成字节
当库存服务成为独立进程后,reserve() 看起来仍像一个方法,底层却至少经历:
图表将在阅读到此处时加载…
沿这条链路,可以把成本分成以下几类。不同客户端的具体顺序和实现可能不同:
- 服务发现:确定请求应该发往哪个实例;
- 负载均衡:从可用实例中选择目标;
- 连接获取:连接池保存可复用的连接;连接被占满时要等待,必要时还要建立 TCP/TLS 连接;
- 序列化:把对象编码成 JSON、Protobuf 等字节格式;
- 网络传输:数据经过内核缓冲区、网络设备和对端协议栈;
- 服务端排队:线程池用有限数量的线程处理任务;线程忙时,请求可能进入队列,等待事件循环或业务线程处理;
- 业务执行:访问数据库、缓存或更多下游;
- 响应返回:把以上过程近似反向执行一次。
RPC 框架可以让远程调用写起来像本地方法,却无法消除这些成本。请求和响应也可能在不同阶段失败,所以“方法抛异常”不足以说明服务端究竟执行到了哪一步。
4. 延迟是相加的,尾延迟还会被放大
4.1 关键路径决定用户等待多久
假设一次下单同步执行:
| 阶段 | 示例耗时 |
|---|---|
| 网关处理 | 8 ms |
| 订单服务排队 | 12 ms |
| 库存 RPC | 45 ms |
| 订单数据库事务 | 30 ms |
| 响应编码与网络返回 | 10 ms |
忽略阶段重叠时,总耗时约为 8 + 12 + 45 + 30 + 10 = 105 ms。这里的数字只是演示,不是组件基准;真实值取决于机器、网络、连接复用、数据规模、并发和运行时版本。
如果库存校验、价格查询和风控检查之间没有先后依赖,可以并行执行;需要等待三者完成的这段耗时接近最慢分支,整个接口仍要加上并行段前后的串行步骤。但并行也会增加瞬时下游请求数、资源占用和故障处理复杂度。
4.2 平均值正常,不代表用户体验正常
P99 表示约 99% 的观测值不超过该值,剩余约 1% 更慢。这部分较慢请求的耗时称为尾延迟。多数请求很快时,少量极慢请求可能被平均值掩盖,因此平均耗时正常并不能说明用户都能及时得到响应。
假设一个请求必须串行通过 5 个下游,每个下游单次调用达到其“正常区间”的概率都是 99%。在简化且相互独立的假设下,整条链路全部正常的概率约为:
text
0.99 ^ 5 ≈ 95.1%这个计算描述的是“所有调用都落在各自正常区间”的概率,不能直接算出整条链路的 P99,也不是生产容量公式。下游延迟通常并不独立:它们可能共享网络、宿主机或数据库。在上述简化假设下,依赖越多,至少遇到一个慢点的概率就越高。
4.3 排队时间往往比执行时间更危险
服务端记录的“业务方法耗时 20 ms”不一定包含:
- 客户端等待连接池的时间;
- 请求到达后等待业务线程的时间;
- 服务端写回响应时等待网络缓冲区的时间;
- 客户端收到字节后反序列化的时间。
因此一次 RPC 的客户端总耗时可以按以下阶段拆解。服务发现可能使用缓存,已有连接也可以省去建连和握手;请求编码与负载均衡等开销也应按实际实现计入:
text
总耗时 = 服务发现 + 连接池等待 + 建连/握手 + 请求发送
+ 服务端排队 + 业务执行 + 响应传输 + 解码只有确认两项记录属于同一次调用、测量边界一致,才能用“客户端 800 ms”和“服务端方法 20 ms”的差值寻找其余 780 ms。缺失时间可能分散在多个阶段,不能直接归到网络传输。
5. 分布式系统的常态:Partial Failure
**Partial Failure(部分失败)**指系统中的一部分组件失败或失联,而其他组件仍在运行。单体进程通常整体存活或整体退出;分布式系统却会出现大量中间状态:
- 请求发出前客户端崩溃;
- 请求已到服务端,但客户端没收到响应;
- 服务端数据库已提交,响应在网络中丢失;
- A 能访问 B,C 暂时不能访问 B;
- 一个实例健康,另一个实例卡在 Full GC(全堆垃圾回收);
- 注册中心里实例仍存在,但其业务线程池已经耗尽。
5.1 超时只说明“没等到”,不说明“没执行”
考虑下列时序:
图表将在阅读到此处时加载…
此时调用方拿到的是“结果未知”,而不是确定失败。如果直接重试,又没有幂等保护,库存可能被扣两次。幂等是指同一业务操作重复请求时,不会产生额外的业务副作用;幂等键则是服务端用来识别同一操作的稳定标识。
这也是分布式系统里最重要的思维变化之一:
成功、失败之外,还必须处理 Unknown(未知结果)。
5.2 TCP 成功不等于业务成功
TCP 确认数据到达对端协议栈,不代表业务线程已经执行;HTTP 200 表示应用返回了成功状态,也不自动代表跨数据库、缓存和消息队列的全部副作用都已完成。
业务必须定义自己的成功语义。例如创建订单可以定义为:
text
订单事务提交成功,并且可靠事件已经与订单处于同一个可恢复流程中。这里的“可恢复流程”意味着:即使发送进程中断,系统仍能找到尚未完成的事件并继续处理。例如可以将订单和待发送事件写入同一个本地事务,再由后续任务发送事件。接口成功承诺的是订单已创建、后续工作可恢复,而不是积分已经到账。
6. 代码实战:复现远程调用的三种结果
下面的 Java 17 示例只使用 JDK 自带组件,需要本机安装 JDK 17 且 8080 端口可用。它启动 HTTP 服务,再分别调用快速、慢速和“服务端已完成但响应太晚”的接口。业务提交由内存集合模拟,不连接真实数据库。
客户端的连接超时为 300 ms,快速请求允许等待 1 秒;两个慢接口故意延迟 800 ms,而首次调用只等待 200 ms。最后使用相同的 R1001 重试,并把请求超时设为 2 秒,以观察去重响应。
保存为 RemoteCallDemo.java:
java
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class RemoteCallDemo {
// 模拟已经完成的业务操作。生产环境应由数据库唯一约束或状态机保证幂等。
private static final Set<String> COMPLETED = ConcurrentHashMap.newKeySet();
public static void main(String[] args) throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
ExecutorService serverExecutor = Executors.newFixedThreadPool(4);
server.setExecutor(serverExecutor);
server.createContext("/fast", exchange -> respond(exchange, 200, "fast-ok"));
server.createContext("/slow", exchange -> {
sleep(800);
respond(exchange, 200, "slow-ok");
});
server.createContext("/commit-then-slow-response", exchange -> {
String requestId = exchange.getRequestHeaders().getFirst("X-Request-Id");
boolean firstExecution = COMPLETED.add(requestId);
// 模拟数据库事务已经提交。
System.out.printf("server: requestId=%s, firstExecution=%s, committed=true%n",
requestId, firstExecution);
// 故意延迟响应,使客户端先超时。
sleep(800);
respond(exchange, 200, firstExecution ? "created" : "duplicated-but-ignored");
});
server.start();
System.out.println("server started at http://localhost:8080");
HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofMillis(300))
.build();
call(client, "/fast", "R-fast", Duration.ofSeconds(1));
call(client, "/slow", "R-slow", Duration.ofMillis(200));
// 第一次调用会超时,但服务端操作已经完成。
call(client, "/commit-then-slow-response", "R1001", Duration.ofMillis(200));
sleep(1_000);
// 使用相同幂等键重试,服务端识别出重复操作。
call(client, "/commit-then-slow-response", "R1001", Duration.ofSeconds(2));
server.stop(0);
serverExecutor.shutdown();
}
private static void call(HttpClient client, String path, String requestId,
Duration requestTimeout) {
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("http://localhost:8080" + path))
.timeout(requestTimeout)
.header("X-Request-Id", requestId)
.GET()
.build();
long start = System.nanoTime();
try {
HttpResponse<String> response = client.send(
request, HttpResponse.BodyHandlers.ofString());
System.out.printf("client: path=%s, status=%d, body=%s, elapsed=%dms%n",
path, response.statusCode(), response.body(), elapsedMillis(start));
} catch (Exception e) {
System.out.printf("client: path=%s, result=UNKNOWN, error=%s, elapsed=%dms%n",
path, e.getClass().getSimpleName(), elapsedMillis(start));
}
}
private static void respond(HttpExchange exchange, int status, String body)
throws IOException {
byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
exchange.sendResponseHeaders(status, bytes.length);
try (var output = exchange.getResponseBody()) {
output.write(bytes);
}
}
private static long elapsedMillis(long start) {
return Duration.ofNanos(System.nanoTime() - start).toMillis();
}
private static void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}
}编译并运行:
bash
javac --add-modules jdk.httpserver RemoteCallDemo.java
java --add-modules jdk.httpserver RemoteCallDemo预期输出大致如下,具体毫秒数和日志顺序受本机调度影响;机器严重繁忙或连接异常时,快速请求也可能失败:
text
server started at http://localhost:8080
client: path=/fast, status=200, body=fast-ok, elapsed=...ms
client: path=/slow, result=UNKNOWN, error=HttpTimeoutException, elapsed=...ms
server: requestId=R1001, firstExecution=true, committed=true
client: path=/commit-then-slow-response, result=UNKNOWN, error=HttpTimeoutException, elapsed=...ms
server: requestId=R1001, firstExecution=false, committed=true
client: path=/commit-then-slow-response, status=200, body=duplicated-but-ignored, elapsed=...ms可以从这个示例理解三件事:
- 本机回环网络也不是零成本,首次请求还可能包含连接建立等开销;
- 客户端超时后,服务端线程可以继续执行;
- 对扣库存、创建订单等有副作用的操作,重试需要携带稳定的幂等键,服务端需要原子地识别重复请求。
示例里的 ConcurrentHashMap 只适合单进程演示:进程重启会丢失记录,多实例之间也不共享状态。集合的 add 仅模拟原子去重,不能保证真实业务提交和去重记录一起成功。生产环境通常使用数据库唯一约束、业务状态机或具备明确持久化语义的去重存储。幂等将在第 13 篇详细展开。
call 为简化展示,把捕获的所有异常统一打印为 UNKNOWN。实际系统应按错误发生阶段区分:确定请求未发送,与请求已发送但未收到响应,需要不同的处理策略。另外,这里的 GET 请求带有模拟写操作,仅用于本机演示;真实 HTTP 接口不应把扣库存等写操作设计为 GET。
7. 反例与正例:不要把远程调用写得像普通 Getter
7.1 反例:隐藏远程成本和失败语义
以下两段是依赖业务类型和客户端实现的 Java 局部示意,不能独立编译。Getter 通常指读取属性的方法,但一个看起来简单的读取方法也可能发起远程调用。
java
public OrderView getOrder(long orderId) {
Order order = orderRepository.find(orderId);
// 方法名看不出这是远程调用,也没有超时、降级和结果语义。
String memberName = memberService.getName(order.userId());
return new OrderView(order, memberName);
}这类代码容易形成几个问题:
- 一次查询获取 N 条订单后,逐条查询会员,额外触发 N 次 RPC,形成远程版 N+1 查询;
- 默认超时可能远大于接口总预算;
- 下游非核心字段失败,却拖垮整个订单接口;
- 调用方不知道该调用是否安全重试;
- 指标只记录整个方法,无法定位时间花在哪个下游。
7.2 正例:显式表达边界、预算和降级
超时预算是本次请求还能用于等待的时间;降级是在业务允许的情况下,用较少的信息继续提供服务。下面假设订单主体已能正确查询,会员名称是非核心字段,且 memberClient 会遵守传入的超时。传入预算必须为正;实际调用前还应扣除订单查询等已消耗时间,并为后续响应留出时间。
java
public OrderView getOrder(long orderId, Duration remainingBudget) {
Order order = orderRepository.find(orderId);
// 示例:会员名称不是订单详情的核心字段,调用失败时允许降级。
Duration memberTimeout = remainingBudget.compareTo(Duration.ofMillis(100)) > 0
? Duration.ofMillis(100)
: remainingBudget;
try {
String memberName = memberClient.getName(order.userId(), memberTimeout);
return new OrderView(order, memberName);
} catch (RemoteTimeoutException e) {
// 记录下游、超时预算、请求 ID 和降级次数;不要只打印异常文本。
return new OrderView(order, "暂不可用");
}
}这段示意明确了远程调用的几个边界:
memberClient是远程依赖;- 客户端应限制等待时间,避免无限占用资源;
- 会员超时取传入预算与 100 ms 中的较小值;完整链路还需持续更新剩余预算;
- 会员名称允许降级,订单主体不允许被静默伪造;
- 失败后的返回语义由业务决定。
如果会员信息是合规校验的必要条件,就不能这样降级。降级不是技术组件替业务做决定,而是业务提前定义“缺少什么信息时仍能正确服务”。
8. 为什么慢下游会拖垮上游
假设订单服务用 200 个业务线程处理阻塞式请求,正常时每个请求占用线程 50 ms。库存服务故障后,下游调用等待 2 秒才超时;由于业务线程在等待期间不能释放,单个请求因此占用线程约 2 秒,是正常时的约 40 倍。即使入口流量不变,原来的请求还没释放线程,新的请求已经到达,也会更容易排队;若等待期间还持有连接,连接池同样可能被占满。
Little's Law(利特尔法则)描述稳定系统中平均在途请求数、到达速率和停留时间的关系,可以直观写成:
text
系统内平均并发数 ≈ 到达速率 × 平均停留时间这里的平均值应来自同一系统边界和统计窗口,例如请求每秒到达多少、从进入到离开平均停留多少秒。它有助于理解资源需求,但不能直接用作持续过载时的容量预测。非阻塞实现不一定为每个请求占用一个等待线程,不过仍需容纳在途请求、连接和缓冲数据。
当等待变长、所需并发超过可用资源,而系统仍继续接收请求时,队列就会增长。如果多层共享资源并自动重试,故障可能按以下顺序传播:
图表将在阅读到此处时加载…
增大线程池只能暂时容纳更多等待者,还会增加内存占用、上下文切换,并把更高并发传给下游。真正的治理通常需要组合使用:
- 分层超时与全链路 Deadline(整条请求必须完成的截止时间),避免每层各等一份完整超时;
- 退避重试(失败后逐步延长等待)与抖动(随机分散重试时间),并用 Retry Budget(重试预算)限制额外请求量;
- 并发隔离(为不同依赖划分资源)与有界队列,防止一个慢依赖占满全部处理能力;
- 限流(限制进入的请求量)、熔断(依赖持续异常时暂时停止调用)和业务允许的降级;
- 下游容量评估与过载保护;
- 幂等和结果查询接口。
这些机制并不是为了“保证永不失败”,而是限制失败影响范围,让系统在超出容量时以可预期方式退化。
9. 线上定位:先补齐一条请求的时间账本
遇到“下游 20 ms,上游却 800 ms”,建议先对齐同一个 Trace ID(链路追踪标识)和时间窗口,再分段取证:
| 阶段 | 应关注的证据 |
|---|---|
| 网关入口 | 请求到达时间、路由、状态码、总耗时、上游断开 |
| 客户端连接池 | active、idle、pending、获取连接耗时 |
| RPC 客户端 | 目标实例、序列化耗时、请求超时、重试次数 |
| 服务端入口 | 到达时间、队列等待、业务开始时间 |
| 业务线程池 | 活跃线程、队列长度、拒绝次数、任务耗时 |
| 数据资源 | 数据库连接等待、SQL 耗时、锁等待、Redis 延迟 |
| 响应阶段 | 编码耗时、响应大小、写回失败、客户端是否取消 |
表中的 active、idle、pending 通常分别表示正在使用的连接、空闲连接和等待获取连接的请求;具体含义应以连接池实现为准。不要在没有证据时直接把时间归因于“网络抖动”。网络问题需要通过连接错误、重传、RTT(网络往返时间)、丢包、代理日志或抓包等证据确认。连接池等待、服务端排队和下游锁等待也可能让调用方观察到高延迟。
同时要区分三个时间:
text
客户端观察时间:从发起调用到得到结果/超时
服务端处理时间:从业务开始执行到业务结束
端到端时间:包含两端排队、传输和所有中间代理客户端观察时间的边界也要明确:一次下游调用的耗时,不等于用户请求经过网关和所有依赖的端到端耗时。各节点使用的时钟可能不同,跨机器直接相减日志时间前,应确认时钟同步情况。单进程内测量耗时优先使用单调时钟,例如 Java 的 System.nanoTime();它适合计算时间差,不应当作跨机器对齐的日期时间。
10. 容易踩的坑
10.1 坑:为每层都配置一次重试
客户端重试 2 次、网关重试 2 次、订单服务再重试库存 2 次,最坏请求次数会乘法放大。若“重试 2 次”指首次调用外再尝试两次,每层最多尝试 3 次;在每层都用满次数且没有预算限制的情况下,一次用户请求最多触发 3 × 3 × 3 = 27 次库存调用。重试策略应集中设计,并只对临时错误、幂等操作和剩余预算充足的请求生效。
10.2 坑:超时设置得越长越“稳定”
延长超时可能让部分慢请求完成,但也会让仍无法完成的请求更晚失败,并持续占用线程、连接或内存。超时应结合业务 SLO(服务等级目标,例如延迟和成功率目标)与调用链预算,同时考虑下游正常延迟分布,而不是复制一个统一的 30 秒配置。
10.3 坑:只监控成功率,不监控资源等待
接口可能暂时仍返回成功,但线程池队列、连接池 pending 和 P99 已持续上涨。等成功率下降时,系统往往已经进入过载。资源饱和指标是重要的前置信号。
10.4 坑:异步就等于不影响主流程
如果发送消息仍在同步等待 Broker(负责接收和存储消息的服务节点)确认,它就在关键路径上;如果完全不等确认,又没有可靠的持久化与恢复机制,发送失败可能造成消息丢失。异步消费缩短的是等待业务处理的路径,消息的可靠接收与后续完成仍需分别设计。
10.5 坑:客户端超时后直接认定业务失败
超时代表观察者没有及时获得结果。对有副作用的操作,应配合幂等键、业务状态查询或可靠事件,处理结果未知状态。
10.6 坑:把所有问题归结为“微服务拆得不够好”
服务拆分会增加通信成本,但故障也可能来自错误的超时、无界队列、连接泄漏、不合理查询或缺少容量保护。诊断需要沿真实链路取证,而不是用架构名词代替根因。
11. 进阶:什么时候不应该继续拆服务
拆分通常是为了独立演进、独立扩缩容、隔离组织边界或满足数据与合规要求。它的代价包括:
- 更多网络调用和序列化;
- 更多部署、监控和版本兼容工作;
- 本地事务变成跨服务一致性问题;
- 调试从调用栈变成跨进程证据链;
- 容量规划从单点资源变成整条依赖图。
如果两个模块始终一起变更、一起扩容、共享强事务,并且没有明确团队边界,把它们拆成两个服务可能只是在制造远程调用。模块化单体并不落后;在边界尚不稳定时,它往往更容易保持正确性。
评估是否拆分时,可以问四个问题:
- 是否存在可独立描述的业务能力和数据所有权?
- 是否确实需要独立发布、扩容或故障隔离?
- 跨边界调用失败时,业务能否定义正确的补偿或降级语义?
- 团队是否具备链路追踪、容量治理和自动化运维能力?
如果后两个问题没有答案,过早拆分通常会把代码复杂度转移成运行时复杂度。
12. 总结
服务拆分把进程内调用变成了跨进程协议链路:用户等待多久,取决于必须完成的步骤;故障影响多大,取决于等待占用的资源;操作能否重试,取决于能否确认结果并避免重复副作用。
- 用户耗时由同步关键路径决定,排查时必须包含连接池等待、服务端排队、业务执行与响应写回。
- 超时只表示调用方没等到结果;对有副作用的操作,必须用幂等和状态查询处理 Unknown。
- 服务拆分会放大尾延迟和故障传播,超时、隔离、限流与可观测性必须作为系统设计的一部分。
下一篇:CAP 不是“三选二”口诀:网络分区发生时系统到底怎么选。