生产环境中,一次失败的优雅停机可能导致客户端看到 502、数据库连接半开、消息重复消费,甚至分布式事务悬挂。本文从 Linux 信号处理出发,完整覆盖 TCP 半关闭、进程生命周期管理、连接池 Drain、Kubernetes Pod 终止链路、消息队列的 unacked 回收,到 Rust/Go/Java 的具体实现,给出可落地的生产级 Checklist。


一、问题的真正复杂度

很多工程师对"优雅停机"的理解就是"捕获 SIGTERM 然后 exit(0)",但在生产级系统中,真正的挑战分布在多个层面:

  • 网络层:正在飞行的请求怎么办?TCP 连接是 RST 还是 FIN?
  • 应用层:正在执行的 Handler 能否完成?连接池中的借出连接如何归还?
  • 中间件层:Redis/MySQL/消息队列的 client 是否注册了 close hook?编排层:Kubernetes 的 preStop、terminationGracePeriodSeconds、Service Endpoint 摘除时序是否正确?

任何一个环节遗漏,都会导致"看似优雅,实则翻车"。


二、Linux 信号处理:被忽视的细节

2.1 signal() vs sigaction()

永远使用 sigaction(),不要用 signal()。原因有三:

  1. signal() 在不同 UNIX 平台行为不一致(System V 语义 vs BSD 语义),sigaction() 是 POSIX 标准
  2. sigaction() 可以指定 SA_RESTART 标志,让被信号中断的系统调用自动重启(避免 EINTR 处理遗漏)
  3. sigaction() 通过 SA_SIGINFO 获取发送者 PID、UID 等上下文信息
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

static volatile sig_atomic_t g_shutting_down = 0;

void handle_sigterm(int sig, siginfo_t *info, void *context) {
    (void)info; (void)context;
    g_shutting_down = 1;
    // 实际工程中写入 eventfd / pipe,唤醒主循环
    write(notify_fd, "X", 1);
}

int main() {
    struct sigaction sa;
    sa.sa_sigaction = handle_sigterm;
    sa.sa_flags = SA_SIGINFO | SA_RESTART;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGTERM, &sa, NULL);

    // 主循环
    while (!g_shutting_down) {
        event_loop_iteration();
    }

    enter_graceful_shutdown();
    return 0;
}

2.2 信号处理的黄金法则

  • 信号处理函数只做最小操作:设置标志位或通过 eventfd/self-pipe 通知主循环。永远不在信号处理函数中调用非异步信号安全(async-signal-safe)的函数,比如 malloc()、printf()、pthread_mutex_lock()。
  • SIGKILL 不可捕获:kill -9 会直接终止进程,优雅停机只对 SIGTERM 和 SIGINT 生效。应用层需要接受"随时可能被强杀"的事实,设计幂等和恢复机制。
  • 多线程程序的信号掩码:专用线程通过 sigwait() 同步等待信号,避免异步信号投递到随机线程的问题。

三、TCP 连接关闭的正确姿态

3.1 close() vs shutdown()

行为 close() shutdown(SHUT_WR)
发送 FIN 引用计数归零时 立即
读端关闭 引用计数归零时 不影响
触发 EPOLLHUP 引用计数归零时 不影响
半关闭能力 无 有(单方向关闭)

核心区别:当 fork() 或 dup 了 fd 时,close() 未必真正关闭连接,而 shutdown() 总是立即生效。

3.2 SO_LINGER 的双刃剑

// 激进模式:RST 代替 FIN,避免 TIME_WAIT 堆积
struct linger sl = { .l_onoff = 1, .l_linger = 0 };
setsockopt(fd, SOL_SOCKET, SO_LINGER, &sl, sizeof(sl));

设置 l_linger=0 会导致 close() 发送 RST 而非 FIN,跳过 TIME_WAIT 状态。高风险:若内核发送缓冲区中仍有数据,RST 会导致数据丢失。仅适用于需要强制立刻关闭且可容忍数据丢失的场景(如健康检查失败后的连接清理)。

3.3 优雅停机的 TCP 关闭流程

正确的停机序列应该是:

