如何终止epoll_wait？Linux多线程epoll服务器优雅退出问题咨询

兄弟，我当初把Windows服务器迁到Linux用epoll的时候，也卡过这个终止的问题！关闭主套接字确实没用——毕竟epoll_wait可能还盯着一堆已连接的fd，或者干脆就阻塞在那儿没触发任何事件。给你几个实用的方案，按靠谱程度排序：

这是工业界最常用的优雅终止方式，核心思路就是给epoll加一个“唤醒专用”的fd，主线程要退出时往这个fd里写点东西，让epoll_wait从阻塞状态醒过来，然后我们就能在循环里检查退出标志，顺理成章结束线程。

具体步骤：

1. 创建匿名管道：int wakeup_pipe[2]; pipe(wakeup_pipe);，这个管道有读端wakeup_pipe[0]和写端wakeup_pipe[1]。
2. 把读端设置为非阻塞（避免后续读数据时意外阻塞），然后加到epoll实例里，监听EPOLLIN事件。
3. epoll循环里，每次epoll_wait返回后，遍历事件列表：如果是管道的读事件，就把管道里的数据读完（不管内容，清空就行），然后检查退出标志（比如用std::atomic_bool或者volatile sig_atomic_t保证线程安全），如果标志为真就跳出循环。
4. 主线程收到quit命令时，先设置退出标志为真，然后往管道写端随便写一个字节（比如write(wakeup_pipe[1], "x", 1)），epoll_wait马上就会被唤醒。
5. 最后记得清理所有资源：关闭管道、epoll_fd、所有套接字，等待线程退出。

代码示例：

#include <unistd.h>
#include <sys/epoll.h>
#include <atomic>
#include <pthread.h>
#include <cstring>
#include <iostream>

std::atomic_bool g_quit_flag = false;
int wakeup_pipe[2];

void handle_socket_event(const struct epoll_event& ev) {
    // 这里写你的套接字事件处理逻辑：接受连接、读写数据等
}

void* epoll_thread_func(void* arg) {
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1 failed");
        return nullptr;
    }

    // 配置管道读端为非阻塞
    int flags = fcntl(wakeup_pipe[0], F_GETFL, 0);
    fcntl(wakeup_pipe[0], F_SETFL, flags | O_NONBLOCK);

    // 将管道读端加入epoll
    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;
    ev.data.fd = wakeup_pipe[0];
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, wakeup_pipe[0], &ev) == -1) {
        perror("epoll_ctl add wakeup pipe failed");
        close(epoll_fd);
        return nullptr;
    }

    // 这里添加你的主监听套接字到epoll...
    // epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev_listen);

    struct epoll_event events[1024];
    while (!g_quit_flag) {
        int nfds = epoll_wait(epoll_fd, events, 1024, -1);
        if (nfds == -1) {
            if (errno == EINTR) continue; // 被信号中断，继续循环
            perror("epoll_wait failed");
            break;
        }

        for (int i = 0; i < nfds; ++i) {
            if (events[i].data.fd == wakeup_pipe[0]) {
                // 清空管道数据，避免下次触发不必要的事件
                char buf[16];
                while (read(wakeup_pipe[0], buf, sizeof(buf)) > 0);
                // 检查退出标志，准备退出循环
                if (g_quit_flag) break;
            } else {
                handle_socket_event(events[i]);
            }
        }
    }

    // 清理资源
    close(epoll_fd);
    close(wakeup_pipe[0]);
    std::cout << "epoll thread exited gracefully" << std::endl;
    return nullptr;
}

