Golang的context取消传播 vs Java的CompletableFuture.cancel()：分布式超时治理的11种失效场景复盘

第一章：Golang的context取消传播与Java的CompletableFuture.cancel()核心设计哲学对比

取消语义的本质差异

Go 的 context.Context 将取消视为不可逆的、自上而下的信号广播，一旦父 context 被取消（如调用 cancel()），所有衍生子 context 立即通过 Done() channel 接收关闭信号，并不保证执行清理逻辑；而 Java 的 CompletableFuture.cancel(boolean mayInterruptIfRunning) 则体现协作式中断契约：mayInterruptIfRunning=true 时尝试中断正在执行的线程（依赖 Thread.interrupt() 和任务自身对中断状态的响应），false 时仅拒绝未启动的任务——取消是否生效完全取决于任务实现者是否检查 Thread.currentThread().isInterrupted() 或抛出 InterruptedException。

取消传播机制对比

特性	Go context	Java CompletableFuture
传播方式	基于 channel 关闭的被动监听（无状态）	基于布尔标记 + 显式中断调用（有状态）
清理责任	由用户在 <-ctx.Done() 后手动执行 defer 或 cleanup	由任务代码主动响应中断（无强制钩子）
可组合性	通过 WithCancel/WithTimeout 链式派生，天然支持树形取消传播	thenCompose 等链式操作默认不继承取消，需显式 whenComplete 捕获

典型代码行为验证

// Go：取消后子 context 立即感知，但无自动资源释放
parent, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
child := context.WithValue(parent, "key", "value")
go func() {
    select {
    case <-child.Done():
        fmt.Println("child cancelled:", child.Err()) // 输出：context canceled
    }
}()
time.Sleep(200 * time.Millisecond)

// Java：cancel(true) 发送中断信号，但任务必须主动响应
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // 保留中断状态
        System.out.println("Task interrupted"); // 此行可能执行，也可能被跳过
    }
});
future.cancel(true); // 不阻塞，仅设置状态并中断线程

设计哲学映射

Go 强调控制流的显式性与轻量性：context 是只读信号载体，取消逻辑完全交由业务代码决策何时及如何响应；Java 则延续 JVM 线程模型的契约精神，将取消视为对执行单元的“礼貌请求”，成败取决于双方约定——这导致 Go 的取消更可预测，而 Java 的取消更具弹性但也更易失效。

第二章：超时治理失效的底层机制溯源

2.1 context.WithTimeout的取消链传播模型与goroutine泄漏隐患分析

取消信号的级联传递机制

context.WithTimeout 创建父子上下文，父上下文取消时，子上下文自动接收 Done() 通道关闭信号，形成单向传播链：

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel() // 必须显式调用，否则 timeout 不触发
childCtx, _ := context.WithCancel(ctx) // childCtx 继承父 ctx 的 Done()

逻辑分析：childCtx.Done() 在父 ctx 超时或显式 cancel() 后立即关闭；参数 100ms 是相对起始时间的绝对截止点，非空闲超时。

goroutine 泄漏典型场景

• 未监听 ctx.Done() 的长期 goroutine 持续运行
• defer cancel() 遗漏导致 timer 持有引用无法回收
• 子 context 被闭包捕获但未随父 ctx 生命周期释放

取消传播路径可视化

graph TD
    A[Background] -->|WithTimeout| B[Parent TimeoutCtx]
    B -->|WithCancel| C[Child CancelCtx]
    B -->|timer fires| D[Done closed]
    D --> C

场景	是否泄漏	原因
go func(){ <-ctx.Done() }()	否	主动响应取消
go func(){ time.Sleep(1s) }()	是	完全忽略 ctx

2.2 CompletableFuture.cancel(true)的中断语义模糊性与线程中断失效实证

CompletableFuture.cancel(true) 声称“尝试中断执行任务的线程”，但其行为高度依赖任务提交方式，不保证实际中断发生。

中断失效的典型场景

当任务通过 ForkJoinPool.commonPool() 异步执行时（如 supplyAsync），cancel(true) 仅设置内部中断标志，不会向 ForkJoinWorkerThread 发送真实中断信号——因 ForkJoinTask 不响应 Thread.interrupt()。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(5000); // 阻塞操作
    } catch (InterruptedException e) {
        System.out.println("Interrupted: " + Thread.currentThread().isInterrupted());
        return "interrupted";
    }
    return "done";
});
future.cancel(true); // 此调用几乎总失效

