AJohn Blog

外观

4. EventLoop

约 4563 字大约 15 分钟

2026-04-07

EventLoop 简介

EventLoop 类可以理解为 Reactor 模型中的事件循环核心，它负责把 Poller 监听到的事件分发给对应的 Channel，并执行用户注册的回调函数。

如果把 muduo 的网络框架看成一套“工厂流水线”，那么：

  • Channel 负责描述某个 fd 以及它关心的事件；
  • Poller 负责监听这些 fd 是否发生了事件；
  • EventLoop 负责不停地循环、等待、分发、执行回调。

它的核心作用可以概括为：

  1. 调用 Poller::poll() 等待 IO 事件；
  2. 收集发生事件的 Channel；
  3. 调用这些 Channel 的 handleEvent()；
  4. 执行线程间投递过来的任务回调；
  5. 通过 eventfd 唤醒阻塞中的 poll()。
PlantUML Diagram

EventLoop 类重要的成员变量

1. 重要成员

  • std::atomic_bool looping_：标识当前 EventLoop 是否正在执行 loop() 循环。
    它是原子变量，用于保证多线程场景下状态修改的安全性。

  • std::atomic_bool quit_：标识是否需要退出事件循环。
    当调用 quit() 后，这个值会被设置为 true，loop() 就会结束。

  • const pid_t threadId_：记录创建这个 EventLoop 的线程 ID。
    用来判断当前调用者是否在 EventLoop 自己所属的线程中。

  • Timestamp pollRetureTime_：保存 Poller 返回事件的时间点。
    这个时间会传给 Channel::handleEvent()，方便回调知道事件发生的时间。

  • std::unique_ptr<Poller> poller_：指向当前 EventLoop 所使用的 Poller。
    EventLoop 不直接操作 epoll，而是通过 Poller 接口统一管理。

  • int wakeupFd_：用于唤醒 EventLoop 的 eventfd。
    当其他线程向这个 EventLoop 投递任务时，可以通过它打断阻塞的 epoll_wait()。

  • std::unique_ptr<Channel> wakeupChannel_：专门用于监听 wakeupFd_ 的 Channel。
    当 wakeupFd_ 可读时，就说明有线程向当前 EventLoop 发了唤醒信号。

  • ChannelList activeChannels_：保存当前 Poller 检测到的所有活跃 Channel。
    poll() 返回后，EventLoop 会遍历这个列表并逐个处理。

  • std::atomic_bool callingPendingFunctors_：标识当前是否正在执行 pendingFunctors_ 中的任务。
    这个状态会影响 queueInLoop() 是否需要唤醒事件循环。

  • std::vector<Functor> pendingFunctors_：存储需要在 EventLoop 所在线程中执行的回调任务。
    这些任务通常是其他线程投递过来的。

  • std::mutex mutex_：保护 pendingFunctors_ 的互斥锁。
    因为多个线程可能会同时向 pendingFunctors_ 中添加任务，所以需要加锁保证线程安全。

EventLoop.h
// 事件循环类 主要包含了两个大模块 Channel Poller(epoll的抽象)
std::atomic_bool looping_;           // 原子操作 底层通过CAS实现
std::atomic_bool quit_;              // 标识退出loop循环

const pid_t threadId_;               // 记录当前EventLoop是被哪个线程id创建的 即标识了当前EventLoop的所属线程id

Timestamp pollRetureTime_;           // Poller返回发生事件的Channels的时间点
std::unique_ptr<Poller> poller_;

int wakeupFd_;                        // 作用：当mainLoop获取一个新用户的Channel 需通过轮询算法选择一个subLoop 通过该成员唤醒subLoop处理Channel
std::unique_ptr<Channel> wakeupChannel_;

ChannelList activeChannels_;          // 返回Poller检测到当前有事件发生的所有Channel列表

std::atomic_bool callingPendingFunctors_; // 标识当前loop是否有需要执行的回调操作
std::vector<Functor> pendingFunctors_;    // 存储loop需要执行的所有回调操作
std::mutex mutex_;                        // 互斥锁 用来保护上面vector容器的线程安全操作

EventLoop 类重要的成员方法

1. 构造 / 析构

EventLoop.h
EventLoop();
~EventLoop();

构造函数主要做了几件事：

  • 记录当前线程 ID threadId_；
  • 创建默认的 Poller；
  • 创建 eventfd 作为唤醒 fd；
  • 创建专门监听 wakeupFd_ 的 wakeupChannel_；
  • 为 wakeupChannel_ 绑定读回调 handleRead()；
  • 让 wakeupChannel_ 开始监听读事件。

提示

为什么要有 t_loopInThisThread？

