Go语言信号处理可靠性加固：SIGTERM优雅退出的8个致命缺口（含os/signal.Notify阻塞死锁、channel缓冲区溢出、goroutine泄露链）

第一章：Go语言信号处理的底层机制与设计哲学

Go 语言的信号处理并非简单封装系统调用，而是构建在操作系统信号机制之上的协同式抽象层。其核心设计哲学强调“goroutine 安全”与“显式控制”：信号不直接中断任意 goroutine，而是被统一捕获后投递至专门注册的通道（os.Signal），由用户逻辑主动消费，从而避免竞态、栈撕裂与不可重入问题。

信号捕获的运行时桥梁

Go 运行时通过 runtime/sigtramp 在底层安装信号处理函数（如 sigaction），将指定信号转为内部事件，并唤醒阻塞在 sigsend 中的 goroutine。该过程绕过传统 signal() 的全局 handler 模式，确保每个 signal.Notify 调用独立隔离。例如，向主 goroutine 注册 SIGINT：

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    // 创建带缓冲的信号通道，避免发送阻塞
    sigChan := make(chan os.Signal, 1)
    // 将 SIGINT 和 SIGTERM 通知到该通道
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    fmt.Println("Waiting for signal...")
    sig := <-sigChan // 阻塞等待首个信号
    fmt.Printf("Received signal: %v\n", sig)
}

执行后按 Ctrl+C 触发 SIGINT，程序立即输出并退出——整个流程无 panic，且未侵入任何用户 goroutine 栈。

信号语义与常见陷阱

• SIGKILL 和 SIGSTOP 无法被捕获或忽略，属操作系统强制行为
• 多次 signal.Notify 对同一信号会覆盖前次注册，非叠加
• 若未调用 signal.Stop 或关闭通道，可能导致 goroutine 泄漏

信号类型	可捕获	典型用途	Go 中推荐处理方式
SIGINT	是	用户中断（Ctrl+C）	清理资源后优雅退出
SIGHUP	是	终端挂起	重载配置，不终止进程
SIGQUIT	是	调试转储	触发 pprof 或日志快照

Go 选择将信号转化为同步通信原语，本质是将异步外部事件纳入 channel-select 并发模型，体现其“用通信共享内存”的根本信条。

第二章：SIGTERM优雅退出的8大致命缺口全景图

2.1 理论剖析：POSIX信号语义与Go运行时信号模型的错位

POSIX信号是异步、进程级、无队列的软中断机制，而Go运行时通过runtime.sigtramp接管信号，并将其同步化、goroutine局部化、可抢占化——这一根本性重定向导致语义断层。

核心错位表现

• POSIX SIGUSR1 可被任意线程接收，Go 中默认仅由主M（主线程）捕获并转发至sigsend通道；
• SA_RESTART 在C中自动重启系统调用，Go却主动中断（如read返回EINTR后不重试），交由上层逻辑处理；
• 多信号并发到达时，POSIX仅保留一个待决（pending）实例，Go则通过sigqueue模拟队列语义（但非标准行为）。

Go信号拦截关键代码

// src/runtime/signal_unix.go
func sigtramp(sig uint32, info *siginfo, ctxt unsafe.Pointer) {
    // 将POSIX信号转为runtime内部事件
    sigsend(uint32(sig)) // 非阻塞写入全局sigsend通道
}

sigsend将信号推入sigsend channel（类型为chan uint32），由sigrecv goroutine统一消费。该设计规避了多线程信号竞争，但彻底丢失POSIX“信号即刻投递”语义。

语义对比表

维度	POSIX标准	Go运行时实现
投递时机	异步、随时中断执行流	同步、等待G被调度到M
并发处理	单信号pending（覆盖）	多信号排队（channel缓冲）
系统调用中断	可配置SA_RESTART	总返回EINTR，不自动重试

graph TD
    A[POSIX信号抵达内核] --> B{内核选择接收线程}
    B --> C[线程栈执行sigaction handler]
    C --> D[直接修改用户上下文]
    A --> E[Go runtime.sigtramp]
    E --> F[写入sigsend channel]
    F --> G[sigrecv goroutine消费]
    G --> H[调用用户注册的signal.Notify channel]

2.2 实践复现：os/signal.Notify阻塞死锁的5种典型触发路径

