操作系统 / 系统课时

让服务器优雅停止并排空连接

让服务器优雅停止并排空连接

优雅停止不是收到 SIGTERM 后立刻退出,而是让事件循环进入“排空”状态:先停止接收新连接,再继续处理已经建立的连接,并在宽限时间耗尽后强制结束。这样可以把部署重启从随机断连变成可观测、可控制的退出流程。

学习目标

  • 用 signalfd 把 SIGINT、SIGTERM 安全地交给 epoll 事件循环处理。
  • 设计“运行、排空、停止”三个阶段,明确何时关闭监听套接字。
  • 用排空完成和超时两条退出条件验证优雅停止行为。

退出动作必须发生在事件循环里

传统异步信号处理函数只能安全调用极少量的 async-signal-safe 函数,不适合直接遍历连接、修改复杂状态或写日志。Linux 可以先阻塞终止信号,再用 signalfd 把信号变成一个可读文件描述符;事件循环像处理普通 I/O 一样读取它,所有状态切换都发生在同一线程。

服务器可以只维护三个阶段:正常运行时监听新连接;收到终止信号后进入排空状态并关闭监听套接字;现有连接全部关闭,或者宽限时间到期后结束进程。关闭监听套接字比只设置一个布尔变量更可靠,因为内核将不再为该进程保留可 accept 的入口。

优雅停止的事件循环状态转换

用 signalfd 驱动排空状态

下面的脚本会生成并编译一个最小 epoll 服务器,再自动建立一个保持两秒的客户端连接、发送 SIGTERM,最后等待现有连接自行关闭。宽限时间设为 5 秒;如果连接提前排空,服务器会立即结束。

bash
set -e

cat > graceful_server.c <<'EOF'
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <sys/signalfd.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>

static long long monotonic_ms(void) {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (long long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}

static void add_fd(int epfd, int fd, uint32_t events) {
    struct epoll_event ev = {.events = events};
    ev.data.fd = fd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        perror("epoll_ctl");
        exit(1);
    }
}

int main(void) {
    setvbuf(stdout, NULL, _IONBF, 0);

    /* 先阻塞终止信号,再由 signalfd 统一交给事件循环。 */
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGINT);
    sigaddset(&mask, SIGTERM);
    if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
        perror("sigprocmask");
        return 1;
    }

    int sigfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
    int epfd = epoll_create1(EPOLL_CLOEXEC);
    int listener = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
    if (sigfd == -1 || epfd == -1 || listener == -1) {
        perror("create fd");
        return 1;
    }

    /* 允许课程实验快速重启,不改变优雅停止本身的语义。 */
    int one = 1;
    setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(9090),
    };
    inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);

    if (bind(listener, (struct sockaddr *)&addr, sizeof(addr)) == -1 ||
        listen(listener, 128) == -1) {
        perror("bind/listen");
        return 1;
    }

    add_fd(epfd, sigfd, EPOLLIN);
    add_fd(epfd, listener, EPOLLIN);
    printf("listening on 127.0.0.1:9090\n");

    int draining = 0;
    int listener_open = 1;
    int active = 0;
    long long deadline_ms = 0;
    struct epoll_event events[64];

    for (;;) {
        /* 排空阶段把 epoll_wait 的最长等待限制在 grace deadline 内。 */
        int timeout = -1;
        if (draining) {
            long long remain = deadline_ms - monotonic_ms();
            if (remain <= 0) {
                printf("grace timeout, force closing %d connection(s)\n", active);
                break;
            }
            timeout = (int)remain;
        }

        int n = epoll_wait(epfd, events, 64, timeout);
        if (n == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            return 1;
        }
        if (n == 0) {
            printf("grace timeout, force closing %d connection(s)\n", active);
            break;
        }

        /* 先处理终止信号,避免同一批事件中继续 accept 新连接。 */
        for (int i = 0; i < n; i++) {
            if (events[i].data.fd != sigfd) continue;

            struct signalfd_siginfo si;
            if (read(sigfd, &si, sizeof(si)) == sizeof(si) && !draining) {
                draining = 1;
                deadline_ms = monotonic_ms() + 5000;

                epoll_ctl(epfd, EPOLL_CTL_DEL, listener, NULL);
                close(listener);
                listener_open = 0;
                printf("draining: listener closed, grace=5s\n");
            }
        }

        for (int i = 0; i < n; i++) {
            int fd = events[i].data.fd;
            if (fd == sigfd) continue;

            if (fd == listener) {
                if (draining) continue;
                for (;;) {
                    int client = accept4(listener, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
                    if (client == -1) {
                        if (errno == EAGAIN || errno == EWOULDBLOCK) break;
                        perror("accept4");
                        return 1;
                    }
                    add_fd(epfd, client, EPOLLIN | EPOLLRDHUP);
                    active++;
                    printf("accepted fd=%d, active=%d\n", client, active);
                }
                continue;
            }

            char buf[1024];
            ssize_t r = read(fd, buf, sizeof(buf));
            if (r > 0) {
                /* 回显只用于确认客户端已被事件循环接管。 */
                send(fd, buf, (size_t)r, MSG_NOSIGNAL);
                continue;
            }
            if (r == 0 || (r == -1 && errno != EAGAIN && errno != EWOULDBLOCK) ||
                (events[i].events & (EPOLLHUP | EPOLLERR | EPOLLRDHUP))) {
                epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                close(fd);
                active--;
                printf("closed fd=%d, active=%d\n", fd, active);
            }
        }

        if (draining && active == 0) {
            printf("all existing connections drained\n");
            break;
        }
    }

    if (listener_open) close(listener);
    close(sigfd);
    close(epfd);
    return 0;
}
EOF