它是一个线程局部变量，用来保证 一个线程只能有一个 EventLoop。 如果同一个线程里创建了多个 EventLoop，就会直接报错。

析构函数则负责：

  • 取消 wakeupChannel_ 的所有监听；
  • 从 EventLoop 中移除它；
  • 关闭 wakeupFd_；
  • 清空线程局部的 EventLoop 指针。

2. loop()

EventLoop.h
void loop();

loop() 是整个 EventLoop 的主循环，也是 Reactor 的核心。

每一轮循环大致分成三步：

  1. 调用 poller_->poll() 等待事件；
  2. 遍历所有活跃的 Channel，调用它们的 handleEvent()；
  3. 执行 pendingFunctors_ 中的任务。

这段逻辑的本质：loop() 就是一个不断重复的“事件分发器”：

  • 没有事件时就阻塞等待；
  • 有事件时就交给 Channel 处理；
  • 有线程投递任务时就执行任务。

3. quit()

EventLoop.h
void quit();

quit() 的作用是退出事件循环。

提示

为什么如果不是当前线程就要 wakeup()？

因为 EventLoop 可能正阻塞在 poller_->poll() 中。 如果其他线程调用 quit()，单纯把 quit_ = true 还不够，必须唤醒阻塞中的 epoll_wait()，让 loop() 能尽快检查到退出标志并结束循环。

4. runInLoop(Functor cb)

EventLoop.h
void runInLoop(Functor cb);

runInLoop() 的意思是：在 EventLoop 所在线程里执行这个回调。

分两种情况

  • 如果当前就在这个 EventLoop 所属线程中，直接执行 cb()；
  • 如果不在，就把任务扔到 queueInLoop()，等待该 EventLoop 线程来执行。

这个函数的意义：它为上层提供了一个统一入口： 不管当前是不是 loop 线程，都能“确保任务最终在 loop 线程中执行”。

5. queueInLoop(Functor cb)

EventLoop.h
void queueInLoop(Functor cb);

queueInLoop() 用来把一个回调任务加入待执行队列中。

作用：

  • 把任务放入 pendingFunctors_；
  • 如果当前线程不是 loop 线程，或者当前正在执行其他任务，就通过 wakeup() 唤醒事件循环线程。

提示

为什么需要唤醒？

因为 EventLoop 可能正在 poll() 阻塞，如果不唤醒，新的任务就会被延迟执行。

6. wakeup()

EventLoop.h
void wakeup();

wakeup() 的作用是向 wakeupFd_ 写入一个整数，从而让 wakeupChannel_ 变成可读状态。

它的本质：wakeupFd_ 是一个 eventfd，只要往里写数据，就会触发读事件，wakeupChannel_ 监听到读事件后，会调用 handleRead()，这样就能打断阻塞中的 epll_wait()，这是一种线程间通知机制。

7. handleRead()

EventLoop.h
void handleRead();

handleRead() 是 wakeupChannel_ 的读回调。

它从 wakeupFd_ 中读出 8 字节数据，清除 eventfd 的可读状态，让后续唤醒通知可以继续正常工作。

提示

为什么必须读掉？

因为如果不读，wakeupFd_ 会一直保持可读状态，epoll_wait() 会不断返回，造成空转。

8. updateChannel(Channel *channel)

EventLoop.h
void updateChannel(Channel *channel);

EventLoop 本身不直接处理 epoll，它只是把工作转交给 Poller。

这个函数的作用就是： 把 Channel 的状态更新请求交给 Poller 去做。

9. removeChannel(Channel *channel)

EventLoop.h
void removeChannel(Channel *channel);

和 updateChannel() 类似，removeChannel() 也是把删除 Channel 的动作交给 Poller 去完成。

10. hasChannel(Channel *channel)

EventLoop.h
bool hasChannel(Channel *channel);

这个函数通常用于判断某个 Channel 是否已经被当前 EventLoop 管理。 它本质上会转发给 Poller::hasChannel()。

EventLoop 的线程判断

EventLoop.h
bool isInLoopThread() const { return threadId_ == CurrentThread::tid(); }

这个函数用于判断当前调用是否发生在 EventLoop 自己的线程中。

提示

为什么要判断线程？

因为 muduo 的设计是 one loop per thread，很多操作必须在所属线程中完成。

例如：

  • 直接执行回调；
  • 修改 Channel；
  • 操作 Poller。

如果不在所属线程中，就需要用 queueInLoop() / wakeup() 来跨线程投递任务。

EventLoop 和 Poller、Channel 的关系

可以这样理解：

Channel 保存：

  • fd
  • 感兴趣事件
  • 实际发生事件
  • 回调函数

