Go信号处理默写生死关：syscall.SIGTERM捕获、graceful shutdown等待链、context.WithTimeout嵌套深度——K8s滚动更新必考

第一章：Go信号处理默写生死关：syscall.SIGTERM捕获、graceful shutdown等待链、context.WithTimeout嵌套深度——K8s滚动更新必考

在 Kubernetes 环境中，Pod 被滚动更新或缩容时，会向容器主进程发送 SIGTERM 信号，要求其在默认 30 秒（由 terminationGracePeriodSeconds 控制）内完成优雅退出。若未正确捕获并响应该信号，进程将被强制 SIGKILL 终止，导致连接中断、数据丢失或事务不一致。

SIGTERM 捕获与信号通道初始化

使用 signal.Notify 将 syscall.SIGTERM 和 syscall.SIGINT 注入通道，避免阻塞主线程：

sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)

该通道必须在服务启动前注册，且仅注册一次——重复调用 signal.Notify 会覆盖前序注册，造成信号丢失。

Graceful Shutdown 等待链构建

优雅关闭需按依赖顺序反向终止：先停止接收新请求（如关闭 HTTP server 的 Listener），再等待活跃连接完成（srv.Shutdown(ctx)），最后释放数据库连接池、消息队列消费者等资源。关键在于所有子任务必须可被同一 context.Context 取消：

// 启动 HTTP server 并监听退出信号
go func() {
    <-sigChan
    log.Println("Received SIGTERM, starting graceful shutdown...")
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()
    if err := srv.Shutdown(shutdownCtx); err != nil {
        log.Printf("HTTP server shutdown error: %v", err)
    }
}()

context.WithTimeout 嵌套深度陷阱

避免在 Shutdown 内部再次调用 context.WithTimeout 创建子 Context——这会形成嵌套超时，导致实际等待时间被最内层 timeout 截断。例如：

错误写法	正确写法
innerCtx, _ := context.WithTimeout(ctx, 5*time.Second) inside Shutdown	复用传入的 ctx，不新建 timeout

务必确保：所有子任务共享同一个 shutdownCtx，且其 deadline 由上层统一控制。K8s 的 terminationGracePeriodSeconds 是最终兜底时限，应用层 timeout 必须严格小于它（建议 ≤20s），为 kubelet 留出清理余量。

第二章：syscall.SIGTERM信号捕获与阻塞式监听机制默写

2.1 SIGTERM信号语义与POSIX标准在Go运行时的映射实现

POSIX.1-2017 定义 SIGTERM 为“请求终止进程”的标准信号，不强制立即退出，而是赋予进程执行清理的机会。Go 运行时通过 signal.Notify 将其映射为可捕获的 Go 事件，并交由 runtime.sigsend 统一调度。

信号注册与转发路径

// 注册 SIGTERM 捕获通道
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGTERM)

• os.Signal 是 syscall.Signal 的别名，底层直接对应 int 常量（如 syscall.SIGTERM == 15）
• signal.Notify 调用 sigignore 和 sigmask 系统调用，确保信号不被忽略且可被 runtime 处理

Go 运行时信号处理流程

graph TD
    A[内核发送 SIGTERM] --> B[Go signal handler 入口]
    B --> C[runtime.sigtramp：保存上下文]
    C --> D[runtime.doSigNotify：写入 sigNote]
    D --> E[main goroutine 从 sigChan 接收]

POSIX 行为	Go 运行时实现
可被阻塞/忽略	signal.Ignore / sigprocmask
默认终止进程	若未注册，runtime.sigterm 调用 exit(143)
可重入安全	sigNote 使用原子写入保证并发安全

2.2 signal.Notify + signal.Ignore 的双模式信号路由默写（含竞态规避）

Go 程序需在不同生命周期阶段对同一信号采取隔离响应策略：启动时忽略 SIGUSR1，运行中转为监听并触发热重载，退出前再次忽略以避免干扰清理逻辑。

双模式切换语义

• signal.Ignore：彻底屏蔽信号，内核不递送至进程
• signal.Notify：将信号转发至 channel，由用户协程消费
• 关键约束：二者不可并发调用同一信号，否则触发 panic

竞态规避方案