cc -O2 -Wall -Wextra -std=c11 graceful_server.c -o graceful_server

./graceful_server &
SERVER_PID=$!
sleep 0.2

READY_FILE="/tmp/graceful-client-ready-$$"
rm -f "$READY_FILE"
python3 - "$READY_FILE" <<'PY' &
import pathlib
import socket
import sys
import time

sock = socket.create_connection(("127.0.0.1", 9090))
sock.sendall(b"ping")
assert sock.recv(4) == b"ping"
pathlib.Path(sys.argv[1]).write_text("ready")
time.sleep(2)
sock.close()
PY
CLIENT_PID=$!

for _ in $(seq 1 50); do
    [ -f "$READY_FILE" ] && break
    sleep 0.1
done
[ -f "$READY_FILE" ]

kill -TERM "$SERVER_PID"
wait "$SERVER_PID"
wait "$CLIENT_PID"
rm -f "$READY_FILE"

预期输出

text
listening on 127.0.0.1:9090
accepted fd=<ID>, active=1
draining: listener closed, grace=5s
closed fd=<ID>, active=0
all existing connections drained

<ID> 是运行时分配的文件描述符,实际值会不同。关键观察点是:终止信号出现后不再有新的 accepted,已有连接仍能存活到客户端主动关闭,并且服务器没有等满 5 秒。

给排空过程设置明确边界

排空不能无限等待。HTTP keep-alive、WebSocket、长轮询或异常客户端都可能长期占着连接,因此需要一个明确的 grace deadline。业务层还应在进入排空状态后停止领取新任务,并让长连接协议收到“准备关闭”信号;超时后再由进程退出统一回收剩余描述符。

如果服务由 systemd、Kubernetes 或其他进程管理器托管,还要让外部的终止等待时间大于应用内部宽限时间,否则管理器会在应用排空结束前发送强制终止。应用日志至少记录“开始排空、当前连接数、排空完成或超时”三个节点,才能区分正常退出与被外部强杀。

验证是否真的没有接收新连接

验证时不要只看进程是否退出。进入排空后,新的连接尝试应失败、被上游摘流或落到其他实例;进入排空前已经建立的连接则应在宽限时间内继续工作。若仍看到新连接被 accept,通常说明监听套接字关闭得太晚,或者多个线程仍在共享同一个 listener。

真正可控的退出顺序是:信号进入事件循环 → 关闭 listener → 排空已有连接 → 到零立即退出,或超时强制退出。把这条顺序固定下来,发布、扩缩容和主机关停时的连接损失才有稳定边界。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

让服务器优雅停止并排空连接

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通