操作系统 / 系统课时
让服务器优雅停止并排空连接
让服务器优雅停止并排空连接
优雅停止不是收到 SIGTERM 后立刻退出,而是让事件循环进入“排空”状态:先停止接收新连接,再继续处理已经建立的连接,并在宽限时间耗尽后强制结束。这样可以把部署重启从随机断连变成可观测、可控制的退出流程。
学习目标
- 用
signalfd把SIGINT、SIGTERM安全地交给epoll事件循环处理。 - 设计“运行、排空、停止”三个阶段,明确何时关闭监听套接字。
- 用排空完成和超时两条退出条件验证优雅停止行为。
退出动作必须发生在事件循环里
传统异步信号处理函数只能安全调用极少量的 async-signal-safe 函数,不适合直接遍历连接、修改复杂状态或写日志。Linux 可以先阻塞终止信号,再用 signalfd 把信号变成一个可读文件描述符;事件循环像处理普通 I/O 一样读取它,所有状态切换都发生在同一线程。
服务器可以只维护三个阶段:正常运行时监听新连接;收到终止信号后进入排空状态并关闭监听套接字;现有连接全部关闭,或者宽限时间到期后结束进程。关闭监听套接字比只设置一个布尔变量更可靠,因为内核将不再为该进程保留可 accept 的入口。

用 signalfd 驱动排空状态
下面的脚本会生成并编译一个最小 epoll 服务器,再自动建立一个保持两秒的客户端连接、发送 SIGTERM,最后等待现有连接自行关闭。宽限时间设为 5 秒;如果连接提前排空,服务器会立即结束。
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"预期输出
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 → 排空已有连接 → 到零立即退出,或超时强制退出。把这条顺序固定下来,发布、扩缩容和主机关停时的连接损失才有稳定边界。