常见误用模式

os/signal.Notify 本身不阻塞，但与 signal.Stop、chan 关闭逻辑或 select{} 配合不当，极易引发 goroutine 永久等待。

典型死锁路径（摘要）

编号	触发场景	根本原因
1	向已关闭 channel 发送信号	Notify(c, os.Interrupt) 写入 panic 或阻塞（若 c 无缓冲且未读）
2	signal.Stop 后仍尝试读 channel	channel 无新信号，但未关闭，range 或 <-c 永久挂起

c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
close(c) // ❌ 错误：Notify 内部仍可能向已关闭 chan 写入
<-c      // panic: send on closed channel

逻辑分析：signal.Notify 在内部 goroutine 中向 c 发送信号；close(c) 后若系统恰好触发中断，底层写操作直接 panic。参数 c 必须由用户生命周期独占管理，不可提前关闭。

graph TD
    A[main goroutine] -->|调用 Notify| B[signal 包内部 goroutine]
    B -->|尝试向 c 发送| C[c 已关闭]
    C --> D[panic: send on closed channel]

2.3 理论建模：channel缓冲区溢出导致信号丢失的概率化分析

在高吞吐实时系统中，channel缓冲区容量有限，当生产速率持续超过消费速率时，将触发丢包。该过程可建模为带容量限制的M/M/1/K排队系统。

关键参数定义

• λ：单位时间到达信号数（泊松过程）
• μ：单位时间处理信号数（指数服务时间）
• K：缓冲区总容量（含正在处理的1个槽位）

丢包概率公式

根据Erlang-B公式，稳态溢出概率为：
$$ P{\text{loss}} = \frac{(\lambda/\mu)^K / K!}{\sum{i=0}^{K} (\lambda/\mu)^i / i!} $$

实时验证代码（Go）

func dropProb(lambda, mu float64, K int) float64 {
    rho := lambda / mu
    numerator := math.Pow(rho, float64(K)) / float64(factorial(K))
    denominator := 0.0
    for i := 0; i <= K; i++ {
        denominator += math.Pow(rho, float64(i)) / float64(factorial(i))
    }
    return numerator / denominator // Erlang-B丢包率
}
// factorial() 需预实现；rho>1时P_loss急剧上升

不同负载下的丢包率（K=8）

ρ (λ/μ)	P_loss
0.5	1.2e-5
1.0	0.014
1.3	0.127

graph TD
    A[信号到达] --> B{缓冲区未满？}
    B -->|是| C[入队]
    B -->|否| D[立即丢弃]
    C --> E[消费者取走]

2.4 实践验证：goroutine泄露链在长生命周期服务中的级联放大效应

数据同步机制

某微服务通过 time.Ticker 触发周期性数据库同步，但未绑定 context 生命周期：

func startSync(db *sql.DB) {
    ticker := time.NewTicker(30 * time.Second)
    go func() { // ❌ 无 cancel 控制的 goroutine
        for range ticker.C {
            syncData(db) // 可能阻塞或 panic
        }
    }()
}

逻辑分析：ticker 持续发射时间信号，goroutine 永不退出；若服务运行 7 天（604800 秒），将累积 604800 / 30 ≈ 20160 次调度，但仅需 1 个 goroutine —— 泄露根源在于 goroutine 启动后失去控制权，而非调用频次本身。

级联放大路径

• 单个泄露 goroutine → 持有 DB 连接/HTTP client → 阻塞资源池
• 资源耗尽 → 新请求超时 → 重试逻辑启动 → 新 goroutine 创建
• 形成正反馈循环

阶段	goroutine 增长倍率	典型表现
初始泄露	×1	CPU 稳定，内存缓升
连接池耗尽	×5–10	dial tcp: lookup failed
重试风暴	×50+	P99 延迟突增至 10s+

根因修复示意

func startSync(ctx context.Context, db *sql.DB) {
    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()
    go func() {
        for {
            select {
            case <-ticker.C:
                syncData(db)
            case <-ctx.Done(): // ✅ 可取消
                return
            }
        }
    }()
}

参数说明：ctx 由服务启动时传入（如 context.WithCancel(signal.NotifyContext(...))），确保进程终止时所有衍生 goroutine 统一退出。

2.5 理论+实践：信号竞争窗口与GC STW周期的隐式耦合陷阱