var mu sync.RWMutex
var sigCh = make(chan os.Signal, 1)

func setMode(mode string) {
    mu.Lock()
    defer mu.Unlock()
    signal.Stop(sigCh) // 清空前注册
    switch mode {
    case "ignore":
        signal.Ignore(syscall.SIGUSR1)
    case "notify":
        signal.Notify(sigCh, syscall.SIGUSR1)
    }
}

signal.Stop 是线程安全的注销操作；mu 保证 Ignore/Notify 不重入；channel 缓冲区设为 1 防止信号丢失。

模式	信号递送路径	典型用途
notify	kernel → channel → goroutine	动态配置更新
ignore	kernel → 丢弃	启动/退出临界区

graph TD
    A[收到 SIGUSR1] --> B{当前模式？}
    B -->|notify| C[投递到 sigCh]
    B -->|ignore| D[内核直接丢弃]
    C --> E[goroutine 处理热重载]

2.3 os.Signal通道的阻塞接收与goroutine生命周期绑定默写

信号通道的初始化语义

os.Signal 通道需显式通过 signal.Notify() 绑定，否则为 nil —— 直接接收将永久阻塞（deadlock）。

阻塞接收的典型模式

sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
<-sigChan // 阻塞等待首个信号

• make(chan os.Signal, 1)：带缓冲通道，避免信号丢失；容量为 1 是因多数场景仅需响应首次中断。
• signal.Notify(...)：将指定信号转发至该通道；若未调用，<-sigChan 永不返回。

goroutine 生命周期绑定机制

绑定方式	生命周期终止条件	风险
匿名 goroutine	信号接收后立即退出	无法优雅清理
带 cancel context	主动 close channel + wait	推荐：可协调退出

graph TD
    A[main goroutine] --> B[启动 signal handler goroutine]
    B --> C[阻塞接收 sigChan]
    C --> D{收到 SIGTERM?}
    D -->|是| E[执行 cleanup]
    D -->|否| C
    E --> F[关闭资源/退出]

2.4 多信号并行捕获（SIGTERM/SIGINT）与优先级降级策略默写

当服务需兼顾优雅终止与快速响应时，需同时监听 SIGTERM（系统管理终止）与 SIGINT（用户中断，如 Ctrl+C），但二者语义不同：前者要求完整事务收尾，后者允许加速降级。

信号语义与响应优先级

• SIGTERM → 触发「软降级」：关闭新连接、等待活跃请求 ≤30s
• SIGINT → 触发「硬降级」：立即拒绝新请求，5s 内强制终止残留工作

降级策略执行流程

import signal, time
from enum import Enum

class DegradationLevel(Enum):
    NORMAL = 0
    SOFT = 1   # SIGTERM → graceful drain
    HARD = 2   # SIGINT  → immediate reject

degrade = DegradationLevel.NORMAL

def handle_signal(signum, frame):
    global degrade
    if signum == signal.SIGTERM:
        degrade = DegradationLevel.SOFT
        print("→ Received SIGTERM: entering soft degradation")
    elif signum == signal.SIGINT:
        degrade = DegradationLevel.HARD
        print("→ Received SIGINT: enforcing hard degradation")

signal.signal(signal.SIGTERM, handle_signal)
signal.signal(signal.SIGINT,  handle_signal)

逻辑分析：注册双信号处理器，通过共享枚举变量 degrade 统一控制下游行为。frame 参数未使用但必须保留（符合 POSIX 信号处理函数签名）。signal.signal() 是原子操作，避免竞态。

信号类型	默认超时	新连接处理	活跃请求处置
SIGTERM	30s	拒绝	等待自然完成
SIGINT	5s	立即拒绝	强制中断

graph TD
    A[收到信号] --> B{信号类型？}
    B -->|SIGTERM| C[设 degrade=SOFT]
    B -->|SIGINT| D[设 degrade=HARD]
    C --> E[启动 drain 计时器]
    D --> F[立即标记 shutdown]

2.5 信号监听goroutine的启动时机与init/main边界约束默写

信号监听 goroutine 必须在 main() 函数进入主逻辑前启动，且严禁在 init() 中启动——因 init() 阶段 runtime 尚未完成调度器初始化，signal.Notify 可能触发 panic 或静默失效。

