C / C++ / 系统课时

实现跨线程安全任务投递

实现跨线程安全任务投递

当多个业务线程都可能操作同一个 EventLoop 时,真正要保证的不是“任何线程都能直接执行 I/O”,而是任务最终只在目标 I/O 线程落地。实现上需要区分同线程立即执行与跨线程入队,并用互斥保护待执行队列,再通过唤醒机制让阻塞中的事件循环及时处理新任务。

学习目标

  • 能定义 runInLoop 与 queueInLoop 的职责边界
  • 能实现线程安全的待执行任务队列,并避免持锁执行用户回调
  • 能说明为什么生产级 Reactor 还需要 eventfd 或管道唤醒阻塞中的 poll

先确定执行规则

runInLoop 的规则很简单:如果调用者就是目标 I/O 线程,可以立即执行;否则必须转交给 queueInLoop。queueInLoop 只负责把任务放进受保护的队列,并通知事件循环,不应该在提交线程里偷偷执行任务。

这样一来,连接状态、Channel 更新和 I/O 回调仍然遵守单线程所有权。跨线程调用方只负责“投递”,不用和事件循环同时修改同一批内部对象。

跨线程任务从提交到 EventLoop 执行的数据流

实现最小可运行的任务队列

下面用 std::condition_variable 模拟“唤醒阻塞中的事件循环”。真实网络库通常把这部分替换为 eventfd 或 pipe,并把唤醒文件描述符注册进 epoll;任务队列和线程归属规则保持一致。

cpp
#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";
        });
    });
}

预期输出:

text
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 的阻塞等待链路接起来。

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

目录与阅读设置

阅读设置

17

记录一个想法

实现跨线程安全任务投递

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

登录哪都通