C / C++ / 系统课时
实现跨线程安全任务投递
实现跨线程安全任务投递
当多个业务线程都可能操作同一个 EventLoop 时,真正要保证的不是“任何线程都能直接执行 I/O”,而是任务最终只在目标 I/O 线程落地。实现上需要区分同线程立即执行与跨线程入队,并用互斥保护待执行队列,再通过唤醒机制让阻塞中的事件循环及时处理新任务。
学习目标
- 能定义
runInLoop与queueInLoop的职责边界 - 能实现线程安全的待执行任务队列,并避免持锁执行用户回调
- 能说明为什么生产级 Reactor 还需要
eventfd或管道唤醒阻塞中的poll
先确定执行规则
runInLoop 的规则很简单:如果调用者就是目标 I/O 线程,可以立即执行;否则必须转交给 queueInLoop。queueInLoop 只负责把任务放进受保护的队列,并通知事件循环,不应该在提交线程里偷偷执行任务。
这样一来,连接状态、Channel 更新和 I/O 回调仍然遵守单线程所有权。跨线程调用方只负责“投递”,不用和事件循环同时修改同一批内部对象。

实现最小可运行的任务队列
下面用 std::condition_variable 模拟“唤醒阻塞中的事件循环”。真实网络库通常把这部分替换为 eventfd 或 pipe,并把唤醒文件描述符注册进 epoll;任务队列和线程归属规则保持一致。
#include <condition_variable>
#include <functional>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <utility>
class EventLoop {
public:
EventLoop() : thread_([this] { loop(); }) {
// 等待 I/O 线程完成初始化,避免过早读取未设置的线程 ID。
std::unique_lock<std::mutex> lock(mutex_);
readyCv_.wait(lock, [this] { return ready_; });
}
~EventLoop() {
{
std::lock_guard<std::mutex> lock(mutex_);
stopping_ = true;
}
cv_.notify_one();
thread_.join();
}
void runInLoop(std::function<void()> task) {
if (std::this_thread::get_id() == loopThreadId_) {
task();
return;
}
queueInLoop(std::move(task));
}
void queueInLoop(std::function<void()> task) {
{
std::lock_guard<std::mutex> lock(mutex_);
pending_.push(std::move(task));
}
// 跨线程投递后唤醒阻塞中的目标线程。
cv_.notify_one();
}
private:
void loop() {
{
std::lock_guard<std::mutex> lock(mutex_);
loopThreadId_ = std::this_thread::get_id();
ready_ = true;
}
readyCv_.notify_one();
while (true) {
std::queue<std::function<void()>> tasks;
{
std::unique_lock<std::mutex> lock(mutex_);
cv_.wait(lock, [this] {
return stopping_ || !pending_.empty();
});
if (stopping_ && pending_.empty()) {
break;
}
// 在锁内只交换队列,不执行用户代码。
tasks.swap(pending_);
}
while (!tasks.empty()) {
auto task = std::move(tasks.front());
tasks.pop();
task();
}
}
}
std::thread thread_;
std::thread::id loopThreadId_;
std::mutex mutex_;
std::condition_variable cv_;
std::condition_variable readyCv_;
std::queue<std::function<void()>> pending_;
bool ready_ = false;
bool stopping_ = false;
};
int main() {
EventLoop loop;
std::cout << "submit from main\n";
loop.runInLoop([&loop] {
std::cout << "task A on loop thread\n";
// 当前已经在目标线程,所以这次 runInLoop 会立即执行。
loop.runInLoop([] {
std::cout << "task B inline on loop thread\n";
});
});
}预期输出:
submit from main
task A on loop thread
task B inline on loop thread示例中互斥锁只覆盖队列操作。真正执行任务前先把共享队列 swap 到局部队列,这是关键:用户回调可能再次投递任务、注册事件,甚至触发复杂业务逻辑,如果一直持锁执行,很容易造成长时间阻塞或自锁。
接入 Reactor 时补上 wakeup
在基于 epoll_wait 的 Reactor 中,仅把任务压入队列还不够。I/O 线程可能正阻塞在 epoll_wait,如果没有新的网络事件,它就不知道队列里已经有任务。典型做法是为每个 EventLoop 创建一个 eventfd,跨线程入队后向它写入计数,使 epoll_wait 立即返回。
处理顺序通常是:先处理活跃 I/O 事件,再执行待处理任务;或者按库的设计统一定义顺序。无论选择哪种策略,都应保证一次循环会把当前批次任务完整取出,并避免在队列锁内调用用户代码。
验收线程归属
完成实现后,应至少验证三件事:业务线程调用 runInLoop 时任务在 I/O 线程执行;I/O 线程内部再次调用 runInLoop 时任务立即执行;多个生产者并发投递时没有任务丢失或重复执行。随后把示例里的条件变量唤醒替换成网络库实际使用的 eventfd,即可与 Reactor 的阻塞等待链路接起来。