C / C++ / 系统课时

用信号安全关闭服务端

用信号安全关闭服务端

并发 TCP 服务端收到 SIGINT 或 SIGTERM 时,目标不是“立刻退出”,而是让阻塞中的主循环被可靠唤醒,再由正常控制流停止接收新连接、关闭已有连接并释放资源。本篇用 self-pipe 模式实现一条可验证的安全退出路径。

学习目标

  • 解释为什么信号处理函数不应承担复杂清理工作。
  • 用 self-pipe 将异步信号转换为主事件循环可处理的事件。
  • 按明确顺序关闭监听 Socket、客户端连接和唤醒管道。

信号处理函数只负责通知

信号处理函数运行在异步上下文中,可能打断主程序正在执行的任意位置。此时调用 printf、malloc 等非 async-signal-safe 函数可能破坏库内部状态,因此处理函数应尽量短小。

这里采用两个动作:把 volatile sig_atomic_t 类型的停止标志设为 1,再向非阻塞管道写入一个字节。POSIX 将 write 列为 async-signal-safe,因此它适合用来唤醒阻塞在 poll 上的主循环。即使管道已满导致写入失败,管道本身也已经可读,主循环仍会被唤醒。

用 self-pipe 唤醒主循环

主循环同时监听三类描述符:监听 Socket、self-pipe 的读端、已建立的客户端连接。终止信号到来后,处理函数只写 self-pipe;poll 因管道可读而返回,主循环看到停止标志后退出事件循环,再进入普通的清理路径。

终止信号唤醒主循环并安全释放 TCP 服务端资源

这种结构还有一个重要优点:信号不需要“知道”服务端当前处于哪个系统调用中。无论主循环正在等待新连接还是已有连接的数据,通知都会进入同一条事件通道,退出逻辑因此保持集中。

完整实现

下面的程序用 poll 同时维护监听 Socket、唤醒管道和最多 32 个客户端连接。客户端发来的数据只被读取并丢弃,目的是把注意力放在退出流程,而不是业务协议上。

c
#define _POSIX_C_SOURCE 200809L

#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

enum { PORT = 9090, MAX_CLIENTS = 32 };

/* 处理函数与主循环只共享简单状态和 self-pipe 写端。 */
static volatile sig_atomic_t stop_requested = 0;
static int wake_write_fd = -1;

static void on_terminate(int signo) {
    (void)signo;
    int saved_errno = errno;
    stop_requested = 1;

    /* 非阻塞写只负责通知;失败也不在处理函数里做复杂补救。 */
    if (wake_write_fd != -1) {
        unsigned char byte = 1;
        (void)write(wake_write_fd, &byte, 1);
    }

    errno = saved_errno;
}

static int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1) {
        return -1;
    }
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

static int install_handlers(void) {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = on_terminate;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;

    if (sigaction(SIGINT, &sa, NULL) == -1) {
        return -1;
    }
    if (sigaction(SIGTERM, &sa, NULL) == -1) {
        return -1;
    }
    return 0;
}