1. 进入 draining 状态:拒绝新请求,返回 503 + Retry-After
2. 等待 in-flight 请求完成(设置 deadline)
3. shutdown(SHUT_WR):通知对端"我不会再发数据"
4. 读端继续 drain 对端的剩余数据直到对端也发送 FIN
5. close()

四、HTTP Server 的优雅停机实现

4.1 Go (net/http) —— 标准库自带

server := &http.Server{Addr: ":8080", handler: mux}

go func() {
    sig := make(chan os.Signal, 1)
    signal.Notify(sig, syscall.SIGTERM, syscall.SIGINT)
    <-sig

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    // Shutdown 执行:关闭监听→拒绝新请求→等待 in-flight 完成
    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("forced shutdown: %v", err)
    }
    cleanupConnectionPools()
}()

http.Server.Shutdown() 在 Go 1.8+ 的实现是生产级标杆:关闭所有 listeners → 关闭空闲连接 → 等待活跃连接完成 → 超时强制退出。只需要注意它不等待后端连接池回收,所以 cleanupConnectionPools() 必须调用方自己实现。

4.2 Rust (Axum + Tower) —— 需手动组合

use axum::Server;
use tokio::signal;

#[tokio::main]
async fn main() {
    let app = Router::new().route("/api", get(handler));

    Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .with_graceful_shutdown(shutdown_signal())
        .await
        .unwrap();

    // 重要:手动清理连接池
    DB_POOL.close().await;
    REDIS_MANAGER.quit().await;
}

async fn shutdown_signal() {
    let ctrl_c = async { signal::ctrl_c().await.unwrap() };
    let sigterm = async {
        signal::unix::signal(SignalKind::terminate())
            .unwrap()
            .recv()
            .await
    };

    tokio::select! {
        _ = ctrl_c => {},
        _ = sigterm => {},
    }
    println!("shutting down gracefully...");
}

4.3 Java (Spring Boot 3.x) —— 容器化模式

# application.yml
server:
  shutdown: graceful
spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

Spring Boot 2.3+ 的 graceful shutdown 在收到 SIGTERM 后会:停止接受新请求 → 等待活跃请求完成(最多 30s)→ SmartLifecycle beans 按顺序停止 → 退出。

Tomcat/Netty/Reactor Netty 三种嵌入式容器的实现细节略有差异:Tomcat 放弃 acceptor 线程但保留 worker threads,Netty 停掉 EventLoopGroup 的 accept 过程但保留 channel 处理。


五、连接池与中间件停机关联

这是绝大多数事故的温床 —— 应用进程停了,但连接池中的连接半开留在中间件侧,占用连接配额或阻塞下游。

5.1 数据库连接池配置矩阵

配置项 推荐值 原因
max-lifetime 30 min 避免数据库端 firewall/NAT timeout 导致半开连接
idle-timeout 10 min 释放不活跃连接,减少中间件负担
validation-timeout 5s 停机时 invalidate 连接不要阻塞过久
leak-detection-threshold 15s 开发阶段发现未归还的连接

5.2 Redis 客户端的特殊考量

Jedis/Lettuce 在 close() 时:

  • JedisPool:物理关闭所有连接,归还过程不涉及命令发送,安全
  • Lettuce:基于 Netty EventLoop,shutdown() 需要优雅关闭 EventLoopGroup,否则 TimerTask(reconnect、ping)可能 NPE

Lettuce 正确写法:

RedisClient client = RedisClient.create(uri);
client.shutdown(0, 0, TimeUnit.SECONDS); // 立即关闭,不等待

当需要等待飞行命令完成时,先调用 getStatefulConnection().close(),再 client.shutdown(quietPeriod, timeout, unit)。

5.3 gRPC 客户端通道

conn, _ := grpc.Dial(target,
    grpc.WithDefaultCallOptions(grpc.WaitForReady(true)),
)
// 优美关闭:等待进行中的 RPC 完成或 timeout
conn.Close() // 阻塞直到所有 stream 关闭或 transport 关闭

gRPC 的 Close() 会立即拒绝新的 RPC,但等待已有 stream 自然结束或 transport 层 idle 超时。


六、消息队列的 Unacked 回收

这是最容易被忽视的一环 —— 消费者停了,但 broker 端的 unacked 消息何时回到队列取决于 channel 关闭方式。