✅ 逻辑分析：supplyAsync 默认使用 ForkJoinPool，其工作线程忽略标准中断；Thread.interrupted() 返回 false，sleep() 也不会抛出异常。参数 true 仅影响 Future 状态标记，不触发底层线程中断。

关键差异对比

提交方式	cancel(true) 是否触发 InterruptedException	是否响应 isInterrupted()
new Thread(r).start()	✅ 是	✅ 是
supplyAsync(r)	❌ 否（ForkJoinTask 无中断感知）	❌ 否

根本原因流程

graph TD
    A[future.cancel(true)] --> B{任务是否封装为 ForkJoinTask？}
    B -->|是| C[调用 task.cancel\(\)]
    B -->|否| D[调用 thread.interrupt\(\)]
    C --> E[仅设置任务取消状态，不中断线程]

2.3 取消信号跨协程/线程边界的可观测性断层与trace缺失场景复现

问题根源：上下文传递断裂

当 ctx.WithCancel 创建的取消信号跨越 goroutine 边界但未显式传播 context.Context，trace 链路即告中断：

func badPropagation() {
    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        // ❌ 缺失 ctx 传递 → span 断开、cancel 不可观测
        time.Sleep(1 * time.Second)
        cancel() // 取消发生，但无 trace 关联
    }()
}

逻辑分析：cancel() 调用脱离原始 trace 上下文，OpenTelemetry SDK 无法关联该事件至父 span；ctx 未传入 goroutine，导致 span context 丢失。参数 context.Background() 无 parent span，进一步加剧链路断裂。

典型断层场景对比

场景	Context 传递	Trace 关联	取消可观测性
显式传 ctx	✅	✅	✅
仅传 cancel func	❌	❌	❌
使用 sync.Once 替代 cancel	❌	❌	⚠️（不可逆）

跨边界 trace 断裂流程

graph TD
    A[main goroutine: StartSpan] --> B[spawn goroutine]
    B --> C{ctx passed?}
    C -- Yes --> D[Child Span linked]
    C -- No --> E[Orphaned cancel event]
    E --> F[Trace missing in Jaeger/OTLP]

2.4 非响应式I/O操作（如net.Conn.Read）对context取消的无视行为及规避方案

根本原因：阻塞式系统调用不感知context

net.Conn.Read 是底层 read(2) 系统调用的封装，而操作系统内核不识别 Go 的 context.Context——它仅在用户态轮询 Done() 通道，无法中断正在执行的阻塞 I/O。

典型风险场景

• 客户端断连后，Read 仍无限期挂起
• ctx.WithTimeout 触发取消，但 goroutine 无法及时退出，导致 goroutine 泄漏

规避方案对比

方案	原理	优点	缺点
SetReadDeadline	利用 socket 层超时机制	零额外 goroutine，内核级中断	需手动管理 deadline，非 cancel-aware
conn.SetReadDeadline(time.Now().Add(...))	动态绑定 context 超时	与 context 生命周期同步	每次 Read 前需重设
runtime.Gosched() + select 轮询	用户态非阻塞模拟	完全 context-aware	高频轮询增加 CPU 开销

// 推荐：基于 deadline 的 context 感知读取
func readWithContext(conn net.Conn, ctx context.Context, buf []byte) (int, error) {
    // 将 context 超时映射为 socket deadline
    if deadline, ok := ctx.Deadline(); ok {
        conn.SetReadDeadline(deadline) // ⚠️ 注意：deadline 仅作用于下一次 Read
    }
    n, err := conn.Read(buf)
    if err == nil {
        return n, nil
    }
    if os.IsTimeout(err) && ctx.Err() != nil {
        return 0, ctx.Err() // 将 timeout 显式转为 context canceled
    }
    return n, err
}

逻辑分析：

• conn.SetReadDeadline 在内核层面触发 EAGAIN 或 ETIMEDOUT，避免 goroutine 阻塞；
• ctx.Deadline() 提供精确截止时间，而非 time.After 手动计算；
• os.IsTimeout(err) 判断是否因 deadline 触发失败，再结合 ctx.Err() 统一返回 cancel 错误，保持语义一致性。

