C++线程优雅退出的避坑指南

void run() {
    while (m_running) {
        recv(m_fd, buf, 1024, 0); // 永久阻塞
        // 业务处理
    }
}

~Worker() {
    m_running = false;
    m_thread.join(); // 永久卡死
}

while (m_running) {
    poll(...); // 可被eventfd唤醒
    recv(m_fd, buf, 1024, 0); // 二次阻塞！卡死无解
}

#include <iostream>
#include <thread>
#include <atomic>
#include <unistd.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include <sys/epoll.h>
#include <csignal>
#include <errno.h>
#include <cstring>

// 全局信号退出标记
std::atomic<bool> g_exit{false};

// 信号处理：仅改标记，无复杂逻辑
void signal_handler(int sig) {
    if (sig == SIGTERM || sig == SIGINT) {
        g_exit = true;
        std::cout << "\n[信号] 收到优雅退出指令" << std::endl;
    }
}

// 注册信号：关闭SA_RESTART，允许中断阻塞调用
void register_signal() {
    struct sigaction sa{};
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    // 不启用SA_RESTART，保证sleep可被信号中断
    sigaction(SIGTERM, &sa, nullptr);
    sigaction(SIGINT, &sa, nullptr);
}

class FinalSafeWorker {
public:
    FinalSafeWorker() {
        init_epoll();
        init_wake_event();
        init_timer_task();
    }

    // 显式启动线程（禁止构造启动）
    void start() {
        m_running = true;
        m_thread = std::thread(&FinalSafeWorker::run, this);
    }

    // 主动优雅停止
    void stop() {
        if (!m_running) return;
        m_running = false;

        // 主动唤醒epoll，解除唯一阻塞点
        uint64_t wake_val = 1;
        write(m_wake_fd, &wake_val, 8);

        if (m_thread.joinable()) {
            m_thread.join();
        }
        std::cout << "[优雅退出] 线程已安全退出，资源清理完成" << std::endl;
    }

    // 析构兜底防护
    ~FinalSafeWorker() {
        stop();
        close(m_epoll_fd);
        close(m_wake_fd);
        close(m_timer_fd);
    }

private:
    // 初始化epoll：全局唯一阻塞管理器
    void init_epoll() {
        m_epoll_fd = epoll_create1(0);
    }

    // 退出唤醒事件：响应kill-15
    void init_wake_event() {
        m_wake_fd = eventfd(0, EFD_NONBLOCK);
        epoll_event ev{};
        ev.events = EPOLLIN;
        ev.data.fd = m_wake_fd;
        epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, m_wake_fd, &ev);
    }

    // 定时器：替代sleep，收拢定时任务到epoll
    void init_timer_task() {
        m_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
        itimerspec spec{};
        spec.it_interval.tv_sec = 1;  // 1秒定时任务
        spec.it_value.tv_sec = 1;
        timerfd_settime(m_timer_fd, 0, &spec, nullptr);

        epoll_event ev{};
        ev.events = EPOLLIN;
        ev.data.fd = m_timer_fd;
        epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, m_timer_fd, &ev);
    }

    void run() {
        while (m_running) {
            // ========== 线程全局唯一阻塞点 ==========
            epoll_event events[10];
            int n = epoll_wait(m_epoll_fd, events, 10, -1);
            if (n <= 0) continue;

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

                // 1. 退出事件：立刻终止循环
                if (fd == m_wake_fd) {
                    uint64_t val;
                    read(m_wake_fd, &val, 8);
                    m_running = false;
                    break;
                }

                // 2. 定时业务任务（替代sleep轮询）
                if (fd == m_timer_fd) {
                    uint64_t val;
                    read(m_timer_fd, &val, 8);
                    std::cout << "执行业务定时任务" << std::endl;
                }

                // 可扩展：socket网络事件、文件事件（全部非阻塞读取）
            }
        }
    }

private:
    int m_epoll_fd{-1};
    int m_wake_fd{-1};
    int m_timer_fd{-1};
    std::atomic<bool> m_running{false};
    std::thread m_thread;
};

int main() {
    register_signal();

    FinalSafeWorker worker;
    worker.start();
    std::cout << "服务启动成功，PID: " << getpid() << std::endl;

    // 可被信号中断的常驻循环
    while (!g_exit) {
        sleep(1);
    }

    // 主动优雅收尾
    worker.stop();
    std::cout << "服务完全优雅退出！" << std::endl;
    return 0;
}