C / C++ / 系统课时
安全唤醒阻塞中的事件循环
安全唤醒阻塞中的事件循环
Reactor 线程通常会阻塞在 epoll_wait,如果其他线程只是把任务塞进队列,事件循环并不会立刻醒来。解决办法是给 epoll 再注册一个专用 eventfd:跨线程投递任务后写入计数器,让 epoll_wait 返回,再由事件循环读取并执行待办任务。
学习目标
- 理解为什么“任务入队”本身无法唤醒阻塞中的
epoll_wait - 使用
eventfd建立线程安全的唤醒通道,并正确处理读写时机 - 明确任务队列、唤醒信号与事件循环之间的并发边界
唤醒机制的核心关系
事件循环负责等待 I/O,而工作线程负责产生“请事件循环执行”的任务。两者之间同时存在任务队列、eventfd 和 epoll_wait 三个对象,因此要把数据路径与唤醒路径分开理解。

关键点是:任务内容不写进 eventfd。eventfd 只承担“有新任务了”的通知,真正的任务仍保存在受互斥锁保护的队列中。普通模式下,eventfd 内部维护一个 64 位计数器,多次写入可以累加,一次读取会取出当前值并把计数清零,因此连续唤醒可以自然合并。
建立可运行的唤醒通道
下面的最小程序把 eventfd 注册进 epoll。主线程作为 EventLoop 阻塞等待,工作线程延迟投递任务并写入 eventfd,事件循环随后被唤醒并执行任务。将代码保存为 wakeup_demo.cpp,使用支持 C++17 的 Linux 编译器编译运行。
#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();
}预期输出:
event loop woke up
task executed避免丢唤醒与过度唤醒
正确性首先来自顺序:先把任务放入队列,再写 eventfd。如果先唤醒再入队,EventLoop 可能抢先返回并发现队列为空,随后重新进入 epoll_wait,真正入队的任务却没有新的信号可用。
同一线程向自己投递普通任务时,也不一定需要无条件写 eventfd。常见实现会记录 EventLoop 所在线程:跨线程投递一定唤醒;同线程投递则根据当前是否正在执行回调决定是否需要唤醒,从而减少无意义的系统调用。
为什么读取后再执行任务
epoll 只告诉你 eventfd 已经可读。如果不执行 read 清掉计数器,它会继续保持可读状态,下一轮 epoll_wait 会立即返回,事件循环就可能空转。
因此推荐顺序是:先处理 eventfd 可读事件并完成读取,再把共享任务队列交换到局部队列,最后执行回调。执行过程中如果其他线程继续投递任务,会再次写入 eventfd,下一轮循环就能稳定收到新的唤醒。
这个设计把“任务内容”和“阻塞唤醒”彻底解耦:任务队列保证内容完整,eventfd 保证及时性,epoll 负责统一等待,三者组合后才能形成可跨线程安全调度的 Reactor 骨架。