2.5 Java中ForkJoinPool默认线程池拒绝中断导致cancel()静默失败的调试追踪

现象复现

以下代码调用 CompletableFuture.supplyAsync()（底层使用 ForkJoinPool.commonPool()）后尝试取消任务，但 cancel(true) 始终返回 false 且无异常：

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(5000); // 模拟长任务
        return "done";
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // 关键：FJP线程忽略此中断
        return "interrupted";
    }
});
System.out.println(future.cancel(true)); // 输出 false —— 静默失败

逻辑分析：ForkJoinPool 的工作线程默认将 Thread.interrupt() 视为“非协作中断”，不响应 isInterrupted() 检查；cancel(true) 依赖 Thread.interrupt() 生效，但 FJP 线程在 park() 状态下不传播中断标志，导致取消失效。

根本原因

• ForkJoinPool.commonPool() 使用 ForkJoinWorkerThread，其 run() 循环中未检查 Thread.interrupted()；
• Future.cancel(true) 仅调用 Thread.interrupt()，而 FJP 线程不响应标准中断协议。

行为	ThreadPoolExecutor	ForkJoinPool.commonPool()
cancel(true) 成功	✅（中断线程并退出）	❌（返回 false，无效果）
支持 isInterrupted() 检测	✅	⚠️（需手动轮询 Thread.interrupted()）

解决路径

• 显式创建可中断的 ForkJoinPool（设置 asyncMode = true 并重写 onTermination）；
• 改用 Executors.newCachedThreadPool() 或自定义 ThreadPoolExecutor；
• 在任务内部主动轮询 Thread.currentThread().isInterrupted()。

第三章：分布式调用链中取消信号衰减的关键路径

3.1 gRPC-go中context传递丢失的11种中间件拦截陷阱与修复模式

gRPC-go 的 context.Context 是请求生命周期与超时控制的核心载体，但中间件链中极易因不当操作导致其被意外替换或截断。

常见陷阱类型（节选5类）

• ❌ 直接 context.Background() 替换入参 context
• ❌ 在 UnaryServerInterceptor 中未透传 ctx 到 handler
• ❌ 使用 context.WithValue 后未保留原始 Done()/Deadline()
• ❌ 并发 goroutine 中持有并修改上游 context
• ❌ 自定义 grpc.ServerOption 注入非继承 context 的拦截器

典型错误代码示例

func badInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    // 错误：新建 context，丢失 cancel、deadline 等关键信号
    newCtx := context.WithValue(context.Background(), "key", "val") 
    return handler(newCtx, req) // ⚠️ 原始 ctx 的超时/取消已失效
}

逻辑分析：context.Background() 是空根 context，无父级继承关系；WithValue 不应脱离原 context 树。正确做法是 context.WithValue(ctx, key, val)，确保 Done()、Err()、Deadline() 可穿透。

陷阱编号	关键失现场景	修复模式
#3	defer 中调用 cancel	改用 defer func(){...}() 捕获闭包 ctx
#7	middleware 返回新 ctx	必须 return handler(ctx, req) 而非 handler(newCtx, req)

graph TD
    A[Client Request] --> B[Interceptor Chain]
    B --> C{ctx 是否被 replace?}
    C -->|Yes| D[Cancel/Timeout 丢失]
    C -->|No| E[Context 正常透传]

3.2 Spring WebFlux+Reactor中Mono.timeout()与CompletableFuture.cancel()语义冲突案例

核心冲突根源

Mono.timeout() 触发时会调用下游 Subscriber.cancel()，而 CompletableFuture.cancel(true) 试图中断正在执行的线程（需配合 Thread.interrupt()），但 Reactor 的调度器线程通常不响应中断——导致超时后任务仍在运行。

典型错误示例

Mono.fromFuture(
    CompletableFuture.supplyAsync(() -> {
        Thread.sleep(5000); // 模拟阻塞操作
        return "done";
    })
).timeout(Duration.ofMillis(100))
.subscribeOn(Schedulers.boundedElastic())
.block(); // 抛出 TimeoutException，但 sleep 仍继续执行