启动时序铁律

• ✅ 正确：main() 开头、flag.Parse() 后立即 go signalHandler()
• ❌ 禁止：init() 中调用 go signal.Notify(...)
• ⚠️ 危险：在 main() 中延迟启动（如嵌套于 http.ListenAndServe 后），将丢失早期 SIGTERM/SIGHUP

典型安全启动模式

func main() {
    flag.Parse()
    // 启动信号监听 goroutine —— 此刻 runtime 已就绪
    go func() {
        sigs := make(chan os.Signal, 1)
        signal.Notify(sigs, syscall.SIGTERM, syscall.SIGINT)
        <-sigs // 阻塞等待首个信号
        gracefulShutdown()
    }()
    // ... 启动业务逻辑（如 HTTP server）
}

逻辑分析：make(chan os.Signal, 1) 创建带缓冲通道避免信号丢失；signal.Notify 绑定后，goroutine 立即阻塞于 <-sigs，确保零信号漏收。缓冲大小为 1 是最小安全值，防止并发多信号覆盖。

约束类型	init() 中	main() 开头	main() 深层调用
调度器可用	❌ 未就绪	✅ 已就绪	✅ 已就绪
signal.Notify 安全	❌ 不可靠	✅ 推荐	✅ 可接受
优雅退出可控性	❌ 无法注册	✅ 显式控制	⚠️ 依赖调用链

graph TD
    A[程序启动] --> B[执行所有 init 函数]
    B --> C[main 函数入口]
    C --> D{runtime 初始化完成？}
    D -->|否| E[panic 或未定义行为]
    D -->|是| F[启动 signal 监听 goroutine]
    F --> G[注册 os.Signal channel]
    G --> H[阻塞等待信号]

第三章：Graceful Shutdown等待链构建默写

3.1 HTTP Server Shutdown方法调用链与连接 draining 状态机默写

HTTP Server 的优雅关闭（graceful shutdown）核心在于 shutdown() → closeIdleConns() → drain() → state transition 的调用链。

关键状态机阶段

• Active：接收新请求，保持活跃连接
• Draining：拒绝新请求，等待现有请求完成（Server.SetKeepAlivesEnabled(false) + closeIdleConns()）
• Closed：所有连接终止，监听器关闭

调用链示例（Go net/http）

// server.Shutdown(ctx) 启动 draining 流程
func (srv *Server) Shutdown(ctx context.Context) error {
    srv.mu.Lock()
    defer srv.mu.Unlock()
    srv.closeDone = make(chan struct{})
    // 触发连接 draining：禁用 keep-alive 并通知空闲连接退出
    srv.setKeepAlivesEnabled(false) // ← 关键：响应头加 Connection: close
    srv.idleConnCh <- struct{}{}    // 唤醒 idleConnTimeout goroutine
    return srv.waitOnClosures(ctx)
}

setKeepAlivesEnabled(false) 强制后续响应添加 Connection: close，客户端收到后主动断连；idleConnCh 信号促使空闲连接立即关闭，加速进入 Draining 状态。

状态迁移表

当前状态	触发动作	下一状态	条件
Active	Shutdown(ctx)	Draining	srv.setKeepAlivesEnabled(false) 执行完成
Draining	所有 conn.Close() 完成	Closed	srv.waitOnClosures() 返回

graph TD
    A[Active] -->|Shutdown called| B[Draining]
    B -->|All connections closed| C[Closed]
    B -->|Timeout exceeded| C

3.2 自定义资源清理函数注册顺序与逆序执行栈默写

资源清理函数的注册顺序直接决定其执行时的出栈顺序——后注册者先执行，形成典型的 LIFO 栈语义。

执行栈模型示意

// 注册顺序：A → B → C
register_cleanup(A); // 入栈底
register_cleanup(B); // 中间
register_cleanup(C); // 栈顶（最后注册）
// 实际执行顺序：C → B → A（逆序弹出）

register_cleanup() 将函数指针压入全局 cleanup_stack；运行时按 pop() 顺序调用，确保子资源先于父资源释放。

清理函数注册约束

