C / C++ / 系统课时

安全唤醒阻塞中的事件循环

安全唤醒阻塞中的事件循环

Reactor 线程通常会阻塞在 epoll_wait,如果其他线程只是把任务塞进队列,事件循环并不会立刻醒来。解决办法是给 epoll 再注册一个专用 eventfd:跨线程投递任务后写入计数器,让 epoll_wait 返回,再由事件循环读取并执行待办任务。

学习目标

  • 理解为什么“任务入队”本身无法唤醒阻塞中的 epoll_wait
  • 使用 eventfd 建立线程安全的唤醒通道,并正确处理读写时机
  • 明确任务队列、唤醒信号与事件循环之间的并发边界

唤醒机制的核心关系

事件循环负责等待 I/O,而工作线程负责产生“请事件循环执行”的任务。两者之间同时存在任务队列、eventfd 和 epoll_wait 三个对象,因此要把数据路径与唤醒路径分开理解。

eventfd 跨线程唤醒 Reactor 的数据流

关键点是:任务内容不写进 eventfd。eventfd 只承担“有新任务了”的通知,真正的任务仍保存在受互斥锁保护的队列中。普通模式下,eventfd 内部维护一个 64 位计数器,多次写入可以累加,一次读取会取出当前值并把计数清零,因此连续唤醒可以自然合并。

建立可运行的唤醒通道

下面的最小程序把 eventfd 注册进 epoll。主线程作为 EventLoop 阻塞等待,工作线程延迟投递任务并写入 eventfd,事件循环随后被唤醒并执行任务。将代码保存为 wakeup_demo.cpp,使用支持 C++17 的 Linux 编译器编译运行。

cpp
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <unistd.h>

#include <chrono>
#include <cstdint>
#include <functional>
#include <iostream>
#include <mutex>
#include <queue>
#include <stdexcept>
#include <thread>

class EventLoop {
public:
    EventLoop() {
        epollFd_ = epoll_create1(EPOLL_CLOEXEC);
        wakeupFd_ = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
        if (epollFd_ < 0 || wakeupFd_ < 0) {
            throw std::runtime_error("failed to create epoll/eventfd");
        }

        epoll_event ev{};
        ev.events = EPOLLIN;
        ev.data.fd = wakeupFd_;
        if (epoll_ctl(epollFd_, EPOLL_CTL_ADD, wakeupFd_, &ev) < 0) {
            throw std::runtime_error("failed to add eventfd to epoll");
        }
    }

    ~EventLoop() {
        close(wakeupFd_);
        close(epollFd_);
    }

    void queueInLoop(std::function<void()> task) {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            tasks_.push(std::move(task));
        }

        // eventfd 只负责通知,不承载任务内容。
        const std::uint64_t one = 1;
        if (write(wakeupFd_, &one, sizeof(one)) != sizeof(one)) {
            throw std::runtime_error("failed to wake event loop");
        }
    }

    void runOnce() {
        epoll_event events[4]{};
        const int count = epoll_wait(epollFd_, events, 4, -1);
        if (count < 0) {
            throw std::runtime_error("epoll_wait failed");
        }

        for (int i = 0; i < count; ++i) {
            if (events[i].data.fd == wakeupFd_) {
                drainWakeup();
            }
        }
        runPendingTasks();
    }

private:
    void drainWakeup() {
        std::uint64_t value = 0;
        if (read(wakeupFd_, &value, sizeof(value)) != sizeof(value)) {
            throw std::runtime_error("failed to drain eventfd");
        }
        std::cout << "event loop woke up" << '\n';
    }

    void runPendingTasks() {
        std::queue<std::function<void()>> local;
        {
            std::lock_guard<std::mutex> lock(mutex_);
            std::swap(local, tasks_);
        }

        // 交换到局部队列,避免执行回调时长期持有互斥锁。
        while (!local.empty()) {
            local.front()();
            local.pop();
        }
    }

    int epollFd_{-1};
    int wakeupFd_{-1};
    std::mutex mutex_;
    std::queue<std::function<void()>> tasks_;
};

int main() {
    EventLoop loop;
    std::thread worker([&loop] {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        loop.queueInLoop([] {
            std::cout << "task executed" << '\n';
        });
    });

    loop.runOnce();
    worker.join();
}

预期输出:

text
event loop woke up
task executed

避免丢唤醒与过度唤醒

正确性首先来自顺序:先把任务放入队列,再写 eventfd。如果先唤醒再入队,EventLoop 可能抢先返回并发现队列为空,随后重新进入 epoll_wait,真正入队的任务却没有新的信号可用。

同一线程向自己投递普通任务时,也不一定需要无条件写 eventfd。常见实现会记录 EventLoop 所在线程:跨线程投递一定唤醒;同线程投递则根据当前是否正在执行回调决定是否需要唤醒,从而减少无意义的系统调用。

为什么读取后再执行任务

epoll 只告诉你 eventfd 已经可读。如果不执行 read 清掉计数器,它会继续保持可读状态,下一轮 epoll_wait 会立即返回,事件循环就可能空转。

因此推荐顺序是:先处理 eventfd 可读事件并完成读取,再把共享任务队列交换到局部队列,最后执行回调。执行过程中如果其他线程继续投递任务,会再次写入 eventfd,下一轮循环就能稳定收到新的唤醒。

这个设计把“任务内容”和“阻塞唤醒”彻底解耦:任务队列保证内容完整,eventfd 保证及时性,epoll 负责统一等待,三者组合后才能形成可跨线程安全调度的 Reactor 骨架。

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

目录与阅读设置

阅读设置

17

记录一个想法

安全唤醒阻塞中的事件循环

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

登录哪都通