如何在接收SIGINT信号时优雅关闭多线程C++ Socket应用？

你遇到的问题很典型——信号处理场景下的资源优雅释放，直接用静态实例的方式确实会让代码变得臃肿且难以维护。下面给你几个更优雅、更符合C++设计原则的解决方案：

方案1：原子退出标志+主线程轮询（简单易实现） #

核心思路是用一个线程安全的退出标志，信号处理函数只负责将标志置为true，主线程或监控线程轮询这个标志，一旦触发就执行和main()末尾一致的关闭逻辑。

#include <atomic>
#include <signal.h>
#include <thread>
#include <iostream>
#include <vector>

// 线程安全的退出标志
std::atomic<bool> g_should_exit(false);

void sigint_handler(int signum) {
    // 信号处理函数只做最小操作（必须异步安全）
    g_should_exit = true;
}

int main() {
    // 注册SIGINT信号处理函数
    signal(SIGINT, sigint_handler);

    // 初始化你的资源：服务器Socket、工作线程等
    ServerSocket server(8080);
    std::vector<std::thread> worker_threads;
    for (int i = 0; i < 4; ++i) {
        worker_threads.emplace_back(&worker_loop);
    }

    // 主线程轮询退出标志，等待触发
    while (!g_should_exit) {
        // 用sleep减少CPU占用，也可以用条件变量优化
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    // 复用main末尾的优雅关闭逻辑
    server.shutdown();
    for (auto& t : worker_threads) {
        if (t.joinable()) {
            t.join();
        }
    }
    std::cout << "所有资源已释放，程序优雅退出" << std::endl;
    return 0;
}

• 优点：不需要静态实例，关闭逻辑复用性强，信号处理函数完全符合异步安全要求。
• 注意：必须用std::atomic或volatile sig_atomic_t作为标志，避免编译器优化导致标志不生效。

方案2：自管道技巧（Self-Pipe Trick）（推荐，更安全） #

如果觉得轮询有延迟，或者想严格遵循POSIX异步安全规范，自管道是更可靠的选择：创建一个管道，信号处理函数向管道写入一个字节，主线程监听管道的可读事件，一旦有数据就读取并启动关闭流程。

#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <iostream>
#include <vector>
#include <thread>

int g_pipe_fd[2];

void sigint_handler(int signum) {
    char dummy = 'x';
    // 向管道写入一个字节，忽略错误（仅写1字节不会阻塞）
    write(g_pipe_fd[1], &dummy, 1);
}

int main() {
    // 创建管道
    if (pipe(g_pipe_fd) == -1) {
        perror("pipe creation failed");
        return 1;
    }
    // 设置写端为非阻塞，避免信号处理函数中write意外阻塞
    fcntl(g_pipe_fd[1], F_SETFL, O_NONBLOCK);

    // 注册信号处理函数（用sigaction比signal更可靠）
    struct sigaction sa;
    sa.sa_handler = sigint_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    if (sigaction(SIGINT, &sa, nullptr) == -1) {
        perror("sigaction failed");
        return 1;
    }

    // 初始化资源
    ServerSocket server(8080);
    std::vector<std::thread> worker_threads;
    // ... 启动工作线程

    // 主线程阻塞等待管道数据（SIGINT触发时写入）
    char buf;
    read(g_pipe_fd[0], &buf, 1);

    // 关闭管道
    close(g_pipe_fd[0]);
    close(g_pipe_fd[1]);

    // 执行优雅关闭
    server.shutdown();
    for (auto& t : worker_threads) {
        if (t.joinable()) t.join();
    }
    std::cout << "优雅退出完成" << std::endl;
    return 0;
}

• 优点：完全符合POSIX异步安全要求，响应无延迟，没有线程安全隐患。
• 注意：管道要在信号注册前创建，避免信号触发时管道未初始化。

额外优化：用RAII封装资源 #

把Socket、线程等资源封装到类中，利用C++的RAII特性，让析构函数自动完成资源释放，这样不管是正常退出还是信号触发的退出，只要对象被正确销毁，资源就会自动清理：

class ServerSocket {
public:
    ServerSocket(int port) {
        // 初始化socket、bind、listen等逻辑
        sock_fd = socket(AF_INET, SOCK_STREAM, 0);
        // ... 绑定端口、监听
    }

    ~ServerSocket() {
        // 析构时自动关闭socket
        if (sock_fd != -1) {
            shutdown(sock_fd, SHUT_RDWR);
            close(sock_fd);
        }
    }

    void shutdown() {
        // 主动关闭逻辑，和析构复用
        if (sock_fd != -1) {
            shutdown(sock_fd, SHUT_RDWR);
        }
    }

private:
    int sock_fd = -1;
};

这样你就不用手动写一堆关闭代码，代码的可维护性会大幅提升。

内容的提问来源于stack exchange，提问作者Mr Smith