6.1 RabbitMQ

  • 正常关闭(Channel.close() / Connection.close()):所有 unacked 消息回到队列头部
  • 异常断开(TCP RST / 进程 crash):broker 检测 TCP 连接断开(依赖 heartbeat,默认 60s)后将 unacked 重新入队
  • 生产建议:开启 consumer ACK + 合理 heartbeat(10-30s),宁可短暂重复消费也不要悬挂

6.2 Kafka

Kafka 没有"ack"概念,而是依赖 consumer group rebalance。优雅停机 = 调用 consumer.commitSync() + consumer.close() + 等待 rebalance 完成。

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    consumer.commitSync(); // 先提交 offset 再关闭
    consumer.close(Duration.ofSeconds(15));
}));

陷阱:close() 之前先 commitSync(),否则未提交的 offset 会在 rebalance 后被重复消费。如果业务层是"先处理再提交",在信号处理中应选择等待当前处理完成而非立即关闭。

6.3 NATS JetStream

sub, _ := js.PullSubscribe("ORDERS.*", "WORKER")
// 优雅停机
sub.Unsubscribe() // 停止接收新消息
consumer.Delete()  // 清理 durable consumer 的 stateful metadata

注意 Unsubscribe 后 in-flight 的 msg 需要 Ack() 或 Nak() 才能从 pending 列表移除,否则 pending 列表会持续增长直到 server 端的 AckWait 到期。


七、Kubernetes Pod 终止链路:时序是核心

这是分布式环境下最容易踩坑的区域 —— 多个并行事件的时序直接决定是否有流量损失。

7.1 完整时序图

kubectl delete pod foo
    │
    ▼
APIServer 标记 Pod 的 deletionTimestamp
    │
    ├─── (1) preStop hook 执行 ─── sleep 15 或 /bin/sh -c "curl localhost:8080/drain"
    │
    ├─── (2) SIGTERM 发送到容器主进程 (PID 1)
    │         │
    │         ▼
    │     应用进入 draining,返回 503
    │
    ├─── (3) Endpoint Controller 将 Pod IP 从 Endpoints 摘除
    │         │   (与 SIGTERM 同时发生,不同 Controller 异步处理)
    │         ▼
    │     kube-proxy 更新 iptables/ipvs 规则
    │         │    (可能有 0.5~5s 延迟)
    │         ▼
    │     Service 不再路由新请求到此 Pod
    │
    └─── (4) terminationGracePeriodSeconds (默认 30s) 到期后 SIGKILL

关键问题:步骤 (2) 和 (3) 是并发的,SIGTERM 和 Endpoint 摘除在不同 goroutine。所以会出现 Pod 还在处理请求但已经收到了来自旧连接的新 TCP SYN(被路由到即将终止的 Pod)的情况。

7.2 preStop Hook 的实践价值

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

这个 sleep 15 不是玄学,而是给 Endpoint 摘除传播留出缓冲期。没有 preStop 时,Pod 可能在 Endpoint 摘除之前就退出,期间新请求全部 502。

业务级 preStop 更优雅:

lifecycle:
  preStop:
    httpGet:
      path: /admin/drain
      port: 8080

应用收到 drain 请求后:设置 health check 失败 → 返回 503 → 继续处理已有请求。

7.3 readinessProbe 联动

readinessProbe:
  httpGet:
    path: /health
  periodSeconds: 5
  failureThreshold: 1

当应用检测到停机信号时,可以让 /health 立刻返回 503,这样 Endpoint Controller 会从 Service 摘除 IP 的时序提前到 preStop 阶段,进一步减少 502 窗口。


八、常见事故案例分析

案例 1:MySQL 连接池泄漏导致停机后数据库雪崩

现象:K8s 滚动更新时数据库连接数飙升 300%。

根因:Java 应用收到 SIGTERM 后 Spring Boot graceful shutdown 等待 30s,但 HikariDataSource 的 close() 在 SmartLifecycle.stop() 之后滚动更新时多个 Pod 同时停机,旧 Pod 的连接要等 30s 才归还,新 Pod 又开新连接,数据库 max_connections 被打爆。