int main(void) {
    int wake_pipe[2] = {-1, -1};
    int listen_fd = -1;
    int exit_code = 1;

    /* self-pipe 必须非阻塞,避免处理函数因管道写满而卡住。 */
    if (pipe(wake_pipe) == -1) {
        perror("pipe");
        return 1;
    }
    if (set_nonblocking(wake_pipe[0]) == -1 ||
        set_nonblocking(wake_pipe[1]) == -1) {
        perror("fcntl");
        goto cleanup;
    }

    wake_write_fd = wake_pipe[1];
    if (install_handlers() == -1) {
        perror("sigaction");
        goto cleanup;
    }

    listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) {
        perror("socket");
        goto cleanup;
    }

    int reuse = 1;
    if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR,
                   &reuse, sizeof(reuse)) == -1) {
        perror("setsockopt");
        goto cleanup;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);

    if (inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) != 1) {
        fprintf(stderr, "inet_pton failed\n");
        goto cleanup;
    }
    if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        goto cleanup;
    }
    if (listen(listen_fd, 16) == -1) {
        perror("listen");
        goto cleanup;
    }

    /* 0 是监听 Socket,1 是 self-pipe,后面才放客户端。 */
    struct pollfd fds[2 + MAX_CLIENTS];
    memset(fds, 0, sizeof(fds));
    fds[0].fd = listen_fd;
    fds[0].events = POLLIN;
    fds[1].fd = wake_pipe[0];
    fds[1].events = POLLIN;
    nfds_t nfds = 2;

    fprintf(stderr, "listening on 127.0.0.1:%d\n", PORT);

    while (!stop_requested) {
        int ready = poll(fds, nfds, -1);
        if (ready == -1) {
            if (errno == EINTR) {
                continue;
            }
            perror("poll");
            goto cleanup_clients;
        }

        /* 排空通知字节后再次看停止标志,退出仍由主循环决定。 */
        if (fds[1].revents & POLLIN) {
            unsigned char buffer[64];
            while (read(wake_pipe[0], buffer, sizeof(buffer)) > 0) {
            }
            if (stop_requested) {
                break;
            }
        }

        if (fds[0].revents & POLLIN) {
            int client_fd = accept(listen_fd, NULL, NULL);
            if (client_fd >= 0) {
                if (nfds < 2 + MAX_CLIENTS) {
                    fds[nfds].fd = client_fd;
                    fds[nfds].events = POLLIN;
                    fds[nfds].revents = 0;
                    ++nfds;
                } else {
                    close(client_fd);
                }
            } else if (errno != EINTR) {
                perror("accept");
            }
        }

        for (nfds_t i = 2; i < nfds;) {
            short events = fds[i].revents;
            int remove_client = 0;

            if (events & (POLLERR | POLLHUP | POLLNVAL)) {
                remove_client = 1;
            } else if (events & POLLIN) {
                char buffer[512];
                ssize_t n = recv(fds[i].fd, buffer, sizeof(buffer), 0);
                if (n <= 0) {
                    remove_client = 1;
                }
            }

            /* 用最后一项覆盖被移除项,避免在数组中留下空洞。 */
            if (remove_client) {
                close(fds[i].fd);
                fds[i] = fds[nfds - 1];
                --nfds;
            } else {
                ++i;
            }
        }
    }

    fprintf(stderr, "shutdown requested, closing resources\n");
    exit_code = 0;

cleanup_clients:
    for (nfds_t i = 2; i < nfds; ++i) {
        close(fds[i].fd);
    }

cleanup:
    /* 关闭 self-pipe 前先阻塞终止信号,避免处理函数再次写入。 */
    {
        sigset_t blocked;
        sigemptyset(&blocked);
        sigaddset(&blocked, SIGINT);
        sigaddset(&blocked, SIGTERM);
        (void)sigprocmask(SIG_BLOCK, &blocked, NULL);
    }

    wake_write_fd = -1;

    if (listen_fd != -1) {
        close(listen_fd);
    }
    if (wake_pipe[0] != -1) {
        close(wake_pipe[0]);
    }
    if (wake_pipe[1] != -1) {
        close(wake_pipe[1]);
    }

    return exit_code;
}

预期结果

text
代码可由支持 POSIX 接口的 Linux GCC/Clang 编译;启动后打印监听地址,收到 SIGINT 或 SIGTERM 后进入统一清理路径并正常退出。

这段代码的关键不是 poll 本身,而是“异步通知”和“同步清理”被明确分开。最后清理前暂时阻塞终止信号,避免信号处理函数在管道描述符关闭后再次写入。

运行与验证

把代码保存为 server.c,编译后让服务端进入后台,再发送 SIGTERM。kill 只负责投递信号,真正关闭资源的是被唤醒后的主循环。

bash
gcc -std=c11 -Wall -Wextra -O2 server.c -o server
./server &
pid=$!
sleep 1
kill -TERM "$pid"
wait "$pid"
printf 'exit=%d\n' "$?"

预期输出

text
listening on 127.0.0.1:9090
shutdown requested, closing resources
exit=0

若 9090 已被占用,bind 会失败并打印 Address already in use;这属于启动失败,不应进入信号退出流程。实际服务中还应把停止接收新连接、等待正在处理的请求完成以及设置最长退出时间纳入同一套资源生命周期设计。

退出时的资源回收顺序

收到终止信号后,先让主循环停止继续 accept,再关闭现有客户端连接,最后关闭监听 Socket 与 self-pipe。对于线程池版本,还应在关闭监听入口后通知工作线程结束,并在释放共享状态前完成 pthread_join。

安全关闭的核心原则是:信号只改变“应该退出”的状态,不在异步上下文里执行复杂业务;真正的资源释放仍沿正常控制流发生。这样既能避免信号处理函数中的不安全调用,也让每个文件描述符的所有权和关闭位置都可检查。

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

目录与阅读设置

阅读设置

17

记录一个想法

用信号安全关闭服务端

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

登录哪都通