数据同步机制中的时序脆弱性

Go 运行时中，runtime.sigsend 向 sighandlers 发送信号时，若恰逢 GC 进入 STW（Stop-The-World）前的 preemption sweep 阶段，信号队列可能被临时冻结，导致用户态信号处理延迟不可预测。

// 模拟信号注入与 GC 干扰竞争点
func triggerSignalWithGCDisturbance() {
    runtime.GC() // 强制触发 GC，增大 STW 概率
    syscall.Kill(syscall.Getpid(), syscall.SIGUSR1) // 此刻易落入 STW 窗口
}

逻辑分析：runtime.GC() 不保证立即 STW，但会加速 gcStart 流程；SIGUSR1 若在 sighandler 被禁用（sigdisable）期间到达，则被丢弃而非排队——这是信号丢失的根本原因。参数 syscall.SIGUSR1 无特殊语义，仅作可捕获的用户信号示例。

隐式耦合的典型表现

场景	GC STW 状态	信号行为
STW 前 10μs	准备中（mheap_.sweepdone = false）	信号入队成功
STW 中（mheap_.sweepdone = true）	全局暂停	sigsend 返回但不入队（静默丢弃）
STW 后恢复	m->gsignal 可用	新信号正常处理

graph TD
    A[用户调用 syscall.Kill] --> B{GC 是否处于 STW？}
    B -- 是 --> C[忽略信号，不入队]
    B -- 否 --> D[写入 sigqueue，唤醒 sighandler]
    C --> E[应用层感知为“信号未送达”]

第三章：核心漏洞的深度归因与反模式识别

3.1 信号监听goroutine未受context管控的生命周期失控

当使用 signal.Notify 启动监听 goroutine 时，若未结合 context.Context 进行取消控制，该 goroutine 将持续运行直至程序退出，造成资源泄漏与不可预测的终止行为。

典型失控代码示例

func listenSignals() {
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
    // ❌ 无 context 控制，无法主动退出
    for range sigChan {
        log.Println("received signal")
    }
}

逻辑分析：sigChan 是无缓冲通道，for range 阻塞等待信号；但缺少 select + ctx.Done() 分支，导致 goroutine 无法响应上级取消指令。参数 sigChan 容量为 1，仅保障至少一次信号不丢失，但无法实现优雅退出。

生命周期对比表

场景	可取消性	资源释放时机	是否推荐
无 context 监听	否	程序退出时	❌
context-aware 监听	是	ctx.Cancel() 后立即退出	✅

正确模式流程图

graph TD
    A[启动 signal.Notify] --> B{select on sigChan or ctx.Done?}
    B -->|sigChan 接收| C[处理信号]
    B -->|ctx.Done() 触发| D[关闭 sigChan 并 return]

3.2 Notify channel未配对close导致的资源泄漏链式反应

数据同步机制中的通道生命周期管理

Notify channel 在事件驱动架构中承担异步通知职责，但若 close() 调用缺失或与 make(chan) 不成对，将引发底层 goroutine 持有、channel 缓冲区驻留、GC 无法回收等连锁问题。

典型泄漏代码片段

func startNotifier() {
    ch := make(chan string, 10) // 缓冲通道
    go func() {
        for msg := range ch { // 阻塞等待，永不退出
            process(msg)
        }
    }()
    // ❌ 忘记 defer close(ch) 或显式 close(ch)
}

逻辑分析：range ch 在 channel 未关闭时永久阻塞，goroutine 无法退出；缓冲区中残留消息持续占用堆内存；若该函数高频调用，将快速累积 goroutine 与内存泄漏。

泄漏影响层级

层级	表现	触发条件
Goroutine	runtime.NumGoroutine() 持续增长	channel 未关闭 + range 永驻
内存	pprof heap 显示 runtime.chansend 相关对象堆积	缓冲通道写入后无消费/关闭
FD/epoll	（若底层封装 socket）文件描述符泄漏	基于 channel 的 net.Conn 通知层复用不当

修复路径示意

graph TD
    A[启动 notifier] --> B[make chan]
    B --> C[启动监听 goroutine]
    C --> D{是否收到终止信号？}
    D -->|是| E[close(ch)]
    D -->|否| C
    E --> F[goroutine 自然退出]