逻辑分析：timeout() 发射错误并触发 cancel()，但 CompletableFuture 的 cancel 仅标记状态，无法终止 sleep()；boundedElastic 线程未被中断，资源泄漏风险隐现。

语义对比表

行为	Mono.timeout()	CompletableFuture.cancel(true)
取消时机	信号链中断	异步状态标记 + 尝试中断线程
实际线程终止能力	❌（无中断）	⚠️（依赖任务可中断性）

安全替代方案

• 使用 Mono.delayElement() + Mono.usingWhen() 管理资源
• 将阻塞调用封装为 Mono.fromCallable().subscribeOn(Schedulers.boundedElastic()) 并显式检查 Thread.interrupted()

3.3 跨语言gRPC网关（如Envoy）对CancelHeader的透传缺失与上下文污染实测

复现环境配置

使用 Envoy v1.28 作为 gRPC JSON transcoding 网关，上游为 Go gRPC server（grpc-go v1.60），客户端发起带 grpc-status: 1 + grpc-message 的 Cancel 请求。

关键缺失行为

Envoy 默认不透传 grpc-encoding、grpc-encoding 及 grpc-status 等控制头，且将 grpc-status 错误码映射为 HTTP 503，导致下游无法区分 CANCELLED（1）与 UNAVAILABLE（14）。

实测响应头对比

Header	客户端直连 gRPC	经 Envoy 网关
grpc-status	1	❌ 丢失
grpc-message	context canceled	❌ 丢失
x-envoy-upstream-service-time	—	✅ 存在

请求拦截代码片段（Envoy Lua filter）

function envoy_on_request(request_handle)
  -- 检测原始 Cancel 请求头（需启用 allow_unescaped_slashes）
  local status = request_handle:headers():get("grpc-status")
  if status == "1" then
    request_handle:logInfo("Detected CANCELLED, injecting context hint")
    request_handle:headers():add("x-grpc-cancel-detected", "true")
  end
end

此 Lua filter 在请求阶段捕获 grpc-status，但仅限于 HTTP/1.1 升级通道；gRPC-Web over HTTP/2 流中该头根本未解包，暴露 Envoy 的 header 解析边界。

上下文污染路径

graph TD
  A[Client Cancel] --> B[Envoy HTTP/2 decode]
  B --> C{Is grpc-status in headers?}
  C -->|No| D[Drop & map to 503]
  C -->|Yes| E[Forward as custom header]
  D --> F[Go server sees no cancellation signal]
  F --> G[goroutine leak]

第四章：工程化超时治理的防御性实践体系

4.1 Go服务中基于context.WithCancel + channel select的双保险超时兜底模式

在高并发微服务场景中，单一超时机制易因 goroutine 泄漏或 channel 阻塞失效。双保险模式通过 context.WithCancel 主动终止 + select 非阻塞判据，实现双重防护。

核心设计逻辑

• context.WithCancel 提供可主动取消的生命周期控制
• select 中并置 ctx.Done() 与业务 channel，确保任一路径触发即退出
• 即使下游 channel 永不就绪，context 超时仍强制退出

典型实现代码

func fetchDataWithDoubleTimeout(ctx context.Context, timeout time.Duration) (string, error) {
    // 创建带超时的子 context（第一道保险）
    ctx, cancel := context.WithTimeout(ctx, timeout)
    defer cancel()

    resultCh := make(chan string, 1)
    go func() {
        // 模拟异步调用
        time.Sleep(3 * timeout) // 故意超时
        resultCh <- "data"
    }()

    // select 双路监听（第二道保险）
    select {
    case result := <-resultCh:
        return result, nil
    case <-ctx.Done():
        return "", ctx.Err() // 优先响应 context 取消
    }
}

逻辑分析：context.WithTimeout 确保 goroutine 在 timeout 后自动触发 cancel()；select 中 ctx.Done() 通道永远可读（一旦超时即就绪），因此必先于阻塞的 resultCh 被选中，杜绝泄漏。参数 timeout 是全局兜底阈值，建议设为 P99 延迟 + 缓冲余量。

机制	触发条件	响应行为
context 超时	定时器到期	自动关闭 Done 通道
channel select	任一 case 就绪	立即执行对应分支