• 函数签名必须为 void (*)(void*)
• 参数由注册时传入，用于携带上下文（如文件描述符、句柄）
• 不可递归调用 register_cleanup()（避免栈溢出）

阶段	行为	安全性要求
注册期	指针入栈	线程安全（需锁）
执行期	逆序调用并清栈	不可重入、无异常

graph TD
    A[注册A] --> B[注册B]
    B --> C[注册C]
    C --> D[执行C]
    D --> E[执行B]
    E --> F[执行A]

3.3 WaitGroup驱动的多组件协同退出等待链默写

在分布式服务中，组件间需有序终止。sync.WaitGroup 构建轻量级退出等待链，避免竞态与资源泄漏。

数据同步机制

核心逻辑：每个子组件注册自身生命周期钩子，并调用 wg.Add(1)；退出时调用 wg.Done()；主控方阻塞于 wg.Wait()。

var wg sync.WaitGroup

func startComponent(name string, stopCh <-chan struct{}) {
    wg.Add(1)
    go func() {
        defer wg.Done() // 确保无论何种路径均计数减一
        <-stopCh        // 模拟组件运行直至收到停止信号
        log.Printf("component %s exited", name)
    }()
}

wg.Add(1) 必须在 goroutine 启动前调用，防止 wg.Wait() 提前返回；defer wg.Done() 保障异常退出仍可通知等待方。

等待链拓扑结构

角色	职责
主协调器	初始化 WaitGroup，广播 stopCh
组件A/B/C	监听 stopCh，执行清理后 Done

graph TD
    Coordinator -->|broadcast stopCh| A
    Coordinator -->|broadcast stopCh| B
    Coordinator -->|broadcast stopCh| C
    A -->|wg.Done| WaitGroup
    B -->|wg.Done| WaitGroup
    C -->|wg.Done| WaitGroup
    WaitGroup -->|wg.Wait blocks until all done| Coordinator

第四章：context.WithTimeout嵌套深度控制与超时传播默写

4.1 context.WithTimeout父Context传递与cancel函数泄漏防护默写

父Context传递的隐式约束

context.WithTimeout(parent, d) 要求 parent != nil，否则 panic；且子 Context 的生命周期严格受父 Context 控制——若父 Context 已 cancel，子 Context 立即失效，d 计时器不再启动。

cancel 函数泄漏的典型场景

• 忘记调用 cancel() → goroutine 持有 context.Context 引用，阻止 GC
• 多次调用同一 cancel → panic（context: double cancel）
• 在 defer 中误传未捕获的 cancel 变量（闭包陷阱）

安全实践对照表

风险行为	安全写法
cancel := WithTimeout(...)	ctx, cancel := WithTimeout(...)
defer cancel()（无参数）	defer func() { cancel() }()

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel() // ✅ 正确：显式、单次、及时释放
select {
case <-time.After(3 * time.Second):
    fmt.Println("done")
case <-ctx.Done():
    fmt.Println("timeout:", ctx.Err()) // timeout: context deadline exceeded
}

逻辑分析：WithTimeout 返回新 ctx 和 cancel 函数；cancel() 清理内部 timer 并关闭 ctx.Done() channel。若省略 defer cancel()，timer 持续运行并阻塞 GC，造成资源泄漏。参数 d=5s 是相对当前时间的绝对截止点，非重置计时器。

graph TD
    A[context.Background] -->|WithTimeout| B[ctx with timer]
    B --> C{timer fired?}
    C -->|Yes| D[close Done channel]
    C -->|No & parent canceled| E[close Done immediately]
    D --> F[ctx.Err() == DeadlineExceeded]
    E --> G[ctx.Err() == Canceled]

4.2 深度嵌套场景下Deadline传播失效的典型错误模式默写

数据同步机制

当 gRPC 客户端调用链深度超过三层（如 A→B→C→D），context.WithDeadline 创建的截止时间在中间节点未显式传递时，下游服务将继承父 context 的 Background 或 TODO，导致 deadline 丢失。

典型错误代码

func handleC(ctx context.Context, req *pb.Request) (*pb.Response, error) {
    // ❌ 错误：未将 ctx 传入下游调用
    childCtx := context.WithTimeout(context.Background(), 5*time.Second) // 覆盖原 deadline
    return callD(childCtx, req) // 原始 deadline 彻底丢失
}