3.3 SIGTERM处理函数中panic/recover滥用引发的退出不可达

问题场景还原

当服务收到 SIGTERM 时，若在信号处理函数中调用 panic() 并试图用 recover() 捕获以“优雅退出”，将导致 os.Exit() 被跳过——因为 recover() 只能终止当前 goroutine 的 panic，无法中止主 goroutine 的阻塞等待。

func handleSigterm() {
    sig := make(chan os.Signal, 1)
    signal.Notify(sig, syscall.SIGTERM)
    go func() {
        <-sig
        panic("shutdown") // ❌ 错误：panic 后 recover 在子 goroutine 中，主流程仍卡住
    }()
}

此处 panic("shutdown") 发生在匿名 goroutine 中，recover() 若置于同 goroutine 内，仅恢复该 goroutine，主程序继续阻塞于 signal.Notify 或 http.Serve()，进程永不退出。

正确模式对比

方式	是否可达 os.Exit(0)	是否阻塞主 goroutine	是否符合 POSIX 语义
panic+recover	❌ 否	✅ 是	❌ 否
os.Exit(0)	✅ 是	❌ 否	✅ 是
close(done) + context	✅ 是	❌ 否	✅ 是

推荐实践

• 使用 context.WithCancel 配合 http.Server.Shutdown()
• 绝不在信号 handler 中触发 panic/recover 链路
• 退出逻辑必须由主 goroutine 显式驱动

graph TD
    A[收到 SIGTERM] --> B[关闭监听套接字]
    B --> C[触发 context cancel]
    C --> D[WaitGroup 等待工作 goroutine 结束]
    D --> E[os.Exit(0)]

第四章：生产级可靠性加固方案矩阵

4.1 基于bounded-channel+select超时的信号安全接收范式

在并发信号处理中，无界通道易引发 goroutine 泄漏，而 signal.Notify 直接对接系统信号存在竞态风险。bounded-channel 结合 select 超时构成轻量级、可中断、内存可控的接收范式。

核心模式：带限通道 + 非阻塞选择

使用容量为 1 的 channel 缓存最新信号，避免堆积；select 内置 default 或 time.After 实现毫秒级响应控制。

sigCh := make(chan os.Signal, 1) // 容量为1，丢弃旧信号，保障内存边界
signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
select {
case s := <-sigCh:
    log.Printf("received: %v", s)
case <-time.After(5 * time.Second):
    log.Println("timeout waiting for signal")
}

逻辑分析：make(chan os.Signal, 1) 确保仅缓存最后一次未消费信号；select 避免永久阻塞，time.After 提供确定性超时控制，适用于健康检查或优雅退出协商场景。

对比优势（关键指标）

特性	unbounded-channel	bounded(1)+select
内存增长	线性（信号洪峰）	恒定 O(1)
超时控制	不支持	原生支持
信号丢失语义	无定义	显式“覆盖即丢弃”

graph TD
    A[OS Signal] --> B(signal.Notify)
    B --> C[bounded-channel]
    C --> D{select with timeout}
    D -->|Signal received| E[Handle & exit]
    D -->|Timeout| F[Proceed non-blockingly]

4.2 context-aware信号处理器：集成cancel、timeout与done通道联动

核心设计哲学

context.Context 不是状态容器，而是信号广播总线：Done() 返回只读 chan struct{}，所有监听者通过 select 统一响应取消、超时或完成事件。

三通道协同机制

• ctx.Done()：统一信号出口，触发后所有监听 goroutine 应立即退出
• ctx.Err()：返回终止原因（context.Canceled / context.DeadlineExceeded）
• ctx.Value()：仅传递请求范围的不可变元数据（如 traceID），禁止传业务对象

典型协程安全模式

func processWithCtx(ctx context.Context, data []byte) error {
    done := make(chan error, 1)
    go func() {
        // 模拟耗时操作
        select {
        case <-time.After(3 * time.Second):
            done <- doWork(data)
        case <-ctx.Done(): // 响应 cancel/timeout
            done <- ctx.Err()
        }
    }()

    select {
    case err := <-done:
        return err
    case <-ctx.Done():
        return ctx.Err() // 防止 goroutine 泄漏
    }
}