修复:设置 terminationGracePeriodSeconds: 45 > spring.lifecycle.timeout-per-shutdown-phase: 30,确保 JVM 退出前连接池先关闭。

案例 2:RabbitMQ 消息重复消费

现象:服务重启后同一订单处理了三次。

根因:Go 服务捕获 SIGTERM 后立即 os.Exit(0),amqp channel 未调用 Close()。broker 在 heartbeat 超时(60s)后才会将 unacked 消息 re-queue。在此期间新 consumer 上线拉取了这些消息,旧进程还在处理 —— 两条流并行处理同一条消息。

修复:信号处理中调用 channel.Close() + connection.Close(),让 unacked 立刻 re-queue,缩短重复窗口。

案例 3:gRPC 调用方收到 GOAWAY

现象:滚动更新期间 gRPC 调用方偶现 UNAVAILABLE。

根因:服务端 Netty 在 SIGTERM 后立即 shutdown() 并发送 GOAWAY帧,但客户端 connection pool 中有缓存的连接,在 GOAWAY 之后仍尝试复用已关闭的连接。

修复:客户端配置 max_connection_age(G1 特性)或使用 name resolver + load balancer,让客户端定期重建连接;服务端 GOAWAY 后保留 EventLoop 5s 让客户端处理 ack。


九、生产级 Checklist

停机前(draining 阶段)

  • [ ] 健康检查端点返回非 200,让 readinessProbe 快速摘流
  • [ ] 停止接受新请求(关闭 listener,或返回 503 + Retry-After: 30)
  • [ ] 拒绝新的定时任务 / Job schedule
  • [ ] 停止服务注册发现中的心跳(Consul/eureka/Nacos deregister)

等待 in-flight 完成(draining 阶段)

  • [ ] 设置全局 deadline(建议 30-60s)
  • [ ] 监控 in-flight 计数器归零
  • [ ] 主动 Flush 响应缓冲区(如 HTTP chunked transfer 的 terminating chunk)
  • [ ] 等待消息队列 unacked 全部 ack/nak 完成

退出阶段(cleanup 阶段)

  • [ ] 关闭消息队列 channel/connection(触发 unacked re-queue)
  • [ ] 关闭 gRPC channel(发送 GOAWAY,等待 in-flight stream 完成)
  • [ ] 关闭数据库连接池(invalidate 而非仅 close)
  • [ ] 关闭 Redis 客户端(释放连接 + 关闭 EventLoop)
  • [ ] 关闭分布式锁(释放持有的锁)
  • [ ] 关闭日志写入器(flush 缓冲,避免日志丢失)
  • [ ] 关闭 metrics exporter(推送最后一批 metrics)
  • [ ] 调用 exit(code)

Kubernetes 层

  • [ ] terminationGracePeriodSeconds > 应用所有 stop phase 总和 + 5s buffer
  • [ ] preStop hook 存在(sleep 或业务 drain 接口)
  • [ ] readinessProbe 在 draining 时能快速返回失败(periodSeconds ≤ 5)
  • [ ] PDB (PodDisruptionBudget) 配置合理,避免滚动更新时同时停过多副本

十、总结

优雅停机不是"加个信号处理函数"就能解决的事,它是贯穿操作系统、网络传输、应用框架、中间件客户端和编排平台的系统工程。

核心原则只有一条:进程的生命周期管理必须与它所依赖的外部资源的生命周期管理协同进行。具体体现为:

  1. 信号先行,资源随后:先接收 SIGTERM,再触发各组件 stop chain
  2. 时序是关键:Endpoint 摘除和进程退出之间的时序窗口必须用 preStop 填满
  3. 超时一切:每一个等待都需要 deadline,绝不死等
  4. 默认幂等:哪怕优雅停机失败,重启后系统能通过幂等、ack 机制恢复一致性

延伸思考:随着 Serverless 和 WebAssembly 的兴起,进程生命周期的粒度正在从"进程级"缩小到"请求级"。Cloudflare Workers 的生命周期就是一个请求,没有"优雅停机的概念;Wasm runtime(如 wasmtime)的实例销毁则是毫秒级的。这反而将优雅停机的责任推到了持久化连接和共享存储层 —— 未来这一领域的问题形态会继续演化,但核心原则不会过时。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部