逻辑分析：context.Background() 切断了 deadline 继承链；5*time.Second 是硬编码值，与上游 ctx.Deadline() 无关，无法实现端到端超时对齐。

失效模式对比

场景	是否继承上游 Deadline	后果
正确传递 ctx	✅	超时级联取消
使用 context.Background()	❌	deadline 彻底丢失
重设固定 timeout	❌	无法响应上游动态 deadline

传播中断流程

graph TD
    A[A: WithDeadline] --> B[B: 忘记传 ctx]
    B --> C[C: context.Background]
    C --> D[D: deadline = ∞]

4.3 K8s preStop hook中context超时与Pod Termination Grace Period对齐默写

preStop hook 的执行生命周期严格受 Pod 的 terminationGracePeriodSeconds 约束。若 hook 中使用 context.WithTimeout，其超时值必须 ≤ grace period，否则将被强制截断。

context 超时设置陷阱

lifecycle:
  preStop:
    exec:
      command: ["/bin/sh", "-c", "sleep 30"]

⚠️ 若 terminationGracePeriodSeconds: 10，该 sleep 实际仅执行约 10 秒即被 SIGTERM 强制终止。

正确对齐实践

func handlePreStop(ctx context.Context) {
    // 从父 context 继承剩余宽限期（非硬编码！）
    deadline, ok := ctx.Deadline()
    if ok {
        timeout := time.Until(deadline)
        childCtx, cancel := context.WithTimeout(context.Background(), timeout)
        defer cancel()
        // 执行优雅关闭逻辑...
    }
}

✅ 利用 ctx.Deadline() 动态推导剩余时间，避免超时冲突。

关键对齐策略对比

策略	安全性	可维护性	是否推荐
硬编码 WithTimeout(5s)	❌ 易超限	❌ 需同步修改 spec	否
ctx.Deadline() 动态计算	✅ 自动对齐	✅ 无需人工干预	✅

graph TD A[Pod 接收 SIGTERM] –> B[启动 terminationGracePeriodSeconds 倒计时] B –> C[触发 preStop hook] C –> D[hook 内获取 ctx.Deadline()] D –> E[派生 childCtx with dynamic timeout] E –> F[安全完成清理或被系统强制终止]

4.4 超时链路中断时的panic recovery与error wrap规范默写

panic recovery 的边界守卫

Go 中禁止在 http.Handler 或 grpc.UnaryServerInterceptor 中任由网络超时 panic 向上逃逸。必须用 recover() 捕获并转为结构化错误：