逻辑分析：双 select 嵌套确保：① 主 goroutine 不阻塞等待子协程；② 子协程在 ctx.Done() 触发时立即中止；③ done channel 容量为 1 避免写入阻塞。参数 ctx 必须由调用方传入（如 context.WithTimeout(parent, 5s)），不可自行创建根 context。

通道联动优先级表

信号源	触发条件	ctx.Err() 返回值
cancel()	cancelFunc() 被显式调用	context.Canceled
timeout	超过 WithDeadline 时间	context.DeadlineExceeded
parent done	父 context 已关闭	继承父级 Err() 值

graph TD
    A[Context 创建] --> B[WithCancel/Timeout/Deadline]
    B --> C[子 Context]
    C --> D{select 监听 Done()}
    D -->|接收信号| E[调用 ctx.Err()]
    D -->|无信号| F[继续执行]

4.3 goroutine退出守卫：WaitGroup+原子状态机的双重收敛机制

数据同步机制

sync.WaitGroup 负责计数协调，但无法表达“已终止”语义；需配合 atomic.Value 或 atomic.Uint32 构建状态机。

状态流转模型

const (
    stateRunning uint32 = iota
    stateStopping
    stateStopped
)

var state uint32 = stateRunning

// 安全过渡：仅允许 Running → Stopping → Stopped
func tryStop() bool {
    return atomic.CompareAndSwapUint32(&state, stateRunning, stateStopping)
}

逻辑分析：CompareAndSwapUint32 保证状态跃迁原子性；参数 &state 为状态地址，stateRunning 是期望值，stateStopping 是新值。失败返回 false，避免重复触发清理。

收敛保障对比

机制	阻塞等待	状态可观测	并发安全
WaitGroup	✅	❌	✅
原子状态机	❌	✅	✅

graph TD
    A[goroutine启动] --> B{state == Running?}
    B -->|Yes| C[执行业务]
    B -->|No| D[立即退出]
    C --> E[收到停止信号]
    E --> F[tryStop → Stopping]
    F --> G[WaitGroup.Done]
    G --> H[state → Stopped]

4.4 全链路可观测性增强：信号到达、分发、处理、退出的trace埋点规范

为实现端到端调用链精准还原，需在信号生命周期四阶段统一注入标准化 trace 上下文。

埋点关键阶段与语义标签

• 到达（Ingress）：解析 HTTP/GRPC 请求头中 trace-id、span-id、parent-span-id，补全 service:gateway 和 endpoint:/api/v1/order
• 分发（Dispatch）：跨服务调用前注入 X-B3-TraceId 等 B3 兼容头，并标记 rpc.role:producer
• 处理（Process）：业务逻辑入口创建子 Span，设置 span.kind:server + http.status_code:200
• 退出（Egress）：异步任务或消息投递时携带 messaging.system:kafka 与 messaging.destination:order-events

标准化 Span 属性表

字段名	类型	必填	示例值	说明
service.name	string	✓	payment-service	服务唯一标识
span.kind	string	✓	client / server	调用角色语义
otel.status.code	string	✓	OK / ERROR	OpenTelemetry 状态码

// Spring Boot 拦截器中注入 ingress span
public class TraceIngressInterceptor implements HandlerInterceptor {
  @Override
  public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) {
    Context parent = OpenTelemetry.getGlobalPropagators()
        .getTextMapPropagator()
        .extract(Context.current(), req::getHeader, getter); // 从 header 提取 trace 上下文
    Span span = tracer.spanBuilder("http.request")
        .setParent(parent) // 继承上游 trace
        .setAttribute("http.method", req.getMethod()) // 补充业务属性
        .setAttribute("http.route", getRoute(req)) 
        .startSpan();
    req.setAttribute("otel-span", span);
    return true;
  }
}

该代码在请求入口构建根 Span，通过 TextMapPropagator.extract() 解析 W3C TraceContext 或 B3 头，确保跨语言链路连续；setParent() 保证 Span 层级正确嵌套，setAttribute() 注入可观测语义标签供后端分析。

graph TD
  A[HTTP Ingress] -->|inject trace-id| B[Service Dispatch]
  B --> C[Async Kafka Egress]
  C --> D[Message Consumer]
  D --> E[DB Transaction]
  E --> F[HTTP Response]

第五章：从单体到云原生：信号可靠性的演进边界与未来挑战