Poller 负责：

  • 把 Channel 注册到内核事件监听器
  • 等待事件发生
  • 把活跃 Channel 收集回来

EventLoop 负责：

  • 驱动 Poller::poll()
  • 遍历活跃 Channel
  • 调用 Channel::handleEvent()
  • 执行跨线程投递的回调任务 EventLoop 的整体运行流程

1. 创建阶段

EventLoop loop;

会做这些事：

  • 创建 Poller
  • 创建 eventfd
  • 创建 wakeupChannel_
  • 注册 handleRead() 回调
  • 开始监听 wakeupFd_

2. 循环阶段

调用：

  • loop.loop();

后会进入死循环：

  • poller_->poll() 等待事件；
  • 收集活跃 Channel；
  • 执行 channel->handleEvent()；
  • 执行 doPendingFunctors()。

3. 任务投递阶段

其他线程可以调用 loop.queueInLoop(cb); 把任务交给该 EventLoop 所在线程执行。

如果 EventLoop 正在阻塞，就通过 wakeup() 把它唤醒。

4. 退出阶段

调用 loop.quit(); 后，EventLoop 会在合适的时机退出 loop()。

总结

EventLoop 的核心职责

  • 驱动事件循环
  • 调用 Poller 等待事件
  • 分发事件给 Channel
  • 执行跨线程任务
  • 提供线程安全的任务投递机制
  • 使用 eventfd 实现线程唤醒

EventLoop 就像一个“总调度员”：

  • Poller 负责把“发生了什么”告诉它；
  • Channel 负责把“事件发生后怎么处理”准备好；
  • EventLoop 负责把整个流程串起来；

如果别的线程想插队干活，就通过 queueInLoop() 和 wakeup() 通知它。

EventLoop 是 Reactor 的心脏，Poller 是耳朵，Channel 是手脚，wakeupFd_ 则是跨线程的“门铃”。

EventLoop 源码

EventLoop.h
#pragma once

#include <functional>
#include <vector>
#include <atomic>
#include <memory>
#include <mutex>

#include "noncopyable.h"
#include "Timestamp.h"
#include "CurrentThread.h"

class Channel;
class Poller;

// 事件循环类 主要包含了两个大模块 Channel Poller(epoll的抽象)
class EventLoop : noncopyable
{
public:
    using Functor = std::function<void()>;

    EventLoop();
    ~EventLoop();

    // 开启事件循环
    void loop();
    // 退出事件循环
    void quit();

    Timestamp pollReturnTime() const { return pollRetureTime_; }

    // 在当前loop中执行
    void runInLoop(Functor cb);
    // 把上层注册的回调函数cb放入队列中 唤醒loop所在的线程执行cb
    void queueInLoop(Functor cb);

    // 通过eventfd唤醒loop所在的线程
    void wakeup();

    // EventLoop的方法 => Poller的方法
    void updateChannel(Channel *channel);
    void removeChannel(Channel *channel);
    bool hasChannel(Channel *channel);

    // 判断EventLoop对象是否在自己的线程里
    bool isInLoopThread() const { return threadId_ == CurrentThread::tid(); } // threadId_为EventLoop创建时的线程id CurrentThread::tid()为当前线程id

private:
    void handleRead();        // 给eventfd返回的文件描述符wakeupFd_绑定的事件回调 当wakeup()时 即有事件发生时 调用handleRead()读wakeupFd_的8字节 同时唤醒阻塞的epoll_wait
    void doPendingFunctors(); // 执行上层回调

    using ChannelList = std::vector<Channel *>;

    std::atomic_bool looping_; // 原子操作 底层通过CAS实现
    std::atomic_bool quit_;    // 标识退出loop循环

    const pid_t threadId_; // 记录当前EventLoop是被哪个线程id创建的 即标识了当前EventLoop的所属线程id

    Timestamp pollRetureTime_; // Poller返回发生事件的Channels的时间点
    std::unique_ptr<Poller> poller_;

    int wakeupFd_; // 作用：当mainLoop获取一个新用户的Channel 需通过轮询算法选择一个subLoop 通过该成员唤醒subLoop处理Channel
    std::unique_ptr<Channel> wakeupChannel_;

    ChannelList activeChannels_; // 返回Poller检测到当前有事件发生的所有Channel列表

    std::atomic_bool callingPendingFunctors_; // 标识当前loop是否有需要执行的回调操作
    std::vector<Functor> pendingFunctors_;    // 存储loop需要执行的所有回调操作
    std::mutex mutex_;                        // 互斥锁 用来保护上面vector容器的线程安全操作
};