int main() {
    // 初始化管道
    if (pipe(wakeup_pipe) == -1) {
        perror("pipe failed");
        return 1;
    }

    // 创建epoll线程
    pthread_t epoll_thread;
    if (pthread_create(&epoll_thread, nullptr, epoll_thread_func, nullptr) != 0) {
        perror("pthread_create failed");
        close(wakeup_pipe[0]);
        close(wakeup_pipe[1]);
        return 1;
    }

    char cmd[256];
    std::cout << "Enter 'quit' to stop server:" << std::endl;
    while (fgets(cmd, sizeof(cmd), stdin)) {
        cmd[strcspn(cmd, "\n")] = '\0'; // 去掉换行符
        if (strcmp(cmd, "quit") == 0) {
            g_quit_flag = true;
            // 写一个字节到管道，唤醒epoll_wait
            char c = 'q';
            write(wakeup_pipe[1], &c, 1);
            // 等待线程退出
            pthread_join(epoll_thread, nullptr);
            close(wakeup_pipe[1]);
            std::cout << "Server stopped" << std::endl;
            break;
        }
        std::cout << "Unknown command, try 'quit'" << std::endl;
    }

    return 0;
}

如果不想搞管道，也可以给epoll线程发一个自定义信号，让epoll_wait被中断返回（返回-1，errno=EINTR），然后检查退出标志退出循环。

步骤：

1. 注册一个信号处理函数（比如处理SIGUSR1），函数里啥都不用做，只要能中断系统调用就行。
2. 主线程收到quit命令时，设置退出标志，然后用pthread_kill(epoll_thread, SIGUSR1)给线程发信号。
3. epoll循环里，当epoll_wait返回-1且errno=EINTR时，检查退出标志，如果为真就退出循环。

代码示例：

#include <signal.h>
#include <pthread.h>
#include <sys/epoll.h>
#include <atomic>
#include <cstring>
#include <iostream>

std::atomic_bool g_quit_flag = false;
pthread_t epoll_thread;

void sigusr1_handler(int sig) {
    (void)sig; // 避免未使用变量警告
}

void handle_socket_event(const struct epoll_event& ev) {
    // 你的事件处理逻辑
}

void* epoll_thread_func(void* arg) {
    // 注册SIGUSR1信号处理函数
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = sigusr1_handler;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIGUSR1, &sa, nullptr) == -1) {
        perror("sigaction failed");
        return nullptr;
    }

    int epoll_fd = epoll_create1(0);
    // 添加主套接字到epoll...

    struct epoll_event events[1024];
    while (!g_quit_flag) {
        int nfds = epoll_wait(epoll_fd, events, 1024, -1);
        if (nfds == -1) {
            if (errno == EINTR) {
                // 被信号中断，检查退出标志
                if (g_quit_flag) break;
                continue;
            }
            perror("epoll_wait failed");
            break;
        }
        // 处理事件
        for (int i = 0; i < nfds; ++i) {
            handle_socket_event(events[i]);
        }
    }

    close(epoll_fd);
    std::cout << "epoll thread exited" << std::endl;
    return nullptr;
}

int main() {
    if (pthread_create(&epoll_thread, nullptr, epoll_thread_func, nullptr) != 0) {
        perror("pthread_create failed");
        return 1;
    }

    char cmd[256];
    std::cout << "Enter 'quit' to stop server:" << std::endl;
    while (fgets(cmd, sizeof(cmd), stdin)) {
        cmd[strcspn(cmd, "\n")] = '\0';
        if (strcmp(cmd, "quit") == 0) {
            g_quit_flag = true;
            pthread_kill(epoll_thread, SIGUSR1);
            pthread_join(epoll_thread, nullptr);
            std::cout << "Server stopped" << std::endl;
            break;
        }
    }

    return 0;
}

⚠️ 注意：信号的坑不少，比如如果线程在处理非系统调用的逻辑时收到信号，信号会被挂起，直到下一次系统调用（比如epoll_wait）才会触发中断。另外，信号处理函数必须是信号安全的，不能调用printf、malloc这类非线程安全的函数，所以尽量只做最基础的操作。

如果不需要优雅清理，只是想立刻终止epoll_wait，那可以直接关闭epoll_fd——这时候epoll_wait会返回-1，errno=EBADF，你就能直接退出循环。不过这种方法会导致后续所有对该epoll_fd的操作失败，适合快速退出的场景。

主线程收到quit命令时，直接调用close(epoll_fd)（前提是epoll_fd是全局或者主线程能拿到的），epoll线程里捕获到错误后就退出。

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