在金融实时风控系统升级项目中，某头部券商将原有 Java 单体应用（部署于 VMware 虚拟机集群）迁移至 Kubernetes + Istio 服务网格架构。迁移后，核心交易信号链路（订单触发→风险评分→拦截决策→审计日志）的端到端 P99 延迟从 320ms 降至 87ms，但意外暴露了信号可靠性新断层：在 2023 年“黑色星期四”行情突变期间，因 Envoy sidecar 的连接池耗尽与上游认证服务 TLS 握手超时叠加，导致约 0.37% 的风控信号被静默丢弃——该比例远低于传统单体架构的故障率（1.2%），却首次引发对“亚秒级不可见信号衰减”的深度审计。

信号可观测性能力的结构性缺口

传统 APM 工具（如 SkyWalking）仅捕获 span 级调用链，无法关联信号语义。我们在 Prometheus 中扩展自定义指标 signal_integrity_ratio{stage="risk_scoring",reason="timeout"}，并结合 OpenTelemetry 的 baggage 传递信号唯一 ID（如 sig_id=TXN-7a3f9b2e）。实际运行发现：当 Istio 的 outlier_detection.base_ejection_time 设为 30s 时，被临时摘除的认证节点在恢复后未同步刷新其 JWT 公钥缓存，造成后续 12–17 秒内所有携带旧签名的信号验证失败，该问题在单体架构中因无服务间动态摘除机制而不存在。

服务网格层信号保活的工程实践

为解决上述问题，我们改造了 Istio 的 EnvoyFilter，注入如下 Lua 插件逻辑：

function envoy_on_request(request_handle)
  local sig_id = request_handle:headers():get("x-signal-id")
  if sig_id and not request_handle:metadata():get("signal_validated") then
    local cache_key = "jwt_pubkey_" .. request_handle:headers():get("x-auth-cluster")
    if not redis:get(cache_key) then
      redis:setex(cache_key, 60, fetch_fresh_pubkey())
    end
  end
end

同时将 retry_policy 配置为 retryOn: "5xx,connect-failure,refused-stream"，并启用 perTryTimeout: 2s，确保单次信号处理失败可快速重试而非静默丢弃。

多活单元化下的信号一致性挑战

当前系统已实现上海、深圳双单元多活部署，但跨单元信号同步依赖 Kafka 分区复制。压测发现：当深圳单元 Kafka ISR 数量从 3 降至 2 时，acks=all 配置下部分风控信号写入延迟激增至 4.2s，超出交易系统 3s 信号有效期阈值。我们引入基于 Raft 的轻量信号协调器 SignalRaft，仅对 critical=true 的信号强制强一致写入，其余信号降级为最终一致，实测将关键信号丢失率从 0.11% 降至 0.002%。

架构阶段	信号丢失率（峰值）	信号乱序率	可观测粒度	恢复平均时间
单体（VM）	1.20%		接口级	4m 12s
容器化（K8s）	0.45%	0.18%	Pod 级	1m 33s
服务网格（Istio）	0.37%	0.82%	连接级	22s
网格+SignalRaft	0.002%	0.03%	信号语义级	8.4s

边缘计算场景的信号可信边界重构

在期货公司移动终端风控场景中，我们将信号预处理下沉至 Android/iOS 客户端 SDK。通过 WebAssembly 模块运行轻量评分模型，并利用 TEE（Trusty OS/Secure Enclave）保护信号生成密钥。实测显示：当网络中断 15 秒后，本地生成的离线信号仍能保证 99.999% 的加密完整性，但需解决设备时钟漂移导致的信号时间戳偏差问题——我们采用 NTP 校准差分补偿算法，在 300ms 内将时间误差收敛至 ±8ms。

混沌工程驱动的信号韧性验证

使用 Chaos Mesh 注入以下故障组合：

• PodKill：每 90s 随机终止一个风控决策 Pod
• NetworkDelay：对 Kafka Broker 网络注入 200±50ms 延迟
• IOChaos：对 Redis 实例磁盘 I/O 延迟提升至 120ms

持续运行 72 小时后，信号完整性维持在 99.998%，但发现 SignalRaft 在网络分区恢复后存在 3–5 秒的 leader 重选窗口，期间新信号暂存队列积压达 172 条，触发了预设的熔断阈值。