目录
一、 Poller.h
1. Poller 类的整体定位与核心设计目标
2. 核心成员变量解析
1. 私有成员：所属 EventLoop（线程安全核心）
2. 保护成员：fd 到 Channel 的映射（核心管理结构）
3. 公共类型别名：活跃 Channel 列表
3. 核心接口逐模块拆解
1. 构造 / 析构：绑定 EventLoop + 抽象析构
2. 核心纯虚函数：IO 多路复用核心接口（子类必须实现）
3. 辅助接口：检查 Channel 是否存在
4. 静态工厂方法：创建默认 Poller（多态核心）
5. 线程安全校验：强制在 Loop 线程执行
4. 核心设计亮点总结
二、 Poller.h
1. 代码整体核心逻辑回顾
2. 逐函数拆解核心实现
1. 构造函数：绑定所属 EventLoop（线程安全基础）
2. 析构函数：默认析构（基类无资源管理）
3. hasChannel：校验 Channel 是否在 Poller 管理范围内（核心）
1. 线程安全校验（assertInLoopThread()）
2. fd 查找（channels_.find(channel->fd())）
3. 指针一致性验证（it->second == channel）
3. 核心设计亮点总结
总结
一、 Poller.h
先贴出完整代码，再逐部分解释：
// Copyright 2010, Shuo Chen. All rights reserved. // http://code.google.com/p/muduo/ // // 本源代码的使用受 BSD 风格许可证约束 // 该许可证可在 License 文件中查阅。 // 作者：陈硕 (chenshuo at chenshuo dot com) // // 这是一个内部头文件，你不应该直接包含它。 #ifndef MUDUO_NET_POLLER_H #define MUDUO_NET_POLLER_H #include <map> #include <vector> #include "muduo/base/Timestamp.h" // 时间戳类（记录 poll 返回的时间） #include "muduo/net/EventLoop.h" // EventLoop 前向声明（Poller 所属的事件循环） namespace muduo { namespace net { class Channel; // 前向声明：Poller 管理的事件通道类 /// /// IO 多路复用的抽象基类 /// /// 核心特性：1. 非拷贝（禁止拷贝 Poller 实例）；2. 不持有 Channel 对象的所有权； /// 3. 所有接口必须在所属 EventLoop 的线程中调用；4. 定义 IO 多路复用的核心接口， /// 由派生类（如 EpollPoller/PollPoller）实现具体的 epoll/poll 逻辑 class Poller : noncopyable { public: /// 活跃 Channel 列表类型：存储触发事件的 Channel 指针 typedef std::vector<Channel*> ChannelList; /// 构造函数：绑定所属的 EventLoop /// @param loop Poller 所属的 EventLoop（一个 Poller 仅属于一个 EventLoop） Poller(EventLoop* loop); /// 虚析构函数：确保派生类析构时正确调用自身析构函数 virtual ~Poller(); /// 轮询（等待）IO 事件 /// 核心约束：必须在 EventLoop 所属线程调用 /// @param timeoutMs 超时时间（毫秒，-1=无限等待，0=非阻塞） /// @param activeChannels 输出参数，存储触发事件的活跃 Channel 列表 /// @return 实际轮询返回的时间戳（用于计算事件处理耗时） virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels) = 0; /// 更新 Channel 关注的 IO 事件（注册/修改事件） /// 核心约束：必须在 EventLoop 所属线程调用 /// @param channel 要更新的 Channel 对象（Poller 不持有其所有权） virtual void updateChannel(Channel* channel) = 0; /// 移除 Channel（取消所有事件关注并删除映射） /// 调用时机：Channel 析构时 /// 核心约束：必须在 EventLoop 所属线程调用 /// @param channel 要移除的 Channel 对象 virtual void removeChannel(Channel* channel) = 0; /// 检查 Poller 是否管理指定的 Channel /// @param channel 要检查的 Channel 对象 /// @return true=已管理；false=未管理 virtual bool hasChannel(Channel* channel) const; /// 工厂方法：创建默认的 Poller 实例（根据系统环境选择 EpollPoller 或 PollPoller） /// @param loop Poller 所属的 EventLoop /// @return 指向 Poller 派生类实例的指针 static Poller* newDefaultPoller(EventLoop* loop); /// 断言当前线程是 Poller 所属 EventLoop 的线程（保证线程安全） /// 若断言失败，程序终止并输出错误信息 void assertInLoopThread() const { ownerLoop_->assertInLoopThread(); } protected: /// Channel 映射表：fd → Channel*，快速通过文件描述符找到对应的 Channel /// 核心作用：避免遍历所有 Channel，提升事件分发效率 typedef std::map<int, Channel*> ChannelMap; ChannelMap channels_; private: /// Poller 所属的 EventLoop（一个 Poller 绑定唯一的 EventLoop） EventLoop* ownerLoop_; }; } // namespace net } // namespace muduo #endif // MUDUO_NET_POLLER_H1. Poller 类的整体定位与核心设计目标
Poller是 Muduo Reactor 模型中IO 多路复用层的抽象基类，核心设计目标：
- 接口统一：为 epoll/poll/kqueue 等不同 IO 多路复用实现定义统一的抽象接口，上层（EventLoop）无需关心底层具体用哪种多路复用器；
- 解耦 EventLoop 与多路复用实现：EventLoop 仅依赖 Poller 抽象接口，可无缝切换 epoll/poll 等实现，符合 “开闭原则”；
- 线程安全约束：所有操作必须在 EventLoop 所属线程执行，通过
assertInLoopThread强制校验； - 非持有设计：仅管理 fd 到 Channel 的映射（
channels_），不持有 Channel 对象的生命周期（Channel 由上层如 TcpConnection/Acceptor 管理）。
在 Muduo 架构中，Poller 是 EventLoop 的 “核心依赖”：
EventLoop → 持有 Poller 对象 → Poller（epoll/poll）监听 fd 事件 → 触发 Channel::handleEventEventLoop 调用 Poller 的poll方法等待 IO 事件，Poller 填充活跃 Channel 列表后，EventLoop 遍历执行 Channel 的事件回调。
2. 核心成员变量解析
1. 私有成员：所属 EventLoop（线程安全核心）
private: EventLoop* ownerLoop_; // Poller 所属的 EventLoop（一个 Poller 仅属于一个 EventLoop）- 核心作用：通过
ownerLoop_->assertInLoopThread()确保所有 Poller 操作都在 EventLoop 线程执行，避免多线程操作导致的状态混乱； - 生命周期绑定：Poller 由 EventLoop 创建，与 EventLoop 同生命周期。
2. 保护成员：fd 到 Channel 的映射（核心管理结构）
protected: typedef std::map<int, Channel*> ChannelMap; ChannelMap channels_; // fd → Channel* 的映射，管理所有关注的 Channel- 设计逻辑：每个 fd 对应一个 Channel，Poller 通过 fd 快速找到对应的 Channel，在事件发生时调用 Channel::handleEvent；
- 访问权限：
protected允许子类（如 EPollPoller/PollPoller）直接访问，提升操作效率； - 非持有语义：
channels_中存储的是 Channel 指针，Poller 不负责 Channel 的创建 / 析构，仅做 “关联映射”。
3. 公共类型别名：活跃 Channel 列表
public: typedef std::vector<Channel*> ChannelList; // 活跃 Channel 列表类型作用：poll方法的输出参数类型，Poller 等待到 IO 事件后，将触发事件的 Channel 指针填充到该列表，供 EventLoop 遍历处理。
3. 核心接口逐模块拆解
1. 构造 / 析构：绑定 EventLoop + 抽象析构
Poller(EventLoop* loop); // 构造：绑定所属的 EventLoop virtual ~Poller(); // 虚析构：确保子类析构时调用正确的析构函数- 虚析构必要性：Poller 是抽象基类，子类（如 EPollPoller）通过基类指针析构时，必须调用子类析构函数，避免内存泄漏；
- 构造约束：Poller 必须与一个 EventLoop 绑定，且生命周期由 EventLoop 管理。、
2. 核心纯虚函数：IO 多路复用核心接口（子类必须实现）
这是 Poller 作为抽象基类的核心，定义了所有 IO 多路复用器必须实现的 “契约”：
/// 等待 IO 事件，超时时间 timeoutMs（毫秒），填充活跃 Channel 列表 /// 必须在 Loop 线程调用，返回值为 Poller 唤醒的时间戳（用于 EventLoop 计时） virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels) = 0; /// 更新 Channel 的关注事件（新增/修改） /// 必须在 Loop 线程调用（如 Channel::enableReading 最终调用此方法） virtual void updateChannel(Channel* channel) = 0; /// 移除 Channel（停止监听该 fd 的事件） /// 必须在 Loop 线程调用（如 Channel::remove 最终调用此方法） virtual void removeChannel(Channel* channel) = 0;- 纯虚函数意义：强制子类（EPollPoller/PollPoller）实现具体逻辑，保证接口统一；
- 线程约束：所有方法必须在 EventLoop 线程执行，避免多线程修改 Poller 状态（如 epoll_ctl 并发调用）。
3. 辅助接口：检查 Channel 是否存在
virtual bool hasChannel(Channel* channel) const;- 核心逻辑：遍历
channels_，检查是否存在channel->fd()对应的映射，返回 bool； - 应用场景：EventLoop 析构时校验是否所有 Channel 已移除，避免泄漏。
4. 静态工厂方法：创建默认 Poller（多态核心）
static Poller* newDefaultPoller(EventLoop* loop);- 核心作用：工厂模式，根据系统环境创建默认的 Poller 实现（Linux 下优先创建 EPollPoller，其他系统如 BSD 下创建 KQueuePoller，无 epoll/kqueue 则创建 PollPoller）；
- 上层价值：EventLoop 只需调用
newDefaultPoller，无需关心底层用 epoll 还是 poll，实现 “接口与实现分离”。
5. 线程安全校验：强制在 Loop 线程执行
void assertInLoopThread() const { ownerLoop_->assertInLoopThread(); // 调用 EventLoop 的线程校验方法 }- 实现逻辑：
EventLoop::assertInLoopThread会检查当前线程是否是 EventLoop 的创建线程，不是则终止进程； - 核心价值：通过断言强制所有 Poller 操作在 Loop 线程执行，避免多线程操作 epoll fd 等导致的未定义行为。
4. 核心设计亮点总结
| 设计点 | 解决的问题 | 价值 |
|---|---|---|
| 抽象基类 + 纯虚函数 | 不同 IO 多路复用器（epoll/poll）接口不统一，上层需适配 | 定义统一契约，上层（EventLoop）无需关心具体实现，可无缝切换多路复用器 |
| 非持有 Channel 设计 | Poller 持有 Channel 会导致生命周期混乱（如 Channel 析构时 Poller 还引用） | 仅管理 fd 映射，Channel 生命周期由上层掌控，解耦资源管理 |
| 线程安全强制校验 | 多线程调用 epoll_ctl 等系统调用导致状态混乱 | 断言确保所有操作在 Loop 线程执行，避免并发问题 |
| 静态工厂方法（newDefaultPoller） | 上层需手动选择 Poller 实现，耦合度高 | 工厂模式隐藏实现细节，适配不同系统，符合 “开闭原则” |
| fd → Channel 映射（ChannelMap） | 事件发生时无法快速找到对应的 Channel | O (1) 时间通过 fd 找到 Channel，提升事件分发效率 |
二、 Poller.h
先贴出完整代码，再逐部分解释：
// Copyright 2010, Shuo Chen. All rights reserved. // http://code.google.com/p/muduo/ // // 本源代码的使用受 BSD 风格许可证约束 // 该许可证可在 License 文件中查阅。 // 作者：陈硕 (chenshuo at chenshuo dot com) #include "muduo/net/Poller.h" #include "muduo/net/Channel.h" // Channel 类（获取 fd、校验指针） using namespace muduo; using namespace muduo::net; /// 构造函数：初始化 Poller 所属的 EventLoop /// @param loop Poller 绑定的 EventLoop（一个 Poller 仅属于一个 EventLoop） Poller::Poller(EventLoop* loop) : ownerLoop_(loop) // 初始化成员变量，绑定所属的 EventLoop { } /// 析构函数：使用默认实现 /// 原因：Poller 是抽象基类，无需要手动释放的资源（channels_ 是 std::map，自动析构）； /// 派生类（如 EpollPoller）的析构逻辑由自身实现，基类无需处理 Poller::~Poller() = default; /// 检查 Poller 是否管理指定的 Channel 对象 /// 核心逻辑：1. 校验调用线程（必须是 EventLoop 线程）；2. 通过 fd 查找 Channel； /// 3. 校验找到的 Channel 指针与传入指针一致（防止 fd 复用导致的错误匹配） /// @param channel 要检查的 Channel 对象指针 /// @return true=Poller 正在管理该 Channel；false=未管理 bool Poller::hasChannel(Channel* channel) const { assertInLoopThread(); // 断言：当前线程是 Poller 所属 EventLoop 的线程（保证线程安全） // 1. 通过 Channel 的 fd 在 channels_ 映射表中查找 ChannelMap::const_iterator it = channels_.find(channel->fd()); // 2. 双重校验： // - 查找结果不为 end（fd 存在于映射表）； // - 映射表中存储的 Channel 指针与传入指针完全一致（避免 fd 复用导致的误判） return it != channels_.end() && it->second == channel; }1. 代码整体核心逻辑回顾
Poller.cpp是 Poller 抽象基类的基础实现，仅包含无业务逻辑的通用接口：
- 构造函数：完成与 EventLoop 的绑定，是 Poller 线程安全的基础；
- 析构函数：使用默认析构（
= default），因为基类无需要手动释放的资源（子类如 EPollPoller 会管理自身资源，如 epoll fd）； hasChannel：核心是 “线程校验 + fd 查找 + 指针一致性验证”，确保 fd 与 Channel 的映射关系准确，避免 fd 复用导致的错误。
2. 逐函数拆解核心实现
1. 构造函数：绑定所属 EventLoop（线程安全基础）
Poller::Poller(EventLoop* loop) : ownerLoop_(loop) // 初始化：将Poller绑定到指定的EventLoop { }核心设计点：
- 极简实现：仅完成
ownerLoop_的赋值，确保一个 Poller 唯一归属一个 EventLoop； - 生命周期约束：Poller 由 EventLoop 创建，
ownerLoop_指向创建它的 EventLoop，后续所有操作的线程校验都依赖这个指针； - 无其他逻辑：基类不涉及任何具体的多路复用资源（如 epoll fd），这些都由子类（如 EPollPoller）在构造时初始化。
2. 析构函数：默认析构（基类无资源管理）
Poller::~Poller() = default;关键设计原因：
- 抽象基类无资源需要释放：Poller 仅管理
channels_（fd→Channel* 映射），但channels_存储的是指针（不持有 Channel 生命周期），且无其他系统资源（如 epoll fd、poll fd）—— 这些资源由子类（如 EPollPoller）管理，子类会实现自己的析构函数（如关闭 epoll fd）； = default优势：显式使用默认析构，既符合 C++11 规范，又明确表示基类无需手动处理析构逻辑，避免冗余代码。
3. hasChannel：校验 Channel 是否在 Poller 管理范围内（核心）
bool Poller::hasChannel(Channel* channel) const { // 第一步：线程安全校验——确保调用在EventLoop线程执行 assertInLoopThread(); // 第二步：根据Channel的fd查找映射 ChannelMap::const_iterator it = channels_.find(channel->fd()); // 第三步：双重验证——不仅要找到fd，还要确保映射的Channel指针与传入的一致 return it != channels_.end() && it->second == channel; }核心逻辑拆解：
1. 线程安全校验（assertInLoopThread()）
调用ownerLoop_->assertInLoopThread()，检查当前线程是否是 EventLoop 的创建线程：
- 如果不是，会触发断言失败并终止进程；
- 必要性：
channels_是非线程安全的 std::map，仅能在 EventLoop 线程操作，避免多线程并发修改 / 查找导致的容器错乱。
2. fd 查找（channels_.find(channel->fd())）
通过 Channel 持有的 fd，在channels_（fd→Channel* 映射）中查找对应的条目：
- 如果
find返回channels_.end()，说明该 fd 未被 Poller 管理，直接返回 false； - 如果找到 fd 条目，还需要执行第三步验证（关键！）。
3. 指针一致性验证（it->second == channel）
这是最容易被忽略但至关重要的一步，目的是解决「fd 复用」问题：
- 场景举例：fd 5 原本绑定到 Channel A，Channel A 被移除后，fd 5 被关闭并重新分配给新的 Channel B；此时
channels_.find(5)可能找到旧的映射（如果未及时删除），或新的映射（Channel B），必须验证指针是否与传入的 Channel 一致； - 价值：确保返回的 “fd 存在” 是「指定的 Channel」对应的 fd，而非复用的 fd，避免将事件分发到错误的 Channel。
3. 核心设计亮点总结
| 设计点 | 解决的问题 | 价值 |
|---|---|---|
| 构造函数仅绑定 EventLoop | 基类无需关心具体多路复用实现，聚焦通用逻辑 | 符合 “单一职责”，基类只做抽象和通用管理，子类做具体实现 |
| 默认析构函数 | 基类无资源需要释放，避免冗余的空析构 | 简化代码，明确基类的资源管理边界 |
| hasChannel 的双重验证（fd + 指针） | fd 复用导致的 “fd 存在但 Channel 不匹配” 错误 | 保证映射关系的准确性，避免事件分发到错误的 Channel |
| 强制线程校验 | 多线程操作非线程安全的 ChannelMap | 从源头避免并发问题，保证 Poller 操作的线程安全 |
总结
- 构造核心：Poller 构造仅绑定所属 EventLoop，是后续线程安全校验的基础；
- 析构设计：基类用默认析构，因为无资源需要释放，子类负责自身资源（如 epoll fd）的清理；
- hasChannel 关键：先校验线程，再查找 fd，最后验证 Channel 指针一致性 —— 既保证线程安全，又避免 fd 复用导致的映射错误；
- 极简原则：基类仅实现通用逻辑，不涉及具体多路复用操作，符合抽象基类的设计初衷。