func withRecovery(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if p := recover(); p != nil {
                // 仅捕获预期 panic（如 context.DeadlineExceeded 触发的显式 panic）
                err := fmt.Errorf("link timeout panic: %v", p)
                http.Error(w, err.Error(), http.StatusGatewayTimeout)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

逻辑分析：recover() 必须紧邻 defer 声明，且仅处理链路超时类 panic；http.StatusGatewayTimeout 明确语义，避免与 500 Internal Server Error 混淆。

error wrap 的三层契约

• 底层：fmt.Errorf("read header: %w", io.ErrUnexpectedEOF) —— 使用 %w 保留原始 error 链
• 中间：errors.Join(err1, err2) 用于并发子任务聚合失败
• 上层：xerrors.Errorf("sync failed: %w", err)（兼容 Go 1.13+）

标准错误包装层级对照表

层级	场景	推荐包装方式
L1	底层 I/O 超时	fmt.Errorf("read: %w", ctx.Err())
L2	业务链路熔断	fmt.Errorf("upstream link broken: %w", err)
L3	API 响应封装	&APIError{Code: 503, Msg: err.Error()}

graph TD
    A[context.DeadlineExceeded] --> B[底层 read/write panic]
    B --> C[recover + fmt.Errorf %w]
    C --> D[中间层链路语义增强]
    D --> E[APIError 结构体序列化]

第五章：K8s滚动更新场景下的信号-上下文-等待三重契约验证

在真实生产环境中，滚动更新失败往往并非源于镜像拉取或资源不足，而是因应用层未正确响应 Kubernetes 的生命周期信号，导致新旧 Pod 间出现请求丢失、连接中断或数据不一致。本章基于某金融支付网关的灰度升级事故复盘，深入验证信号（SIGTERM）、上下文（Context）、等待（Graceful Shutdown Duration）三者必须严格对齐的契约关系。

应用层信号捕获的典型缺陷

某次 v2.3.1 升级中，Java Spring Boot 应用虽配置了 server.shutdown=graceful，但未监听 SIGTERM——其 JVM 进程收到终止信号后直接退出，未触发 SmartLifecycle.stop() 回调。日志显示：Received SIGTERM, but no shutdown hook registered。此时，即使设置了 terminationGracePeriodSeconds: 30，实际优雅关闭耗时仅 120ms，大量进行中的支付确认请求被静默丢弃。

Context 超时与 Pod 状态迁移的竞态条件

该网关使用 context.WithTimeout(ctx, 25*time.Second) 控制 HTTP Server 关闭流程。但 Kubernetes 的 preStop hook 中执行 sleep 5 后才调用 /actuator/shutdown，导致整体关闭窗口被压缩至 25 秒内。当并发请求堆积时，Context 提前取消，http.Server.Shutdown() 返回 context.DeadlineExceeded，而 Pod 已被 kubelet 标记为 Terminating 并从 Endpoints 移除，但部分连接仍在传输层维持（TIME_WAIT 状态），造成客户端超时重试风暴。

滚动更新过程中的三重契约校验表

契约要素	配置位置	实际值	是否匹配	风险表现
SIGTERM 响应延迟	应用代码 signal.Notify(ch, syscall.SIGTERM)	≤ 100ms	✅	无延迟捕获
Context 超时阈值	http.Server.Shutdown() 传入 context	28s	❌（应 ≤ terminationGracePeriodSeconds – preStop 耗时）	连接强制中断
Grace Period 总时长	Deployment spec.template.spec.terminationGracePeriodSeconds	30s	✅	充足缓冲
preStop 执行耗时	lifecycle.preStop.exec.command: ["sh", "-c", "sleep 5 && curl -X POST http://localhost:8080/actuator/shutdown"]	5.2s	✅	可控延迟

Mermaid 流程图：滚动更新期间的信号流与状态跃迁

flowchart TD
    A[RollingUpdate 开始] --> B[新 Pod Ready]
    B --> C[旧 Pod 收到 SIGTERM]
    C --> D{应用是否注册 SIGTERM handler?}
    D -->|是| E[启动 graceful shutdown]
    D -->|否| F[立即 kill 进程 → 请求丢失]
    E --> G[Context.WithTimeout 28s 启动]
    G --> H[preStop sleep 5s + shutdown API 调用]
    H --> I{Context 是否超时?}
    I -->|否| J[Server.Shutdown() 完成 → Pod 终止]
    I -->|是| K[强制关闭 listener → 连接重置]
    J --> L[Endpoint 移除完成]

生产环境验证脚本片段

通过 kubectl debug 注入临时容器，实时观测滚动更新期间的信号接收与上下文状态：

# 在旧 Pod 内执行，捕获 SIGTERM 到 shutdown 完成的精确耗时
kubectl exec payment-gateway-7f9b4d5c8-2xk9p -- sh -c '
  echo "Starting signal watch..." > /tmp/shutdown.log
  trap "echo \$(date +%s.%N) SIGTERM_RECEIVED >> /tmp/shutdown.log; \
        timeout 30s bash -c \"while kill -0 1 2>/dev/null; do sleep 0.1; done; \
        echo \$(date +%s.%N) SHUTDOWN_COMPLETE >> /tmp/shutdown.log\" & \
        wait" TERM
  sleep infinity
'

验证结果：三重契约失配的量化影响

在 1000 QPS 压测下，当 Context 超时设为 28s（terminationGracePeriodSeconds=30s，preStop=5s），平均请求失败率 0.03%；若 Context 设为 30s，则失败率升至 1.2%，因 Shutdown() 阻塞超过 kubelet 等待阈值，触发强制 kill。同时，lsof -i :8080 | wc -l 显示，契约对齐后 TIME_WAIT 连接峰值从 1842 降至 217，证明连接释放节奏与 Endpoint 更新达成同步。