graph TD
    A[启动协程] --> B[启动定时器]
    A --> C[写入 resultCh]
    B --> D{ctx.Done()?}
    C --> E{resultCh 可读?}
    D -->|是| F[返回 ctx.Err]
    E -->|是| G[返回结果]
    D & E --> H[select 二选一]

4.2 Java中CompletableFuture.orTimeout()与Thread.interrupt()协同的强制终止协议

orTimeout() 本身不中断执行线程，仅对 CompletableFuture 的完成状态施加超时约束；真正实现强制终止需与 Thread.interrupt() 显式协同。

中断感知的任务封装

需确保异步任务响应中断信号：

CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(5000); // 模拟阻塞操作
        return "done";
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // 恢复中断状态
        throw new RuntimeException("Task interrupted", e);
    }
}).orTimeout(1, TimeUnit.SECONDS)
  .exceptionally(t -> "fallback");

逻辑分析：orTimeout(1s) 在 1 秒后将 CompletableFuture 置为 TimeoutException，但原线程仍在 sleep；只有任务内部检查 isInterrupted() 或响应 InterruptedException，才能提前退出。此处 sleep() 主动抛出异常并传播中断，形成闭环。

协同终止关键点

• ✅ 任务必须是可中断的（如 BlockingQueue.take()、Thread.sleep()）
• ✅ orTimeout() 触发后需主动调用 future.cancel(true)（但默认不生效，需任务配合）
• ❌ orTimeout() 不等价于 future.orTimeout(...).cancel(true) —— 后者无默认中断传播

机制	是否触发中断	是否终止线程	依赖任务实现
orTimeout()	否	否	否
future.cancel(true)	是（若未完成）	是（仅当任务响应）	是
Thread.interrupt()	是	条件性	必须

4.3 分布式链路中Cancel Token一致性注入（OpenTelemetry Context Propagation）落地指南

在跨服务调用中，Cancel Token需随OpenTelemetry上下文透传，确保超时/中断信号全局生效。

核心实现机制

OpenTelemetry SDK不原生支持CancellationToken传播，需通过Context.Key自定义注入：

// 定义可传播的取消令牌键
public static readonly ContextKey<CancellationToken> CancellationTokenKey 
    = ContextKey<CancellationToken>.Create("cancellation-token");

// 在入口处将Token绑定到Context
var context = Context.Current.With(CancellationTokenKey, cancellationToken);
// 通过Propagators注入HTTP Header（如ot-baggage）

逻辑分析：ContextKey为强类型上下文槽位；With()创建新上下文副本，避免污染原始链路；需配合自定义TextMapPropagator序列化ot-cancel-id头字段。

关键传播策略对比

方式	适用场景	是否支持跨进程	需要SDK扩展
Baggage + 自定义Header	HTTP/gRPC	✅	✅
Activity.Tags	进程内	❌	❌
.NET 6+ AsyncLocal	同线程延续	⚠️（不跨Task）	❌

流程示意

graph TD
    A[Client发起请求] --> B[注入CancellationToken到OTel Context]
    B --> C[序列化为ot-cancel-token header]
    C --> D[Service接收并反序列化Token]
    D --> E[绑定至下游异步操作]

4.4 基于eBPF的超时事件内核级观测与cancel信号丢包定位方法论

核心观测锚点设计

在 tcp_retransmit_timer 和 sk->sk_timer.function 执行路径注入 eBPF tracepoint，捕获超时触发时刻、socket 状态及 sk->sk_wq 队列长度。

cancel信号丢包诊断流程

• 拦截 sock_def_readable 中 wake_up() 调用，标记 cancel 信号发出
• 在 ep_poll_callback 中校验对应 epitem 是否已注册且未被移除
• 比对 ep_remove() 调用栈与 ep_poll_callback 时间戳差值

// bpf_prog.c：捕获 cancel 信号发出前的最后状态
SEC("tracepoint/sock/inet_sock_set_state")
int trace_sock_state(struct trace_event_raw_inet_sock_set_state *ctx) {
    if (ctx->state == TCP_CLOSE_WAIT && ctx->op == 1) { // op=1 表示主动关闭
        bpf_map_update_elem(&cancel_traces, &ctx->skaddr, &ctx->now, BPF_ANY);
    }
    return 0;
}

ctx->skaddr 为 socket 地址哈希键；ctx->now 使用 bpf_ktime_get_ns() 获取纳秒级时间戳，用于后续与 ep_poll_callback 时间对齐分析。

关键指标映射表

信号阶段	观测点	丢包诱因线索
发出	wake_up_interruptible	sk->sk_sleep 为空
投递	ep_poll_callback	epi->nwait 为 0
处理	ep_item_poll	epi->ffd.file 已释放

graph TD
    A[超时触发] --> B{cancel信号发出？}
    B -->|是| C[检查epitem存活状态]
    B -->|否| D[定位sk_wq阻塞点]
    C --> E[对比ep_remove与callback时间差]
    E --> F[>50μs → 队列竞争丢包]

第五章：面向云原生时代的超时治理范式演进

从单体架构的硬编码超时到声明式策略驱动

在早期Spring Boot单体应用中，HTTP调用超时常通过RestTemplate的setConnectTimeout(3000)和setReadTimeout(5000)硬编码设定。某电商订单服务在2021年大促期间因第三方物流接口响应突增至8秒，导致线程池耗尽、雪崩。事后回溯发现，全链路37个HTTP客户端配置分散在12个模块中，无统一治理入口。云原生时代转向Service Mesh后，Istio 1.18通过VirtualService声明式定义超时策略：

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
spec:
  http:
  - timeout: 3s
    retries:
      attempts: 2
      perTryTimeout: 1.5s

超时预算（Timeout Budget）的精细化建模

某金融级支付网关采用SLO驱动的超时预算模型：核心交易链路P99延迟目标为200ms，其中数据库占60ms、缓存占30ms、下游风控服务预留80ms。通过OpenTelemetry采集各Span的http.duration指标，结合Prometheus计算rate(http_client_duration_seconds_bucket{le="0.08"}[1h])，当连续5分钟低于99.5%阈值时自动触发告警并降级至备用风控通道。该策略使2023年双11期间支付成功率提升至99.992%，较旧版提升0.37个百分点。

多层级熔断与超时协同机制

组件层	超时阈值	熔断条件	恢复策略
API网关	1.2s	5分钟内错误率>50%	半开状态，每10秒试探1次
Sidecar代理	800ms	连续3次请求超时	指数退避重试
应用服务内	300ms	线程池队列积压>200	触发Hystrix fallback

某视频平台在直播打赏场景中，将Redis集群超时从默认5s降至400ms，并配置redisson.client.setRetryAttempts(0)禁用重试——避免因网络抖动引发的“超时放大效应”。实际观测显示，单节点故障时错误率下降62%，用户打赏失败感知时间缩短至1.3秒内。

动态超时决策引擎的落地实践

某跨境物流系统构建基于Envoy WASM的动态超时引擎：实时读取Kafka中的地域延迟热力图（如东南亚区域P95延迟达1.8s），通过gRPC调用决策服务返回{"timeout_ms": 2200, "max_retries": 1}。该引擎上线后，印尼用户下单超时率从12.7%降至3.1%，且无需重启任何服务实例。关键代码片段如下：

#[no_mangle]
pub extern "C" fn on_http_call_response(
    _context_id: u32,
    _plugin_id: u32,
    _response_headers: *const HeaderMap,
) -> Status {
    let latency = get_current_region_latency();
    set_timeout_ms(latency as u32 + 200); // 基线+缓冲
    Status::Ok
}

混沌工程验证超时策略韧性

使用Chaos Mesh注入网络延迟故障：对订单服务Pod执行kubectl apply -f chaos-delay.yaml，模拟300ms~2s随机延迟。观测发现，未启用超时预算的服务出现17%请求堆积，而采用Timeout Budget的服务自动触发降级逻辑，将非核心字段查询超时从2s放宽至5s，保障主流程可用性。Mermaid流程图展示该决策路径：

graph TD
    A[请求到达] --> B{是否命中SLA？}
    B -->|是| C[正常处理]
    B -->|否| D[启动超时预算评估]
    D --> E[检查各子服务预算余量]
    E -->|充足| F[延长非关键路径超时]
    E -->|不足| G[触发预设fallback]
    F --> H[返回降级结果]
    G --> H