13.多路转接epoll【由浅入深-网络】

文章目录

  • [第一章 从 select 到 poll:多路转接的破局与演进](#第一章 从 select 到 poll:多路转接的破局与演进)
    • [1 历史的包袱:为什么我们需要抛弃 select?](#1 历史的包袱:为什么我们需要抛弃 select?)
    • [2 poll 的诞生:解耦与突破](#2 poll 的诞生:解耦与突破)
      • [2.1 poll 函数原型全解](#2.1 poll 函数原型全解)
      • [2.2 核心结构体 struct pollfd:输入输出的优雅解耦](#2.2 核心结构体 struct pollfd:输入输出的优雅解耦)
      • [2.3 深入底层:为什么事件是 short 类型?](#2.3 深入底层:为什么事件是 short 类型?)
    • [3 深入内核:poll 的底层运转机制与源码剖析](#3 深入内核:poll 的底层运转机制与源码剖析)
      • [3.1 巧妙的内存管理:poll_list 链表与柔性数组](#3.1 巧妙的内存管理:poll_list 链表与柔性数组)
      • [3.2 核心阻塞逻辑:do_poll 源码全景解构与 O(N) 噩梦](#3.2 核心阻塞逻辑:do_poll 源码全景解构与 O(N) 噩梦)
      • [3.3 痛点总结与前瞻:为什么必须要造 epoll?](#3.3 痛点总结与前瞻:为什么必须要造 epoll?)
    • [4手撕 poll 内核极简引擎](#4手撕 poll 内核极简引擎)
      • [4.1 核心组件与底层驱动的抽象](#4.1 核心组件与底层驱动的抽象)
      • [4.2 核心运转引擎:do_poll 代码重现](#4.2 核心运转引擎:do_poll 代码重现)
      • [4.3 用户态链路联调与运行推演](#4.3 用户态链路联调与运行推演)
    • 补充:poll的使用示例
  • [第二章 从 select 到 poll:基于结构体数组的事件通知与派发](#第二章 从 select 到 poll:基于结构体数组的事件通知与派发)
    • [1 架构设计:poll 事件驱动模型全景解构](#1 架构设计:poll 事件驱动模型全景解构)
      • [1.1 事件源与注册表 (The Registry)](#1.1 事件源与注册表 (The Registry))
      • [1.2 统一监听器与派发器 (Listener & Dispatcher)](#1.2 统一监听器与派发器 (Listener & Dispatcher))
      • [1.3 业务处理器 (Accepter & Recver)](#1.3 业务处理器 (Accepter & Recver))
    • [2 核心业务流:一次完整的事件流转推演](#2 核心业务流:一次完整的事件流转推演)
    • [3 工业级 Poll 服务器全组件源码实战](#3 工业级 Poll 服务器全组件源码实战)
      • [3.1 基础组件:锁机制与高吞吐日志系统](#3.1 基础组件:锁机制与高吞吐日志系统)
      • [3.2 网络底层基建:地址与套接字封装](#3.2 网络底层基建:地址与套接字封装)
      • [3.3 核心引擎:PollServer 与事件驱动落地](#3.3 核心引擎:PollServer 与事件驱动落地)
      • [3.4 编译与联调测试](#3.4 编译与联调测试)
    • [4 终极拷问:poll 真的完美了吗?](#4 终极拷问:poll 真的完美了吗?)
  • [第三章 性能之巅:epoll 的降维打击与大并发破局](#第三章 性能之巅:epoll 的降维打击与大并发破局)
    • [1 初识 epoll:为海量并发而生的终极杀器](#1 初识 epoll:为海量并发而生的终极杀器)
    • [2 撕裂历史的 API 设计:epoll 的三大系统调用全解](#2 撕裂历史的 API 设计:epoll 的三大系统调用全解)
      • [2.1 epoll_create:在内核态圈地,搭建"专属监控室"](#2.1 epoll_create:在内核态圈地,搭建“专属监控室”)
      • [2.2 epoll_ctl:告别全量拷贝,O(log N) 的精准"增删改"](#2.2 epoll_ctl:告别全量拷贝,O(log N) 的精准“增删改”)
        • [2.2.1 深入解析 struct epoll_event 与黑魔法 union](#2.2.1 深入解析 struct epoll_event 与黑魔法 union)
      • [2.3 epoll_wait:坐享其成的 O(1) 盲盒收割](#2.3 epoll_wait:坐享其成的 O(1) 盲盒收割)
    • [3 epoll 原理:红黑树、就绪队列与回调通知机制](#3 epoll 原理:红黑树、就绪队列与回调通知机制)
      • [3.1 epoll_create:在内核中拔地而起的 eventpoll 监控室与等待队列](#3.1 epoll_create:在内核中拔地而起的 eventpoll 监控室与等待队列)
      • [3.2 epoll_ctl 与 struct epitem:红黑树上的哨兵节点](#3.2 epoll_ctl 与 struct epitem:红黑树上的哨兵节点)
        • [3.2.0 epoll_ctl 在做什么](#3.2.0 epoll_ctl 在做什么)
        • [3.2.1 epitem 结构](#3.2.1 epitem 结构)
        • [3.2.2 身份字段:一个节点,三种挂法](#3.2.2 身份字段:一个节点,三种挂法)
          • [身份 1:`rbn` ------ 红黑树节点](#身份 1:rbn —— 红黑树节点)
          • [身份 2:`rdllink` ------ 就绪链表节点](#身份 2:rdllink —— 就绪链表节点)
          • 关键点:挂就绪链表时,**不从红黑树删除**
          • [身份 3:`ovflist_next` ------ 扫描期间的暂存链表](#身份 3:ovflist_next —— 扫描期间的暂存链表)
        • [3.2.3 标识字段:`epoll_key ffd`](#3.2.3 标识字段:epoll_key ffd)
          • [为什么 key 不用 fd,而用 (file, fd)?](#为什么 key 不用 fd,而用 (file, fd)?)
        • [3.2.4 业务字段](#3.2.4 业务字段)
        • [3.2.5 完整流程](#3.2.5 完整流程)
      • [3.3 核心魔法:从硬件中断到 ep_poll_callback 的全链路回调机制](#3.3 核心魔法:从硬件中断到 ep_poll_callback 的全链路回调机制)
        • [3.3.0 先搞清这一节要解决什么问题](#3.3.0 先搞清这一节要解决什么问题)
        • [3.3.1 第一阶段:埋雷(epoll_ctl 时安装探针)](#3.3.1 第一阶段:埋雷(epoll_ctl 时安装探针))
        • [3.3.2 第二阶段:引爆(网卡收包 → 数据进 Socket)](#3.3.2 第二阶段:引爆(网卡收包 → 数据进 Socket))
        • [3.3.3 第三阶段:收网(协议栈调用回调)](#3.3.3 第三阶段:收网(协议栈调用回调))
        • [3.3.4 ep_poll_callback 做了什么](#3.3.4 ep_poll_callback 做了什么)
        • [3.3.5 为什么说这是 O(1)](#3.3.5 为什么说这是 O(1))
        • [3.3.6 全链路一张图](#3.3.6 全链路一张图)
      • [3.4 epoll_wait:精准收割与 ovflist 护航](#3.4 epoll_wait:精准收割与 ovflist 护航)
      • [补充 :拔除暗桩,不用了直接 close(fd) 行不行?](#补充 :拔除暗桩,不用了直接 close(fd) 行不行?)
      • [3.5 LT 与 ET 的底层状态抉择](#3.5 LT 与 ET 的底层状态抉择)
      • [补充 :epoll 的工作模式,LT 与 ET 的底层抉择](#补充 :epoll 的工作模式,LT 与 ET 的底层抉择)
        • [1 暴躁的李四与卑微的张三:一秒看懂 LT 与 ET](#1 暴躁的李四与卑微的张三:一秒看懂 LT 与 ET)
        • [2 剥开表象看本质:什么是通知?](#2 剥开表象看本质:什么是通知?)
        • [3 倒逼出的极限编程:ET 模式与非阻塞循环](#3 倒逼出的极限编程:ET 模式与非阻塞循环)
        • [4 为什么顶级框架(如 Nginx)钟爱 ET 模式?](#4 为什么顶级框架(如 Nginx)钟爱 ET 模式?)
      • [3.6 辟谣与修正:epoll 的时间复杂度真的是绝对的 O(1) 吗?](#3.6 辟谣与修正:epoll 的时间复杂度真的是绝对的 O(1) 吗?)
      • [3.7 终极流转图:epoll 的六步生命周期闭环](#3.7 终极流转图:epoll 的六步生命周期闭环)
    • epoll示例代码
  • [第四章 基于 epoll 的 Reactor 网络计算器:从事件派发到协议处理](#第四章 基于 epoll 的 Reactor 网络计算器:从事件派发到协议处理)
    • [1 架构降维:Reactor 模型到底在干什么?](#1 架构降维:Reactor 模型到底在干什么?)
      • [1.1 为什么 Reactor 必须维护一个 Connection 映射表?](#1.1 为什么 Reactor 必须维护一个 Connection 映射表?)
      • [1.2 为什么 Listener 和 IOManager 都要继承 Connection?](#1.2 为什么 Listener 和 IOManager 都要继承 Connection?)
      • [1.3 必死铁律:为什么 ET 模式必须强绑定非阻塞(Non-Block)?](#1.3 必死铁律:为什么 ET 模式必须强绑定非阻塞(Non-Block)?)
    • [2 Calculator.hpp:绝对纯净的业务计算引擎](#2 Calculator.hpp:绝对纯净的业务计算引擎)
    • [3 Comm.hpp:公共基础设施与非阻塞魔改](#3 Comm.hpp:公共基础设施与非阻塞魔改)
    • [4 Connection.hpp:万物皆可连接的统一抽象](#4 Connection.hpp:万物皆可连接的统一抽象)
    • [5 Epoller.hpp:内核事件系统的面向对象封装](#5 Epoller.hpp:内核事件系统的面向对象封装)
    • [6 InetAddr & Socket:网络底层兵工厂](#6 InetAddr & Socket:网络底层兵工厂)
      • [6.1 InetAddr.hpp(地址洗牌机制)](#6.1 InetAddr.hpp(地址洗牌机制))
      • [6.2 Socket.hpp(模板方法多态网络)](#6.2 Socket.hpp(模板方法多态网络))
    • [7 Reactor.hpp:掌控全局的事件派发大脑](#7 Reactor.hpp:掌控全局的事件派发大脑)
    • [8 Listener 与 IOManager:连接的具体打工人](#8 Listener 与 IOManager:连接的具体打工人)
      • [8.1 Listener.hpp(迎宾小哥)](#8.1 Listener.hpp(迎宾小哥))
      • [8.2 IOManager.hpp(包间服务员)](#8.2 IOManager.hpp(包间服务员))
    • [9 Protocol.hpp:降伏"面向字节流"的粘包凶兽](#9 Protocol.hpp:降伏“面向字节流”的粘包凶兽)
    • [10 骨架闭环:Main.cc 的惊艳组装](#10 骨架闭环:Main.cc 的惊艳组装)
    • [11 最终沙盘推演:单线程大心脏的完整跳动](#11 最终沙盘推演:单线程大心脏的完整跳动)
  • [第五章 Reactor 反应堆模式:从单事件循环到 One Thread One Loop](#第五章 Reactor 反应堆模式:从单事件循环到 One Thread One Loop)
    • [1 Reactor 解决的问题](#1 Reactor 解决的问题)
    • [2 epoll 与 Reactor 的关系](#2 epoll 与 Reactor 的关系)
    • [3 Reactor 四个核心对象](#3 Reactor 四个核心对象)
    • [4 Connection 与回调](#4 Connection 与回调)
    • [5 单 Reactor 完整运行流程](#5 单 Reactor 完整运行流程)
      • [5.1 accept 流程](#5.1 accept 流程)
      • [5.2 多执行单元 accept 的原子性](#5.2 多执行单元 accept 的原子性)
      • [5.3 recv 与协议处理](#5.3 recv 与协议处理)
      • [5.4 send 与 EPOLLOUT](#5.4 send 与 EPOLLOUT)
      • [5.5 连接删除](#5.5 连接删除)
    • [6 为什么不能直接把 fd 交给普通线程池?](#6 为什么不能直接把 fd 交给普通线程池?)
    • [7 OTOL:一个 fd 的唯一归属](#7 OTOL:一个 fd 的唯一归属)
    • [8 Master-Slave Reactor](#8 Master-Slave Reactor)
    • [9 为什么用户队列和条件变量不能直接解决问题?](#9 为什么用户队列和条件变量不能直接解决问题?)
    • [10 eventfd 统一等待模型](#10 eventfd 统一等待模型)
    • [11 SO_REUSEPORT 多进程模型](#11 SO_REUSEPORT 多进程模型)
    • [12 enable_shared_from_this 与生命周期](#12 enable_shared_from_this 与生命周期)
    • [13 总结](#13 总结)

第一章 从 select 到 poll:多路转接的破局与演进

在网络编程的底层世界里,任何一项技术的诞生,往往都是为了填补前代技术留下的巨大天坑。我们在学习多路转接(I/O Multiplexing)时,select 往往是第一课。作为初代的 I/O 多路转接机制,select 确实解决了"如何在一个线程内同时监控多个文件描述符(fd)"的问题。但随着并发量从几十、几百跃升至上万,select 底层设计的历史包袱直接成为了系统性能的致命瓶颈。

为了解决 select 的痼疾,poll 应运而生。poll 的本质依然是多路转接中的"等"------它不负责真正的数据搬迁,只负责监控文件描述符的状态。但相比于 select,poll 在接口和数据结构的设计上完成了一次优雅的重构。

1 历史的包袱:为什么我们需要抛弃 select?

在深入 poll 之前,我们必须先看清 select 到底存在哪些让人痛不欲生的设计缺陷。只有懂了旧架构的痛点,才能明白新架构设计的精妙之处。

select 的致命缺陷主要集中在以下三个方面:

  1. 输入输出参数高度耦合,导致重复初始化代价极高
    select 使用 fd_set 位图来传递需要监控的 fd。然而,这个位图既是输入参数 (用户告诉内核要监控哪些 fd),又是输出参数 (内核告诉用户哪些 fd 就绪了)。只要 select 一返回,内核就会把原来传入的 fd_set 无情地覆盖掉。这就导致了一个极度恶心的结果:程序员必须在每一次 while 循环调用 select 之前,重新遍历并全量设置一次 fd_set。
  2. 连接数存在硬上限(通常为 1024)
    fd_set 在内核中本质上是一个固定大小的结构体,大小由宏 FD_SETSIZE 决定,默认编译下通常是 1024。这意味着单个进程最多只能监控 1024 个 fd。在现代互联网动辄"C10K"(单机万级并发)的场景下,1024 的上限无异于螳臂当车。
  3. 无脑的 O(N) 循环遍历
    用户侧和内核侧在检查就绪状态时,都必须对所有被监控的 fd 进行线性遍历。监控 1000 个 fd,哪怕只有 1 个就绪,内核也要遍历 1000 次,用户层拿回结果后同样要遍历 1000 次来寻找这个幸运儿。这种随着连接数线性增长的开销,直接锁死了 select 的性能上限。

面对这些痛点,poll 率先站了出来。虽然它没有解决 O(N) 遍历的性能问题(这个终极难题留给了后来的 epoll) ,但它通过全新的数据结构设计,完美解决了参数耦合 和连接数上限这两个大麻烦。

2 poll 的诞生:解耦与突破

poll 的核心设计思想非常明确:放弃使用固定大小且读写耦合的 fd_set 位图,转而使用结构体数组来管理所有的文件描述符。

2.1 poll 函数原型全解

我们先来看 poll 的系统调用接口:

c 复制代码
#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

这个函数的参数极其精简,我们逐一拆解:

  • fds :这是一个指向 struct pollfd 结构体数组的指针。用户可以在堆上或者栈上开辟这块数组内存,想监控多少个 fd,就开多大的数组。这一举措直接打破了 select 1024 的硬性封锁。
  • nfds :表示第一个参数 fds 数组中有效元素的个数。
  • timeout :超时时间,单位是毫秒(ms)。
    • > 0:在指定的毫秒数内阻塞等待。如果期间有事件就绪,提前返回;超时无事件,返回 0。
    • == 0:非阻塞轮询,查一下 fd 的状态立刻返回,绝不等待。
    • < 0(通常传 -1):死等,阻塞挂起,直到有文件描述符就绪才返回。
  • poll 返回值 >0 表示有几个 fd 就绪,0 表示超时,在 timeout 时间内没有任何 fd 就绪;-1 表示出错;具体事件要看每个 pollfd.revents。

2.2 核心结构体 struct pollfd:输入输出的优雅解耦

poll 之所以能解决参数耦合的问题,全靠它定义的这个底层结构体 struct pollfd:

c 复制代码
struct pollfd {
    int   fd;         /* 需要监控的文件描述符 */
    short events;     /* 用户告诉内核:需要监控的事件 */
    short revents;    /* 内核告诉用户:实际就绪的事件 (returned events) */
};

这个结构体堪称接口设计的典范。它强行将"输入"和"输出"物理隔离:

  • events(输入) :这是用户层设置的。用户以此告诉内核:"操作系统老大哥,请帮我盯着这个 fd,我只关心它身上的读/写事件。"
  • revents(输出) :这是内核填写的。当 poll 返回时,内核会把该 fd 实际发生的事件写进 revents 里,绝对不会去篡改用户设置的 events。

这一设计的直接收益是 :当 poll 返回后,下一次循环继续调用 poll 时,我们再也不需要像 select 那样重新初始化参数了 。数组里的 events 依然原封不动,直接复用即可,极大地简化了用户的代码逻辑。

2.3 深入底层:为什么事件是 short 类型?

仔细观察 struct pollfd,你会发现代表事件的 events 和 revents 都是 short 类型。为什么要用 16 位的整型?这些所谓的"事件"在底层到底长什么样?

在 C 语言的系统级编程中,当我们有多个状态或标志需要同时表达时,最简单高效的做法不是定义多个布尔变量,而是使用位图(Bitmap) 。这里的 short 类型的本质,就是一个 16 位的二进制位图。

系统库底层通过宏定义了一系列事件标志位:

c 复制代码
#define POLLIN      0x0001    /* 0000 0000 0000 0001 : 有数据可读 */
#define POLLPRI     0x0002    /* 0000 0000 0000 0010 : 有紧急数据可读 */
#define POLLOUT     0x0004    /* 0000 0000 0000 0100 : 写操作不会阻塞 */
#define POLLERR     0x0008    /* 0000 0000 0000 1000 : 指定的 fd 发生错误 */
#define POLLHUP     0x0010    /* 0000 0000 0001 0000 : 对端挂断连接 */
// ... 等等

观察这些十六进制的宏,你会发现它们的值都是 2 的幂次方。换成二进制来看,每一个宏都独占一个特定的 bit 位为 1,其余全为 0。这就是最典型的"标志位"设计。

为什么是 short?

因为网络 I/O 关心的核心状态(读、写、错误、挂断等)屈指可数,16 个 bit 位完全绰绰有余。使用 short 既满足了功能需求,又最大程度压榨了内存空间(对于需要传入数十万个元素的数组来说,节省几个字节意义重大)。

底层是如何通过位图传递和检查标志位的?

  • 用户层的设置(按位或 |) :
    如果我不仅想知道一个 fd 能不能读,还想知道能不能写,怎么办?很简单,使用按位或操作把标志位合并。
    fds[0].events = POLLIN | POLLOUT;
    (底层二进制变为 0000 0000 0000 0101,第 0 位和第 2 位同时为 1,内核收到后秒懂:你要同时监控读和写)。
  • 内核侧的反馈与用户检查(按位与 &) :
    当 poll 成功返回后,用户如何知道具体是哪个事件就绪了?这就需要拿内核返回的 revents 和对应的宏进行按位与操作。
    如果 fds[0].revents & POLLIN 的结果为真(非0),则说明读事件就绪了。因为只要 revents 里的第 0 位是 1,按位与出来的结果必定是 1。

通过这种"位图传递标志位"的极客玩法,poll 实现了参数的高效透传与隔离。至此,poll 成功解决了 select 的两座大山。但它依然没有逃脱 O(N) 遍历的魔咒:每次调用内核都要把所有的 pollfd 轮询一遍,用户态依然要遍历数组寻找 revents 非 0 的元素。

随着互联网时代的高速发展,系统需要面对海量的长连接(例如十万级并发),poll 的底层机制再度变得不堪重负。技术痛点的演进迫使 Linux 内核必须交出终极答案------这也是我们下一章将要解剖的神级机制:epoll。

3 深入内核:poll 的底层运转机制与源码剖析

很多同学看不懂 poll 的底层逻辑,是因为大部分资料跳过了一个最核心的灵魂拷问:当你的进程监控了 10 万个 fd 并陷入阻塞沉睡时,网卡收到数据后,是怎么知道该唤醒你的?进程被唤醒后,又是怎么知道哪几个 fd 来数据的?

要彻底搞懂这个过程,我们必须从内核的入口开始,沿着"内存分配 -> 核心轮询 -> 睡眠等待 -> 中断唤醒"这条完整的数据流向,把 poll 的底裤彻底扒掉。

3.1 巧妙的内存管理:poll_list 链表与柔性数组

当你在用户态调用 poll 时,传入的是一个 pollfd 数组的首地址和长度。假设你要监控 10 万个并发连接,这个数组的大小将达到 800KB(10万 × 8字节)。

系统调用进入内核态的第一步(sys_poll),就是要把这 800KB 的数据从用户空间拷贝到内核空间。但内核绝对不敢直接用 kmalloc 申请一块 800KB 的连续物理内存。 因为在长时间运行的服务器上,内存碎片化严重,申请大块连续内存极易失败,甚至导致内核崩溃。

为了解决这个"大数组安全拷贝"的问题,Linux 内核设计了一个极为精妙的数据结构:struct poll_list。内核决定把这 10 万个元素化整为零,按页(Page,通常4KB)进行分块存储。

来看底层核心源码:

c 复制代码
struct poll_list {
    struct poll_list *next;   // 指针:指向下一个 4KB 内存页
    int len;                  // 计数器:当前这个 4KB 页里,存了多少个 pollfd 元素
    struct pollfd entries[0]; // 🌟 核心黑魔法:柔性数组
};

用大白话拆解这里的硬核细节:

entries[0] 被称为柔性数组(Flexible Array) ,它是 C 语言底层开发的一大黑魔法。在计算 sizeof(struct poll_list) 时,它占用 0 个字节。它仅仅代表一个"内存地址偏移量的标号"。

内核具体是怎么搬运那 10 万个元素的?

  1. 栈上极速预判 :内核首先在当前进程的内核栈上预留了一块约 800 字节的小空间(能装下大约 30 个 pollfd)。如果你的并发量很小(比如就监控十几个 fd),内核直接用这块栈内存拷贝,不用向系统申请任何额外内存,速度拉满。
  2. 4KB 切片申请 :如果数量庞大(如 10 万),栈不够用了。内核就会向系统申请一个 4KB 的物理内存页。
  3. 头部占位与柔性填充 :内核在这个 4KB 页的最头部,强行转换出一个 struct poll_list 结构(占用十几个字节,包含 next 和 len)。接着,entries[0] 这个标号就刚好指向了头部之后的空白内存。内核利用这剩下的近 4KB 空间,能塞多少个 pollfd 就塞多少个,塞完后把数量写进 len。
  4. 链表串联 :一个 4KB 页面塞满后,如果还有数据,内核就再申请一个新的 4KB 页面,用上一个页面的 next 指针指向它。

最终,用户态那一整块庞大连续的 10 万个数组,在内核态变成了一条由 4KB 内存页串联起来的单向链表。这种做法完全避免了大块连续内存分配失败的风险,非常优雅。

3.2 核心阻塞逻辑:do_poll 源码全景解构与 O(N) 噩梦

数据安全搬运到内核后,真正的监控开始。代码会进入 do_poll 函数。这是整个 poll 机制的心脏,也是它后来被高并发时代淘汰的"罪魁祸首"。

在讲源码前,我们必须先理解一个底层因果:进程凭什么能被挂起?网卡凭什么能唤醒进程?

答案是:等待队列(Wait Queue)。Linux 中每一个文件/Socket 的底层,都自带一个等待队列。就像去餐厅排队拿号,你想等某个 Socket 来数据,你就必须把自己的进程"名字"写到那个 Socket 的等待队列本子上。

我们来看 do_poll 是怎么做这件事的(精简核心逻辑):

c 复制代码
static int do_poll(struct poll_list *list, struct poll_wqueues *wait, long timeout) {
    int count = 0; // 记录有多少个 fd 就绪了
    
    // 🌟 死循环开始
    for (;;) {
        // 第一重 O(N) 遍历:顺着刚刚建好的 4KB 页链表,一个一个往下找
        for (walk = list; walk != NULL; walk = walk->next) {
            
            // 遍历当前 4KB 页里的每一个 pollfd 元素
            for (i = 0; i < walk->len; i++) {
                struct pollfd * pfd = &walk->entries[i]; // 取出一个待监控的 fd
                
                // 🌟 核心动作:调用虚拟文件系统(VFS)底层的 poll 钩子函数
                // 对于网络套接字,这最终会调到 tcp_poll()
                mask = file->f_op->poll(file, wait);
                
                // 掩码比对:如果底层返回的就绪状态(mask) 包含了用户关心的事件(events)
                if (mask & pfd->events) {
                    pfd->revents = mask; // 把就绪状态写入 revents
                    count++;             // 就绪数量 +1,记录找到了一个!
                }
            }
        }

        // 🌟 跳出条件:如果找到至少1个就绪的fd,或者超时了,或者收到中断信号,立刻跳出循环返回
        if (count || timeout == 0 || signal_pending(current))
            break;

        // 🌟 沉睡挂起:如果遍历了整整 10 万个 fd,发现什么事都没发生!
        // 那么主动交出 CPU 的执行权,当前进程进入睡眠状态。
        // 直到被超时唤醒,或者被网卡硬中断唤醒!
        schedule_timeout(timeout);
    }
    
    return count; // 返回就绪的个数
}

这段代码到底揭示了怎样一幅绝望的画卷?我们一步步拆解:

第一步:盲目且沉重的排队(第一重 O(N) 遍历)

当 for 循环启动,内核开始遍历这 10 万个 fd。每次调用 file->f_op->poll(file, wait)(也就是 tcp_poll),其实是在做两件事:

  1. 排队登记 :把当前正在调用 poll 的进程,强行挂载到这 10 万个 Socket 的等待队列上。相当于告诉这 10 万个 Socket:"老哥,待会你们谁收到数据了,记得把我踹醒!"。
  2. 状态探查 :顺便看一下当前这个 Socket 有没有数据。如果没有,返回 0;如果有,返回掩码(如 POLLIN)。

第二步:绝望的沉睡(schedule_timeout)

如果这 10 万个 fd 全都没数据(高并发场景下这是常态,大部分是发呆的长连接),count 就是 0。此时进程调用 schedule_timeout,交出 CPU 陷入沉睡。

第三步:网卡发威,触发唤醒

突然,网卡收到了一条数据!网卡发起硬件中断 ,CPU 停下手中的活,通过 DMA 把数据拷入内存,经过网络协议栈层层解析,最终确认这包数据属于这 10 万个 Socket 中的某一个 。

此时,内核找到这个特定的 Socket,顺藤摸瓜找到它的等待队列,发现我们的进程正躺在上面睡觉,于是调用 wake_up 将其唤醒!

第四步:最大的智障设计诞生(第二重 O(N) 遍历)

进程被唤醒了,从 schedule_timeout() 这行代码苏醒,继续往下走。但是,致命的问题来了!

内核只是把进程唤醒了,但并没有告诉进程,到底是这 10 万个 Socket 里的哪一个来数据了!

进程犹如大梦初醒,一脸懵逼。它唯一的办法,就是让最外层的 for(;;) 循环再转一圈!

它只能咬着牙,把这 10 万个 fd 重新遍历一遍,挨个再去调用一次 tcp_poll,直到找到那个返回了 POLLIN 的幸运儿,让 count++,然后才能 break 退出循环。

最后,系统调用结束,把包含结果的链表数据,再次完完整整地拷贝回用户态的那 800KB 数组里。

3.3 痛点总结与前瞻:为什么必须要造 epoll?

看完上面的底层全景,你可以想象一下,如果把 poll 机制比作一个班主任(操作系统)管理 10 万个学生(并发连接):

班主任为了收一份作业,必须挨个问 10 万个学生:"你写完了吗?没写完的话,写完了叫我。"(第一重 O(N) 遍历)

问完后班主任回办公室睡觉去了。突然有个学生写完了,跑去敲门把班主任吵醒。

结果班主任醒来后,因为不知道是谁敲的门,只能回到教室,再次挨个去问这 10 万个学生:"刚才谁写的?是不是你?"(第二重 O(N) 遍历)。

这种反人类的操作,暴露了 poll 面对海量并发时的三大致命 O(N) 瓶颈:

  1. 拷贝噩梦 O(N) :每次调用 poll,都要把 10 万个元素的数组从用户态拷进内核态;返回时,又要把结果原封不动拷回用户态。无数的 CPU 周期被浪费在毫无意义的内存搬运上。
  2. 内核轮询噩梦 O(N):只要进程被唤醒,哪怕只有 1 个连接来数据,内核也要强行拉出十万级的链表进行二次全量遍历。
  3. 用户层轮询噩梦 O(N) :哪怕内核历经千辛万苦找到了那个就绪的 fd 并返回给了用户,用户在应用层依然不知道是谁,只能写一个 for 循环,再次老老实实遍历 10 万次去检查谁的 revents & POLLIN 成立。

在 C10K(单机万级并发)甚至 C100K 时代,"高并发、长连接、低活跃度"(连接很多,但同时发数据的极少)成为了互联网的常态。为了那 1% 的活跃连接,让 CPU 做 99% 的陪跑遍历,这是工业级架构绝对无法容忍的。

既然痛点如此清晰:能不能不每次都拷贝所有的 fd?能不能谁来数据了就直接把谁扔进一个"就绪集合"里告诉我,别让我再去轮询了?

带着这种降维打击的思维,Linux 2.5.44 版本终于推出了一款彻底颠覆网络编程格局的终极杀器。这就是我们下一章要深入拆解的性能之巅:epoll。

4手撕 poll 内核极简引擎

在上一章中,我们通过剖析 Linux 内核源码,揭示了 poll 机制底层的等待队列与 O(N) 轮询噩梦。但源码中穿插了太多文件系统(VFS)、内存页分配以及复杂的信号处理逻辑,容易让人迷失在细节的汪洋中。

为了将这个极其重要的底层逻辑彻底固化在脑海里,我们直接拔高到"上帝视角",剥离掉 Linux 内核中所有旁支末节的工程化代码,用一段最极简的 C 语言 Demo,手写模拟出一个 poll 核心引擎。

只要看懂了这个极简模型,你就能彻底打通 poll 的底层因果。

4.1 核心组件与底层驱动的抽象

在模拟开始前,我们必须先准备好两个核心部件:一个是用户层传入的通信结构体,另一个是模拟网卡底层驱动返回状态的钩子函数。

c 复制代码
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

/* 模拟系统底层宏定义,使用十六进制独占特定的 bit 位 */
#define MY_POLLIN  0x0001  // 读事件就绪 (0000 0001)
#define MY_POLLOUT 0x0004  // 写事件就绪 (0000 0100)

/* 1. 核心结构体:打通用户态与内核态的通信桥梁 */
struct my_pollfd {
    int   fd;       // 用户态:我要监控哪个文件描述符
    short events;   // 用户态输入:我关心它的哪些事件?(按位或)
    short revents;  // 内核态输出:它实际发生了哪些事件?(内核负责填写)
};

/* 2. 模拟底层硬件与 VFS 驱动的探查函数 
 * 在真实内核中,这对应 file->f_op->poll(),比如 tcp_poll 
 * 它的作用是:去真实的 Socket 缓冲区看一眼,有没有数据?
 */
short mock_driver_poll(int fd) {
    // 假设在我们的模拟环境中,fd 为 3 的套接字刚好收到了网卡的数据
    if (fd == 3) {
        return MY_POLLIN; // 底层网卡/驱动说:这个 fd 可以读了!
    }
    // 假设 fd 为 4 的套接字缓冲区空了,可以写
    if (fd == 4) {
        return MY_POLLOUT;
    }
    
    // 其他绝大部分 fd(如长连接发呆状态),没有任何事件
    return 0; 
}

4.2 核心运转引擎:do_poll 代码重现

接下来是最核心的 do_poll 模拟。在这里,我们将以最直观的代码结构,重现 poll 的两大痛点:盲目遍历 与唤醒后的二次遍历。

c 复制代码
/* 
 * 模拟内核空间的 sys_poll -> do_poll 核心逻辑
 * fds: 从用户态拷贝过来的结构体数组
 * nfds: 数组的长度(并发连接数)
 * timeout: 超时时间
 */
int my_kernel_do_poll(struct my_pollfd *fds, int nfds, int timeout) {
    int count = 0; // 记录有多少个 fd 就绪了

    // 🌟 这就是内核源码中的死循环:for (;;) 
    while (1) {
        
        // ---------------------------------------------------------
        // 【痛点 1:第一重 O(N) 遍历与状态探查】
        // 内核必须老老实实地把所有的 fd 轮询一遍
        // ---------------------------------------------------------
        for (int i = 0; i < nfds; i++) {
            
            // 每次遍历,都要向下调用底层驱动,拿回当前 fd 的真实状态掩码
            short mask = mock_driver_poll(fds[i].fd);
            
            // 🌟 核心掩码校验机制 (按位与 &)
            // 如果底层返回的 mask 中,刚好包含了用户在 events 里关心的事件
            if (mask & fds[i].events) {
                fds[i].revents = mask; // 把就绪状态写入返回字段
                count++;               // 就绪数量 +1
            }
        }

        // ---------------------------------------------------------
        // 【跳出条件】
        // 如果找到了就绪的 fd,或者设定了非阻塞(timeout == 0),直接打断死循环返回
        // ---------------------------------------------------------
        if (count > 0 || timeout == 0) {
            break; 
        }

        // ---------------------------------------------------------
        // 【痛点 2:绝望的沉睡与等待中断】
        // 如果上面遍历了 10 万个 fd 发现全都没有数据,当前进程只能让出 CPU
        // ---------------------------------------------------------
        printf("[内核态] 没有任何 fd 就绪,当前进程让出 CPU,陷入睡眠 schedule_timeout()...\n");
        sleep(2); // 模拟进程挂起睡眠
        
        // 突然,网卡收到了数据,触发硬件中断!
        // 网络协议栈顺着 Socket 的等待队列,把当前进程唤醒 (wake_up)
        printf("[内核态] 网卡收到数据,触发硬中断,当前进程被唤醒!\n");
        
        // 🌟 【最致命的痛点 3:唤醒后的二次 O(N) 遍历】
        // 进程醒来后,代码会继续往下执行。
        // 但由于是在 while (1) 内部,它只能重头开始执行下一次 for 循环!
        // 因为网卡并没有告诉它具体是哪个 fd 来的数据,内核只能再次把所有的 fd 重新遍历一遍!
    }

    return count;
}

4.3 用户态链路联调与运行推演

有了底层的微内核模拟引擎,我们在用户态编写一段客户端代码,将整个数据流向彻底闭环。

c 复制代码
int main() {
    // 1. 用户态准备大数组 (假设我们监控 5 个 fd)
    int const nfds = 5;
    struct my_pollfd fds[5];

    // 2. 初始化参数 (注意:我们只初始化 events,不需要管 revents)
    for (int i = 0; i < nfds; i++) {
        fds[i].fd = i; // 监控 fd: 0, 1, 2, 3, 4
        // 告诉内核:这 5 个 fd 我统统只关心"读事件"
        fds[i].events = MY_POLLIN; 
        fds[i].revents = 0; 
    }

    // 🌟 为了演示多事件复用,我们特意修改 fd = 4 的需求:同时关心读和写
    fds[4].events = MY_POLLIN | MY_POLLOUT;

    printf("--- 开始调用系统底层的 poll ---\n");
    
    // 3. 陷入内核,调用核心引擎 (设置为死等 -1)
    int ready_count = my_kernel_do_poll(fds, nfds, -1);

    printf("--- poll 返回,共发现 %d 个就绪事件 ---\n", ready_count);

    // 4. 用户态的 O(N) 遍历:排查到底是谁就绪了
    for (int i = 0; i < nfds; i++) {
        // 使用按位与(&)排查事件
        if (fds[i].revents & MY_POLLIN) {
            printf("[用户态] 发现 fd = %d 读事件就绪!可以调用 read() 了。\n", fds[i].fd);
        }
        if (fds[i].revents & MY_POLLOUT) {
            printf("[用户态] 发现 fd = %d 写事件就绪!可以调用 write() 了。\n", fds[i].fd);
        }
    }

    return 0;
}

运行这段极简代码,我们的大脑中就能推演出清晰的底层画面:

  1. 结构传递 :用户态把装满 events 需求的数组传递给内核。
  2. 内核寻址 :内核在 while(1) 的死循环里,调用 mock_driver_poll 探查所有设备。
  3. 位图碰撞 :通过 mask & events 的位运算,精准识别出 fd=3 命中读事件,fd=4 命中写事件,并把结果填入 revents。
  4. 原路返回与用户排查 :引擎带着就绪数量返回用户层。但很遗憾,用户层拿到数组后,依然只能写一个 for 循环,再次用 fds[i].revents & MY_POLLIN 把所有的元素筛查一遍。

通过这几十行极简代码,poll 的生命周期被完全扒光。它解决的仅仅是 select 的连接数上限和重复初始化问题。但无论是内核层的 while(1) 搭配 for 循环轮询,还是用户层的 for 循环排查,随着并发数向万级、十万级突破,这种 O(N) 级别的算力消耗,注定会被时代彻底抛弃。

补充:poll的使用示例

cpp 复制代码
#include <iostream>
#include <poll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>

using namespace std;

int main()
{
    // 1. 创建监听套接字
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);

    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = INADDR_ANY;

    // 2. 绑定和监听
    bind(listenfd, (sockaddr*)&addr, sizeof(addr));
    listen(listenfd, 128);

    // 3. 创建 pollfd 数组
    pollfd fds[1024]{};
    int nfds = 1;

    // 将监听套接字加入监听数组
    fds[0].fd = listenfd;
    fds[0].events = POLLIN;

    while (true)
    {
        // 4. 等待事件发生
        int ret = poll(fds, nfds, -1);

        if (ret < 0)
            continue;

        // 5. 遍历所有文件描述符
        for (int i = 0; i < nfds; )
        {
            if (fds[i].revents == 0)
            {
                i++;
                continue;
            }

            // 6. 监听套接字可读:有新连接
            if (fds[i].fd == listenfd)
            {
                int connfd = accept(listenfd, nullptr, nullptr);

                if (connfd >= 0 && nfds < 1024)
                {
                    fds[nfds].fd = connfd;
                    fds[nfds].events = POLLIN;
                    nfds++;
                }
                else if (connfd >= 0)
                {
                    close(connfd);
                }
            }
            // 7. 普通客户端套接字
            else
            {
                int fd = fds[i].fd;
                bool remove = false;

                if (fds[i].revents & POLLIN)
                {
                    char buf[1024] = {};

                    int n = recv(fd, buf, sizeof(buf), 0);

                    if (n > 0)
                    {
                        cout << "收到数据: " << buf << endl;

                        // 回显数据
                        send(fd, buf, n, 0);
                    }
                    else
                    {
                        // 客户端关闭或读取失败
                        remove = true;
                    }
                }

                // 处理连接异常
                if (fds[i].revents & (POLLERR | POLLHUP | POLLNVAL))
                    remove = true;

                if (remove)
                {
                    close(fd);

                    // 删除当前fd:用最后一个元素覆盖
                    fds[i] = fds[nfds - 1];
                    nfds--;

                    continue;
                }
            }

            i++;
        }
    }

    close(listenfd);
    return 0;
}

第二章 从 select 到 poll:基于结构体数组的事件通知与派发

在上一章的微观剖析中,我们彻底看清了 select 因历史包袱带来的致命缺陷:输入输出型参数导致的"每轮必重建位图",以及宏定义锁死的 1024 个文件描述符上限。

为了填补这些天坑,poll 接口应运而生。虽然它在内核态依然没有摆脱 O(N) 轮询的命运,但在应用层的接口设计上,poll 完成了一次优雅的降维打击。它彻底抛弃了晦涩且受限的位图(Bitmap),转而采用最直白的数据结构------结构体数组。

本章,我们将从宏观架构到微观源码,手写落地一个基于 poll 的单线程事件驱动服务器,彻底打通从系统调用到业务派发的底层链路。

1 架构设计:poll 事件驱动模型全景解构

了解了基本兵器,我们开始构建完整的战车。一个工业级的 poll 服务器,本质上是一个事件驱动状态机。它必须包含以下几个核心组件相互咬合:

1.1 事件源与注册表 (The Registry)

  • 监听套接字 (listenfd):它的职责只有一个------产生"新连接到达"事件。当底层 TCP 全连接队列里有握手成功的连接时,它的 revents 会被置位 POLLIN。
  • 通信套接字 (clientfd):它的职责是产生"数据到达"、"对端关闭"或"连接异常"事件(对应 POLLIN、POLLHUP、POLLERR)。
  • 注册表 (_fds 数组):我们维护一个全局的 struct pollfd _fds4096。它既是门禁系统(记录监听谁),也是任务清单(记录关心什么),更是成绩单(内核填写发生了什么)。

1.2 统一监听器与派发器 (Listener & Dispatcher)

  • 监听器 (poll):系统调用 poll 扮演门卫,统一阻塞等待数组中注册的所有 fd。它不干杂活(不负责 accept,也不负责 recv),只负责"等"和"填写 revents 状态"。
  • 派发器 (Dispatcher):当 poll 返回 ready_num > 0 时,派发器出场。它遍历 _fds 数组寻找 revents != 0 的幸运儿。
  • 如果就绪的是 listenfd,将执行流派发给 Accepter。
  • 如果就绪的是 clientfd,将执行流派发给 Recver。

1.3 业务处理器 (Accepter & Recver)

  • Accepter:专门调用 accept 把新连接从内核捞出来,为其分配一个 clientfd,然后把它塞进 _fds 数组里的空闲位置(设为 POLLIN),使其正式纳入下一轮的事件监控体系。
  • Recver:专门调用 recv 读取客户端数据。如果 n > 0 执行业务逻辑(本例中为回显);如果 n == 0(对端正常关闭)或 n < 0(发生错误),则将对应的 _fds 位置清空为 -1,注销该事件源。

2 核心业务流:一次完整的事件流转推演

在看代码前,我们在脑海中跑通一次完整的状态流转。

假设初始状态下,服务器只有 listenfd = 3:

text 复制代码
索引      fd      events      revents
 0        3       POLLIN         0
 1       -1          0           0

服务器调用 poll(_fds, 1, -1) 陷入阻塞。

场景 1:新客户端连接

  1. 客户端发来 SYN,TCP 握手完成。内核将 _fds0.revents 填入 POLLIN。
  2. poll 被唤醒返回 1。
  3. Dispatcher 扫描到索引 0 状态非零,且它是 listenfd,立刻将其派发给 Accepter。
  4. Accepter 执行 accept,拿到新通信句柄 clientfd = 4。
  5. Accepter 扫描数组寻找空位,将 _fds1 填入 fd = 4, events = POLLIN, revents = 0。
  6. 进入下一轮循环,此时 poll(_fds, 2, -1) 开始监控 3 和 4。

场景 2:客户端发来数据

  1. 客户端通过 fd=4 发送了一段 "hello"。
  2. 内核将 _fds1.revents 填入 POLLIN。
  3. poll 被唤醒返回 1。
  4. Dispatcher 扫描发现索引 1 非零,且它是普通通信句柄,将其派发给 Recver。
  5. Recver(1) 根据 _fds1.fd 调用 recv 拿到数据,处理完毕后通过 send 将响应发回。
  6. 继续下一轮事件循环。

一切都在单线程的 while(1) 中行云流水般流转,这就是纯正的事件驱动模型。

3 工业级 Poll 服务器全组件源码实战

下面我们将刚才的架构设计转化为实际的工业级 C++ 代码。为了保证底层链路的完整性,我们将展示包含日志系统、Socket 封装机制以及 PollServer 核心逻辑的完整工程源码。

3.1 基础组件:锁机制与高吞吐日志系统

即使是单线程事件模型,由于其核心组件通常会被多线程架构复用,基础组件(如 Logger)必须具备线程安全性。这里我们实现了一个基于 RAII 思想的互斥锁,以及一个支持控制台与文件双策略的工业级日志器。

Mutex.hpp (互斥锁封装)

cpp 复制代码
#pragma once
#include <pthread.h>

/*
 * 互斥锁 (Mutex) 的面向对象封装
 * 底层依托 POSIX 线程库的 pthread_mutex_t。
 * 在高并发场景下,保证共享资源(如日志缓冲、文件流)的互斥访问,防止竞态条件。
 */
class Mutex {
public:
    // 构造时陷入系统调用,初始化内核级的互斥锁资源
    Mutex() { pthread_mutex_init(&_lock, nullptr); }
    
    // 核心底层规范:严禁拷贝构造和赋值。
    // 锁本质是操作系统维护的同步对象,拷贝会导致内存被同一机制重复销毁,引发崩溃。
    Mutex(const Mutex &) = delete;
    Mutex &operator=(const Mutex &) = delete;
    
    // 加锁:若锁已被持有,当前线程在此挂起,交出 CPU,进入阻塞等待队列
    void Lock() { pthread_mutex_lock(&_lock); }
    // 解锁:释放锁资源,并由内核唤醒等待队列中的阻塞线程
    void Unlock() { pthread_mutex_unlock(&_lock); }
    
    // 析构时归还系统资源,防止内核内存泄漏
    ~Mutex() { pthread_mutex_destroy(&_lock); }
private:
    pthread_mutex_t _lock;
};

/*
 * LockGuard 自动锁守卫:基于 C++ RAII 机制的防御性编程利器
 * 利用对象的生命周期(栈上分配,出作用域自动析构)来管理锁,
 * 彻底杜绝因程序异常分支(如抛出异常、多级 if 提前 return)导致的漏解锁(死锁)现象。
 */
class LockGuard {
public:
    // 构造即加锁:显式接收一个 Mutex 引用并立即锁定
    explicit LockGuard(Mutex &lock) : _lockref(lock) { _lockref.Lock(); }
    
    // 同样严禁拷贝行为
    LockGuard(const LockGuard &) = delete;
    LockGuard &operator=(const LockGuard &) = delete;
    
    // 析构即解锁:离开局部作用域时由编译器自动插入析构调用,做到 100% 安全释放
    ~LockGuard() { _lockref.Unlock(); }
private:
    Mutex &_lockref; // 引用成员变量,强绑定外部的锁实例
};

Logger.hpp (流式日志系统)

利用 C++17 inline 变量和临时对象析构机制,实现流式(<<)无锁感知的日志输出。

cpp 复制代码
#ifndef __LOGGER_HPP
#define __LOGGER_HPP

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <sys/time.h>
#include <unistd.h>
#include <memory>
#include <filesystem>
#include "Mutex.hpp"

namespace NS_LOG_MODULE {
    // 日志分级机制,满足工业级服务排障定级需求
    enum class LogLevel { INFO, WARNING, ERROR, FATAL, DEBUG };

    inline std::string LogLevel2Message(LogLevel level) {
        switch (level) {
            case LogLevel::INFO: return "INFO";
            case LogLevel::WARNING: return "WARNING";
            case LogLevel::ERROR: return "ERROR";
            case LogLevel::FATAL: return "FATAL";
            case LogLevel::DEBUG: return "DEBUG";
            default: return "UNKNOWN";
        }
    }

    // 获取带微秒级精度的当前系统时间,用于高并发下追踪事件时序
    inline std::string GetCurrentTime() {
        struct timeval current_time;
        gettimeofday(&current_time, nullptr);
        struct tm struct_time;
        localtime_r(&(current_time.tv_sec), &struct_time); // 可重入(线程安全)版本
        char timestr[128];
        snprintf(timestr, sizeof(timestr), "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
                 struct_time.tm_year + 1900, struct_time.tm_mon + 1, struct_time.tm_mday,
                 struct_time.tm_hour, struct_time.tm_min, struct_time.tm_sec, current_time.tv_usec);
        return timestr;
    }

    // 策略模式 (Strategy Pattern) 接口层:解耦日志生成与日志落盘动作
    class LogStrategy {
    public:
        virtual ~LogStrategy() = default;
        virtual void SyncLog(const std::string &message) = 0;
    };

    // 策略实现:控制台输出策略 (多用于 Debug 调试)
    class ConsoleStrategy : public LogStrategy {
    public:
        void SyncLog(const std::string &message) override {
            LockGuard lockguard(_mutex); // 输出加锁,防止多线程下字符交错穿插
            std::cerr << message << std::endl;
        }
    private:
        Mutex _mutex;
    };

    // C++17 inline 全局变量:解决头文件 only 带来的重复定义链接错误 (ODR)
    inline const std::string defaultpath = "./log";
    inline const std::string defaultfilename = "log.txt";

    // 策略实现:文件持久化输出策略 (多用于线上生产环境)
    class FileLogStrategy : public LogStrategy {
    public:
        FileLogStrategy(const std::string &path = defaultpath, const std::string &name = defaultfilename)
            : _logpath(path), _logfilename(name) {
            LockGuard lockguard(_mutex);
            // 依赖 C++17 filesystem 库优雅地递归创建多级目录
            if (!std::filesystem::exists(_logpath)) {
                std::filesystem::create_directories(_logpath);
            }
        }
        void SyncLog(const std::string &message) override {
            LockGuard lockguard(_mutex);
            std::string target = _logpath + (_logpath.back() == '/' ? "" : "/") + _logfilename;
            std::ofstream out(target, std::ios::app); // 以追加模式 (Append) 打开文件
            if (out.is_open()) out << message << "\n";
        }
    private:
        std::string _logpath;
        std::string _logfilename;
        Mutex _mutex;
    };

    // 顶层 Logger 类,持有策略对象并提供调用接口
    class Logger {
    public:
        Logger() { UseConsoleStrategy(); }
        void UseConsoleStrategy() { _strategy = std::make_unique<ConsoleStrategy>(); }
        void UseFileStrategy() { _strategy = std::make_unique<FileLogStrategy>(); }

        /* 
         * LogMessage 类利用 C++ 对象的生命周期实现 "流式无锁" 调用。
         * 在宏展开时,创建一个匿名的临时 LogMessage 对象,
         * operator<< 不断向内部 stringstream 拼接数据。
         * 整条语句执行完毕后,临时对象析构,在析构函数中一次性向底层提交整条日志。
         */
        class LogMessage {
        public:
            LogMessage(LogLevel level, std::string filename, int line, Logger &logger)
                : _logger(logger) {
                std::stringstream ss;
                ss << "[" << GetCurrentTime() << "] [" << LogLevel2Message(level) << "] "
                   << "[" << getpid() << "] [" << filename << "] [" << line << "] - ";
                _loginfo = ss.str();
            }
            template <typename T>
            LogMessage &operator<<(const T &info) {
                std::stringstream ss;
                ss << info;
                _loginfo += ss.str();
                return *this;
            }
            ~LogMessage() {
                if (_logger._strategy) _logger._strategy->SyncLog(_loginfo);
            }
        private:
            std::string _loginfo;
            Logger &_logger;
        };

        // 重载 () 运算符,充当临时对象工厂
        LogMessage operator()(LogLevel level, std::string filename, int line) {
            return LogMessage(level, std::move(filename), line, *this);
        }
    private:
        std::unique_ptr<LogStrategy> _strategy;
        friend class LogMessage;
    };

    inline Logger logger;
} 

#define ENABLE_CONSOLE_LOG_STRATEGY() NS_LOG_MODULE::logger.UseConsoleStrategy()
#define ENABLE_FILE_LOG_STRATEGY() NS_LOG_MODULE::logger.UseFileStrategy()
// 提供极为简练的宏接口,隐藏底层的代码所在文件 (__FILE__) 与行号 (__LINE__) 埋点逻辑
#define LOG(level) NS_LOG_MODULE::logger(level, __FILE__, __LINE__)

#endif

3.2 网络底层基建:地址与套接字封装

为了剥离繁琐的 sockaddr_in 转换逻辑以及枯燥的 socket/bind/listen 三步曲,我们利用面向对象的思想对网络底层设施进行封装。

InetAddr.hpp (网络地址对象化)

cpp 复制代码
#pragma once
#include <arpa/inet.h>
#include <string>
#include <strings.h>

// 辅助宏:强制将特定协议族的 sockaddr_in 转换为通用的 sockaddr 指针,适配 POSIX API
#define CONV(address) reinterpret_cast<struct sockaddr *>(address)

/*
 * InetAddr 类:抹平底层大小端(Endianness)与 IP 字符串/二进制结构的转换鸿沟。
 * 内部统一持有网络字节序 (大端机格式) 的 sockaddr_in,
 * 对外提供人类可读的点分十进制 IP 字符串与主机字节序端口。
 */
class InetAddr {
public:
    InetAddr() : _len(sizeof(_address)), _port(0) { bzero(&_address, sizeof(_address)); }
    
    // 构造函数:接受从 accept() 底层弹出的原生态 sockaddr_in
    explicit InetAddr(const struct sockaddr_in &address) : _address(address), _len(sizeof(address)) { ParseAddress(); }
    
    // 构造函数:接受应用层指定的 port 和 ip,底层负责转换为系统 API 所需的大端格式
    InetAddr(uint16_t port, const std::string &ip = "0.0.0.0") : _len(sizeof(_address)), _ip(ip), _port(port) {
        bzero(&_address, sizeof(_address));
        _address.sin_family = AF_INET;
        _address.sin_port = htons(_port); // 主机字节序转网络字节序 (Host to Network Short)
        inet_pton(AF_INET, _ip.c_str(), &(_address.sin_addr)); // 文本 IP 转二进制网络格式
    }
    
    InetAddr &operator=(const struct sockaddr_in &addr) {
        _address = addr; _len = sizeof(_address); ParseAddress(); return *this;
    }
    
    std::string ToString() const { return "[" + _ip + ":" + std::to_string(_port) + "]"; }
    struct sockaddr *NetAddress() { return CONV(&_address); }
    socklen_t Len() const { return _len; }

private:
    // 解析底层二进制数据为应用层直观的可读格式
    void ParseAddress() {
        char ipstr[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &(_address.sin_addr), ipstr, sizeof(ipstr)); // 二进制转文本 IP
        _ip = ipstr;
        _port = ntohs(_address.sin_port); // 网络字节序转主机字节序 (Network to Host Short)
    }
    
    struct sockaddr_in _address;
    socklen_t _len;
    std::string _ip;
    uint16_t _port;
};

Socket.hpp (多态套接字引擎)

通过模板方法模式(Template Method),一键生成可用的监听套接字。

cpp 复制代码
#pragma once
#include <sys/socket.h>
#include <unistd.h>
#include "InetAddr.hpp"
#include "Logger.hpp"

namespace NS_SOCKET_MODULE {
    using namespace NS_LOG_MODULE;
    static constexpr int gbacklog = 16; // 决定底层 TCP 全连接队列 (Accept Queue) 的大小
    enum { OK = 0, SOCKET_ERR, BIND_ERR, LISTEN_ERR };

    // Socket 抽象基类,定义网络通信底层的标准化动作原语
    class Socket {
    public:
        virtual ~Socket() = default;
    protected:
        virtual void CreateSocketOrDie() = 0;
        virtual void BindSocketOrDie(uint16_t port) = 0;
        virtual void ListenSocketOrDie() = 0;
    public:
        virtual int Accepter(InetAddr &addr) = 0;
        virtual int Sockfd() const = 0;
        virtual ssize_t Recv(std::string *out) = 0;
        virtual ssize_t Send(const std::string &in) = 0;
        virtual void Close() = 0;
        virtual bool Connect(InetAddr &addr) = 0;

        // 模板方法模式:固化服务端 TCP 初始化的业务流水线
        void BuildTcpSocketMethod(uint16_t port) {
            CreateSocketOrDie();
            BindSocketOrDie(port);
            ListenSocketOrDie();
        }
    };

    // TcpSocket:对 Socket 原语的具体的 IPv4 TCP 协议栈实现
    class TcpSocket : public Socket {
    public:
        TcpSocket() : _sockfd(-1) {}
        explicit TcpSocket(int sockfd) : _sockfd(sockfd) {}

    protected:
        void CreateSocketOrDie() override {
            _sockfd = socket(AF_INET, SOCK_STREAM, 0); // 请求内核分配 TCP 字节流控制块
            if (_sockfd < 0) { LOG(LogLevel::FATAL) << "create socket error"; exit(SOCKET_ERR); }
            
            // 核心底层优化:开启端口复用 (SO_REUSEADDR)
            // 服务器主动断开连接时会进入 TIME_WAIT 状态(停留 2MSL 时间,通常为 60s)。
            // 开启此选项可允许新启动的进程立即绑定处于 TIME_WAIT 状态的端口,防止服务重启失败。
            int opt = 1;
            setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); 
        }
        
        void BindSocketOrDie(uint16_t port) override {
            InetAddr addr(port);
            if (bind(_sockfd, addr.NetAddress(), addr.Len()) != 0) {
                LOG(LogLevel::FATAL) << "bind socket error"; exit(BIND_ERR);
            }
        }
        
        void ListenSocketOrDie() override {
            if (listen(_sockfd, gbacklog) != 0) {
                LOG(LogLevel::FATAL) << "listen socket error"; exit(LISTEN_ERR);
            }
        }

    public:
        int Accepter(InetAddr &clientaddr) override {
            struct sockaddr_in addr;
            socklen_t len = sizeof(addr);
            // 陷入内核,从该监听 fd 的全连接队列中提取一个已经完成三次握手的 TCP 连接
            int clientfd = accept(_sockfd, CONV(&addr), &len);
            if (clientfd < 0) return -1;
            clientaddr = addr; // 利用运算符重载将底层地址格式化
            return clientfd;
        }
        
        int Sockfd() const override { return _sockfd; }
        
        ssize_t Recv(std::string *out) override {
            char inbuffer[1024];
            ssize_t n = recv(_sockfd, inbuffer, sizeof(inbuffer) - 1, 0);
            if (n > 0) { inbuffer[n] = '\0'; *out += inbuffer; }
            return n;
        }
        
        ssize_t Send(const std::string &in) override {
            // MSG_NOSIGNAL:防御性编程的核心。
            // 当客户端异常关闭,服务端继续调用 send 时,内核会向当前进程抛出 SIGPIPE 信号,
            // 该信号的默认行为是杀死进程。带上此参数可以直接忽略该信号,让 send 返回 -1 并置位 errno。
            return send(_sockfd, in.c_str(), in.size(), MSG_NOSIGNAL);
        }
        
        void Close() override {
            if (_sockfd >= 0) { close(_sockfd); _sockfd = -1; }
        }
        
        bool Connect(InetAddr &addr) override {
            return connect(_sockfd, addr.NetAddress(), addr.Len()) == 0;
        }
        
        ~TcpSocket() override { Close(); }
    private:
        int _sockfd;
    };
}

3.3 核心引擎:PollServer 与事件驱动落地

接下来是最核心的 PollServer。注意这里的一个性能优化小技巧:我们通过维护一个 _max_index 变量,记录了当前 _fds 数组中被使用的最高下标。这样在调用 poll 时,nfds 参数只需传入 _max_index + 1,彻底避免了内核每次都要无脑遍历 4096 个元素的悲剧。

PollServer.hpp

cpp 复制代码
#pragma once
#include <poll.h>
#include <memory>
#include "Logger.hpp"
#include "Socket.hpp"

using namespace NS_LOG_MODULE;
using namespace NS_SOCKET_MODULE;

static constexpr int gnum = 4096;      // 应用层自由定义的监听上限(受系统资源制约)
static constexpr int gdefaultfd = -1;  // 负数表示空位,poll 传入内核时遇到负数会触发安全跳跃机制

class PollServer {
public:
    explicit PollServer(uint16_t port = 8080)
        : _port(port), _listensock(std::make_unique<TcpSocket>()), _quit(false), _max_index(0) {
        
        // 1. 初始化底层的监听套接字
        _listensock->BuildTcpSocketMethod(_port);
        LOG(LogLevel::DEBUG) << "create listen socket success, fd: " << _listensock->Sockfd();

        // 2. 初始化 pollfd 注册表,全部置为 -1 进行打底防脏
        for (int i = 0; i < gnum; ++i) {
            _fds[i].fd = gdefaultfd;
            _fds[i].events = 0;
            _fds[i].revents = 0;
        }

        // 3. 架构原点:将 listenfd 钉死在第 0 号位,并且仅关注"全连接队列新客到达"事件(POLLIN)
        _fds[0].fd = _listensock->Sockfd();
        _fds[0].events = POLLIN;
        _fds[0].revents = 0;
    }

private:
    // 将新建立的握手连接,挂载进事件轮询的监管列表
    bool AddClientFd(int clientfd) {
        if (clientfd < 0) return false;
        // 遍历寻找空位(从1开始,绝对保留 0 号位的 listenfd)
        for (int pos = 1; pos < gnum; ++pos) {
            if (_fds[pos].fd == gdefaultfd) {
                _fds[pos].fd = clientfd;
                _fds[pos].events = POLLIN; // 关注底层内核接收缓冲区的可读数据事件
                _fds[pos].revents = 0;
                
                // 核心降维优化:动态推高探测边界,极大地减少 poll 陷入内核时 O(N) 扫描的空间长度
                if (pos > _max_index) _max_index = pos;
                return true;
            }
        }
        return false;
    }

    // 从事件树中摘除废弃句柄,并强制回收系统资源
    void RemoveClientFd(int index) {
        int clientfd = _fds[index].fd;
        if (clientfd == gdefaultfd) return;
        
        close(clientfd); // 向内核发起 4 次挥手,剥离 VFS 引用
        _fds[index].fd = gdefaultfd; // 状态位复位,将车牌吊销
        _fds[index].events = 0;
        _fds[index].revents = 0;

        // 如果刚好干掉的是处于最末尾(最高位)的元素,执行动态回调收缩,紧凑监控范围
        if (index == _max_index) {
            while (_max_index > 0 && _fds[_max_index].fd == gdefaultfd) {
                --_max_index;
            }
        }
    }

public:
    // --- 业务处理器1:Accepter 专职负责将新建连接捞入应用层 ---
    void Accepter() {
        InetAddr clientaddr;
        int clientfd = _listensock->Accepter(clientaddr);
        if (clientfd < 0) return;

        LOG(LogLevel::WARNING) << "Get a new connection, client fd: " << clientfd 
                               << " | " << clientaddr.ToString();
        
        // 铁律:绝对不能在当前执行流中进行阻塞型的 read/recv!
        // 若对端一直不发数据,该线程将彻底锁死,整个服务器的并发轮询直接瘫痪!
        // 唯一正确的做法:把它丢进 pollfd 数组,把脏活累活丢给底层的 poll()。
        if (!AddClientFd(clientfd)) {
            LOG(LogLevel::WARNING) << "Server is full, closing client fd: " << clientfd;
            close(clientfd);
        }
    }

    // --- 业务处理器2:Recver 处理已连客户端的 I/O 通信 ---
    void Recver(int index) {
        int clientfd = _fds[index].fd;
        char buffer[1024];

        // 走到这步,说明内核缓冲大概率已经有现成数据,recv 将秒返回而不发生阻塞挂起
        ssize_t n = recv(clientfd, buffer, sizeof(buffer) - 1, 0);
        if (n > 0) {
            buffer[n] = '\0';
            LOG(LogLevel::DEBUG) << "Recv from fd: " << clientfd << " data: " << buffer;
            
            // 简单的应用层协议验证:回显服务 (Echo Service)
            std::string echo_string = "echo #";
            echo_string += buffer;
            
            ssize_t send_result = send(clientfd, echo_string.c_str(), echo_string.size(), MSG_NOSIGNAL);
            // 写操作失败且并非系统中断,说明管道已断裂
            if (send_result < 0 && errno != EINTR) {
                RemoveClientFd(index);
            }
        } else if (n == 0) {
            // 这是极其重要的分支:对端主动调用 close 挥手。
            // 网络套接字在断开时,系统级层面依然表现为"可读(POLLIN就绪)",但读出的字节严格为 0。
            LOG(LogLevel::INFO) << "Client quit, fd: " << clientfd;
            RemoveClientFd(index);
        } else {
            // EINTR (信号打断) 或 EAGAIN (非阻塞伪唤醒),这都属于可忽略的系统现象
            if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) return;
            LOG(LogLevel::WARNING) << "Recv error, fd: " << clientfd << ", errno: " << errno;
            RemoveClientFd(index);
        }
    }

    // --- 派发器:根据事件种类,分发到具体的后端工种处理 ---
    void Dispatcher(int ready_num) {
        int handled_num = 0;
        
        // 基于 handled_num 数量截断的算法优化:
        // 只要发现并处理的数量凑满了 poll 告诉我们的 ready_num,立刻打断大循环,避免后续空转探测
        for (int i = 0; i <= _max_index && handled_num < ready_num; ++i) {
            if (_fds[i].fd == gdefaultfd || _fds[i].revents == 0) continue;
            
            ++handled_num; // 精准捕捉一个由内核标红的活跃事件
            short current_events = _fds[i].revents;
            int current_fd = _fds[i].fd;

            // 应对底层的错乱异常 (如该 fd 已被强行关闭但未能及时注销,内核抛出 POLLNVAL 警告)
            if (current_events & POLLNVAL) {
                if (current_fd != _listensock->Sockfd()) RemoveClientFd(i);
                continue;
            }

            // 数据分流:当前发生动静的如果是大门(监听套接字)
            if (current_fd == _listensock->Sockfd()) {
                if (current_events & POLLIN) Accepter();
                if (current_events & (POLLERR | POLLHUP)) _quit = true; // 承重墙倒塌,服务降级拉闸
            } 
            // 数据分流:当前发生动静的是某个具体的房间(普通通信套接字)
            else {
                if (current_events & POLLIN) Recver(i);
                
                // Recver() 中可能会因为协议错误顺手强行关闭连接,此时 i 的状态已重置。
                // 仅针对幸存的连接校验是否被对端挂断 (POLLHUP) 或底层传输错 (POLLERR)。
                if (_fds[i].fd != gdefaultfd && (current_events & (POLLERR | POLLHUP))) {
                    RemoveClientFd(i);
                }
            }

            // 强制将 revents 清零(非必须项)。
            // 实际上每次调用 poll,内核都会直接覆盖该位。这里仅为了开发期打印输出日志能保持清爽。
            if (_fds[i].fd != gdefaultfd) _fds[i].revents = 0;
        }
    }

    void PrintFd() const {
        std::cout << "poll fd list: ";
        for (int i = 0; i <= _max_index; ++i) {
            if (_fds[i].fd != gdefaultfd) std::cout << _fds[i].fd << " ";
        }
        std::cout << std::endl;
    }

    // --- 动力引擎:多路复用总线大循环 ---
    void Loop() {
        const int timeout = -1; // -1 表示将当前线程扔进休眠队列永久挂起,死等硬件级唤醒
        while (!_quit) {
            PrintFd();
            
            // 整个框架的心脏:
            // 将整个庞大的用户态 pollfd 数组拷贝入内核。
            // 内核对这 _max_index + 1 个套接字进行状态巡检,并修改每个元素的 revents 字段。
            int ready_num = poll(_fds, static_cast<nfds_t>(_max_index + 1), timeout);
            
            if (ready_num == 0) { continue; } // 超时情况
            if (ready_num < 0) {
                if (errno == EINTR) continue; // poll 被系统的进程间信号打断,属于正常干扰,重新跑
                break; // 遭受系统级重创
            }

            LOG(LogLevel::WARNING) << "Event ready, count: " << ready_num;
            // 拿到装满事件的数组后,下派给应用态分发层进行拆解
            Dispatcher(ready_num); 
        }
    }

    ~PollServer() {
        for (int i = 1; i <= _max_index; ++i) {
            if (_fds[i].fd != gdefaultfd) close(_fds[i].fd);
        }
    }
private:
    uint16_t _port;
    std::unique_ptr<Socket> _listensock;
    bool _quit;
    int _max_index;
    struct pollfd _fds[gnum];
};

Main.cc (系统入口)

cpp 复制代码
#include <iostream>
#include <memory>
#include "PollServer.hpp"

// 系统主函数:程序拉起的第一落点
int main(int argc, char *argv[]) {
    // 强制传参校验(例:./pollserver 8080)
    if (argc != 2) {
        std::cout << "Usage: " << argv[0] << " port" << std::endl;
        return 1;
    }
    ENABLE_CONSOLE_LOG_STRATEGY();
    
    try {
        int input_port = std::stoi(argv[1]);
        if (input_port <= 0 || input_port > 65535) return 1;
        
        // 通过 unique_ptr 将 Server 实例扔到堆上,控制生命周期
        std::unique_ptr<PollServer> server = std::make_unique<PollServer>(static_cast<uint16_t>(input_port));
        server->Loop(); // 一键点火,启动死循环阻塞引擎
    } catch (...) { return 1; }
    
    return 0;
}

3.4 编译与联调测试

执行 make 编译工程,并在终端运行启动监听:

bash 复制代码
./pollserver 8080

此时终端会打印 poll fd list: 3,表明当前只监控了 listenfd。

通过客户端 nc 127.0.0.1 8080 连入服务器,服务器底层瞬间走完如下链路:

  1. listenfd 的 revents 变为 POLLIN。
  2. poll 停止阻塞,返回 1。
  3. Dispatcher 定位到索引起始处,分配给 Accepter。
  4. accept 得到新的描述符 4,将其写入 _fds1。
  5. 屏幕立刻刷新:poll fd list: 3 4。

随后在客户端随意输入一段话,数据从网卡到缓冲区的链路打通后,_fds1.revents 被触发,派发给 Recver 并将响应回写,完美的单线程异步非阻塞(准确说是多路复用阻塞)架构就此成型。

4 终极拷问:poll 真的完美了吗?

看着跑得无比丝滑的 PollServer,我们似乎已经写出了相当优秀的底层代码。我们不仅利用 pollfd 结构体解决了输入输出参数混用的痛点,还彻底击碎了 1024 个连接的硬性封锁。

但如果我们在真实的高并发生产环境下(例如同时面对 10 万个建立的长连接,但同一秒内只有极少数连接发送数据),重新审视上面的代码,你会惊恐地发现:它在微观执行图景上,依然存在着极其惨烈的算力浪费。

请注意代码中,poll 模型不可避免的"三大原罪":

  1. 每次都要进行沉重的数组拷贝(第一重 O(N)):
    每次调用 poll(_fds, ...),操作系统都要将整个 _fds 数组从用户空间通过内存拷贝硬生生地搬运进内核空间;调用结束后,又要重新拷贝回来。十万个结构体就是接近 1MB 的内存,这种高频的内核态边界搬运是极其昂贵的。
  2. 内核极其被动的无脑遍历(第二重 O(N)):
    哪怕网卡只收到 1 个字节,触发了一次硬中断唤醒进程,内核根本不知道这 1 字节是谁的。它只能在底层硬着头皮,把这十万个 fd 全部探测一遍。
  3. 用户层绝望的地毯式排查(第三重 O(N)):
    代码里的 Dispatcher 虽然加了 handled_num 优化,但在最坏情况下(比如就绪的元素藏在数组的末尾),依然需要写一个大 for 循环把成千上万的 _fds 遍历一遍。

一句话总结:poll 只是让服务器具备了处理海量并发的物理条件(不限制连接数),但根本没有具备处理海量并发的性能条件。

既然"拷来拷去"很费时,那能不能让操作系统和用户层共享一块长期的内存空间,不来回搬了?

既然"从头遍历到底"很愚蠢,那能不能让网卡在收到数据时,直接把发生了数据的 fd 挑出来扔到一个"就绪队列"里,我们只遍历就绪队列?

当 Linux 架构师们顺着这种降维打击的思路继续深入时,人类网络编程史上最伟大、最硬核的终极底层模型------Epoll,终于诞生了。这正是我们下一章将要挺进的终极技术深水区。

第三章 性能之巅:epoll 的降维打击与大并发破局

在上一章的结尾,我们面对 poll 在海量并发下的表现,得出了一个令人绝望的结论:无论是跨越用户态与内核态的百万级内存拷贝,还是内核层与应用层的双重 O(N) 盲目轮询,都在无情地吞噬着宝贵的 CPU 算力。

select 和 poll 诞生的年代,互联网的规模还很小,单台服务器顶多应对几百上千个并发连接,"线性轮询"的粗暴模式勉强够用。但随着 C10K(单机万级并发)甚至 C100K 时代的轰然降临,服务器面临的典型场景变成了"活跃度极低的海量长连接"------同时保持着 10 万个连接,但某一时刻只有 100 个连接在发数据。为了这 100 个活跃连接去轮询 99900 个发呆的连接,这种底层模型上的先天缺陷,再怎么在应用层玩出花来也无济于事。

痛点逼迫着技术的跃迁。既然在用户态修修补补解决不了根本问题,Linux 内核团队决定直接在底层重构一套全新的玩法。

1 初识 epoll:为海量并发而生的终极杀器

在 Linux 2.6 内核版本中,一颗名为 epoll(Event Poll)的重磅炸弹正式被合入主线。官方对它的定位非常明确:为处理大批量文件描述符(句柄)而作了重大改进的 poll。

这绝不是一次简单的接口修补,而是一场底层逻辑的"降维打击"。epoll 几乎摒弃了前代所有的性能包袱,不仅继承了 poll 不限制文件描述符数量的优点,更彻底扭转了内核处理 I/O 事件的哲学。它被工业界公认为 Linux 2.6 之下性能最高、扩展性最强的多路 I/O 就绪通知机制,是 Nginx、Redis 等现代高性能并发软件的绝对基石。

epoll 到底凭什么敢称"性能之巅"?核心在于它将 select/poll 的"轮询(Polling)模型",彻底颠覆为"事件驱动(Event-Driven)模型"。

我们可以用最直白的大白话来理解这次理念上的跨越:

  • poll 的做法(班主任点名):班主任(操作系统)每次都要把全班 10 万个学生(并发连接)的名字念一遍,挨个问"你的作业写完了吗?"如果全班只有 1 个人写完,班主任也要白白问 99999 次。
  • epoll 的做法(举手登记册):班主任再也不主动点名了。谁写完了作业,谁就自己主动举手,跑到讲台把名字写到一张"登记册(就绪队列)"上。班主任每次回教室,连底下的学生看都不看,直接拿起讲台上的登记册,上面有谁的名字,就去收谁的作业。

通过这种"谁有事谁说话"的异步回调机制,epoll 完美地化解了 poll 的三大死局:

  1. 告别 O(N) 的冗余拷贝 :epoll 不再要求应用层每次都把几十万个 fd 统统塞给内核。它在内核中开辟了一块长期存在的专属空间,你只需要把要监控的 fd 告诉内核一次,以后就再也不用传来传去了。
  2. 告别内核态的 O(N) 轮询:底层网卡收到数据触发硬中断后,内核直接通过回调机制,精准地将收到数据的 fd 扔进一个"就绪集合"中,绝对不会再去傻傻遍历所有的 fd。
  3. 告别用户态的 O(N) 盲查 :epoll 每次返回时,直接把刚才那个"就绪集合"端给用户。用户层拿到手里的一定是 100% 来了数据的 fd,不用再写那恶心的 for 循环去挨个做按位与(&)探测了。时间复杂度瞬间从 O(N) 骤降为 O(1)(仅与活跃连接数成正比)。

了解了 epoll 摧枯拉朽的宏观优势,接下来,我们必须直接潜入 Linux 内核,去看看支撑起这种"事件驱动"魔法的底层数据结构究竟长什么样,它是如何一步步将 I/O 多路转接推向神坛的。

2 撕裂历史的 API 设计:epoll 的三大系统调用全解

在 select 和 poll 时代,多路转接的 API 设计有着一个极其致命的架构缺陷------"配置"与"等待"的强耦合。

回想一下上一章的 poll,你必须在同一个函数调用中,同时完成三件事:"告诉内核我要监控谁"、"陷入阻塞等待数据"以及"获取最终的就绪结果"。这种把所有逻辑揉成一团的单体函数设计,注定了每次调用都必须伴随着庞大数据结构的跨态拷贝。

Linux 架构师敏锐地察觉到了这个历史包袱。为了彻底实现"事件驱动"与"状态分离",epoll 毫不留情地将那个臃肿的单体接口撕裂,重构为三个极其优雅且职责单一的系统调用。这三大接口的问世,直接宣告了 Linux 网络编程进入高性能现代化时代。

2.1 epoll_create:在内核态圈地,搭建"专属监控室"

既然每次把十几万个文件描述符(fd)从用户态搬运到内核态的代价极其昂贵,那为什么不直接让内核自己在底层开辟一块常驻内存 ,用来长期保存用户关心的连接呢?这就是 epoll_create 的核心使命。

c 复制代码
#include <sys/epoll.h>

int epoll_create(int size);


epoll_create(1);
epoll_create1(0);//无区别两者,这是新的接口

【参数详解】

  • size :这是一个带有浓厚历史遗迹的参数。在早期的 Linux 2.6.8 版本之前,内核底层是使用哈希表 来管理这些百万级 fd 的,因此需要用户传入一个 size 来预估数量,以便内核提前分配哈希桶的大小。但后来内核团队对底层进行了史诗级重构,将哈希表替换成了具备动态扩容能力、查询效率极高的红黑树 。自此,size 参数在内核中就失去了原本的意义,直接被忽略 。但在现代代码中,为了保持 API 的向后兼容性,你传入的值依然必须严格大于 0,否则系统会直接报错。

【返回值详解】

  • 成功 :返回一个大于 0 的非负整数 ,这是一个全新的文件描述符,我们通常称之为 epfd(epoll 句柄)。

    • 深度剖析 :这体现了 Linux 最核心的"一切皆文件"哲学。内核在底层创建的这个"监控室"(实际上是一个名为 eventpoll 的重量级结构体),本身也被抽象成了一个文件资源。后续所有的增删改查、阻塞等待,全部都要拿着这个 epfd 作为令牌去执行。
  • 失败 :返回 -1 ,并自动设置全局变量 errno。常见的错误原因包括 EMFILE(当前进程打开的文件描述符已达上限)或 ENOMEM(内核内存不足)。

避坑指南 :既然 epfd 是一个文件描述符,它就会占用进程的 fd 配额。当你的程序不再使用 epoll 时,必须显式调用 close(epfd),否则会导致极其严重的内核句柄泄漏。

2.2 epoll_ctl:告别全量拷贝,O(log N) 的精准"增删改"

专属监控室建好了,接下来就是往里面注册需要监控的套接字。poll 的做法是每次把包含 10 万个元素的数组整个砸给内核,而 epoll 提供了 epoll_ctl(Control 函数),支持以红黑树 O(log N) 的极低时间代价,对单个 fd 进行精准的点对点操作。

c 复制代码
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

【参数详解】

  • epfd :由 epoll_create 颁发的营业执照,告诉内核你要操作的是哪一个 eventpoll 对象。

  • op (Operation 操作指令):你想对内核下达什么命令?系统严格规定了三个语义明确的宏:

    • EPOLL_CTL_ADD:注册。向 epoll 监控树中添加一个新的 fd。
    • EPOLL_CTL_MOD:修改。修改已经注册的 fd 的监听事件(例如,本来只监听可读,现在改成同时监听可读和可写)。
    • EPOLL_CTL_DEL:删除 。从 epoll 中彻底拔除并注销一个 fd。注意:执行删除操作时,内核不再关心你要监听什么事件,因此最后一个参数 event 通常可以直接传 NULL(在 2.6.9 版本之后的内核中完全安全)。
  • fd :你要操作的具体目标套接字(例如刚 accept 下来的那个客户端 fd)。

  • event :你要告诉内核,这个 fd 上具体关心什么事件。这是一个极其核心的结构体指针,下面将做毁灭性深挖。

【返回值详解】

  • 成功 :返回 0。表示增删改操作已在内核态完美落盘。
  • 失败 :返回 -1 ,并设置 errno。
    • EEXIST:你试图 ADD 一个已经存在于 epoll 树中的 fd。
    • ENOENT:你试图 MOD 或 DEL 一个根本不在 epoll 树中的 fd。
    • EBADF:传入的 epfd 或 fd 是一个无效的文件描述符。
2.2.1 深入解析 struct epoll_event 与黑魔法 union

无论是添加还是修改,我们都必须给内核传递一个 struct epoll_event 结构体。现代 C++ 网络框架(如 Muduo、Sylar)底层 Reactor 模型的心脏,就跳动在这个结构体里:

c 复制代码
struct epoll_event {
    uint32_t     events;      /* Epoll 关心的事件掩码 */
    epoll_data_t data;        /* 用户态自定义的数据载荷 */
};

核心字段 1:events(事件掩码)

这部分和上一章的 poll 极为相似,也只有一个比特位是1,本质上依旧是利用底层的 bit(比特位)来传递标志位。内核提供了一系列宏,通过按位或(|)进行组合拼装:

  • EPOLLIN:表示对应的 fd 接收缓冲区有数据可读(对端正常挥手关闭也会触发此事件,表现为读到 0 字节)。
  • EPOLLOUT:表示对应的 fd 发送缓冲区有空间可写。
  • EPOLLET:边缘触发模式(Edge Triggered)的开启标志。默认是水平触发(LT),加上这个宏就开启了极为暴力的 ET 模式(这是 epoll 性能登峰造极的大招,后续我们将独立一章进行源码级解构)。
  • EPOLLERR / EPOLLHUP:分别代表错误和挂断事件。这些事件内核会强制默认监听 ,应用层不需要手动在 events 里添加,只需在返回时检查即可。

核心字段 2:data(联合体 epoll_data_t)

这是一个令人拍案叫绝的 union 设计,它是 epoll 能够实现 O(1) 极速业务派发的核心根基:

c 复制代码
typedef union epoll_data {
    void        *ptr;
    int          fd;
    uint32_t     u32;
    uint64_t     u64;
} epoll_data_t;

为什么偏偏要用联合体(union)而不是普通结构体?

因为这四个变量在物理内存上共享着同一块 8 字节(64位系统下)的空间 ,同一时刻你只能使用其中一个。内核在这里的设计语境极其霸道:"我不管你这 8 个字节存的是什么业务逻辑,你交给我什么,我就原封不动地替你在内核里保管。等事件触发唤醒你时,我再原样交还给你。"

epoll_data_t 本质上就是一个用户自定义数据存储容器。

  • 基础玩法(存入 fd) :最朴素的用法,就是把当前监控的套接字存进去(event.data.fd = sockfd)。等内核唤醒进程时,应用层拿出来一看,直接拿这个 fd 去调用 read。
  • 高阶工业级玩法(存入 ptr) :在面向对象的高并发 C++ 服务器中,一个 fd 往往绑定着一个极为庞大且复杂的类实例(比如 class TcpConnection,里面封装了应用层读写缓冲区、业务回调函数等)。如果 data 里只存一个 fd 整数,进程被唤醒后,我们还得去一个全局的哈希表(如 std::unordered_map<int, TcpConnection*>)里,通过 fd 键值去查出对应的对象指针。在单机百万并发下,这平白无故增加了一次极度昂贵的锁竞争与哈希查找开销。
    降维打击的玩法是 :在调用 epoll_ctl 注册时,我们直接把对象的 this 指针强转为 void*,塞进 data.ptr 里。当 epoll_wait 返回就绪事件时,我们拿到的 ptr 直接 static_cast 强转回 TcpConnection*。彻底绕过全局哈希表,一次查找都不需要,通过内存绝对地址 O(1) 极速定位庞大的业务对象! 这,就是 C++ 底层开发的极致暴力美学。

2.3 epoll_wait:坐享其成的 O(1) 盲盒收割

事件都注册进内核了,最后一步就是静静等待网卡数据的降临。epoll_wait 彻底终结了用户态的 O(N) 盲目轮询,它在应用层眼中,就是一台绝对精准的"盲盒收割机":内核吐出来的每一个元素,都必定带着实际数据,绝不让你白跑一趟。

c 复制代码
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

【参数详解与数据流向】

  • epfd:epoll 句柄,锁定那个常驻内核的 eventpoll 对象。

  • events :这是一个纯输出型的数组指针! 用户态在堆或者栈上开辟一块 epoll_event 数组,把首地址传进去。

  • 极度舒适的改变 :这里面的数据不需要像 poll 那样在调用前做任何初始化 。内核一旦发现有 fd 就绪,就会把它们的事件状态(掩码)和我们之前存进去的 data,精准拷贝到这个数组的最前面。

  • maxevents :告诉内核,我传进来的这个 events 数组最多能装多少个事件。这主要是为了防止内核在向用户态拷贝就绪队列时发生内存越界越位。它的值必须大于 0,且通常等于你开辟的数组容量。

  • timeout:阻塞超时控制,单位是毫秒(ms)。底层直接映射为内核态进程调度机制。

    • -1:死等。当前进程交出 CPU 陷入睡眠,直到至少有 1 个事件就绪或收到系统信号才被唤醒。
    • 0:非阻塞轮询。内核扫一眼内部的就绪队列,有就有,没有就立刻返回,绝不挂起当前进程。
    • > 0:限时等待。最多睡眠指定的毫秒数,超时后自动苏醒。

【返回值详解】

  • > 0 :返回实际发生就绪事件的个数 (n) 。这是最理想的情况,代表内核向你传入的 events 数组的前 n 个位置填入了有效数据。
  • == 0 :代表 timeout 设定的时间已到,但没有任何事件发生,超时返回。
  • -1 :代表调用出错,并设置 errno。最常见的是 EINTR,表示 epoll_wait 在阻塞沉睡期间被系统的异步信号打断了,这种情况通常只需要 continue 重新调用即可。

颠覆性的逻辑闭环:

回想一下 poll 的灾难现场。poll 虽然返回了就绪数量 n,但用户态一头雾水,依然只能老老实实写一个 for (int i = 0; i < 100000; ++i),把十万个 fd 全部遍历一遍,去验证 if(revents & POLLIN)。

而在 epoll_wait 中,如果返回值是 5,代表有 5 个事件就绪。内核非常贴心且守规矩地把这 5 个就绪的 epoll_event 结构体,严丝合缝地按顺序填在了 events[0] 到 events[4] 的连续内存位置上。

于是,用户态的业务代码瞬间变得无比清爽且致命高效:

c 复制代码
// 陷入内核阻塞,直到有数据到来
int ready_num = epoll_wait(epfd, events, MAX_EVENTS, -1);

// 绝杀!直接遍历 ready_num!再也不用遍历那十万个空闲连接了!
for (int i = 0; i < ready_num; ++i) {
    // 拿出来的 100% 都是真真切切来了数据的 fd,或者直接强转为业务层对象指针
    int ready_fd = events[i].data.fd;
    uint32_t mask = events[i].events;
    
    // ... 毫无废动作,拿到对象直接去 read/write 处理业务 ...
}

从 O(N) 的地毯式盲扫,到 O(就绪数量) 的精准收割,epoll 在 API 设计层面上,将应用层的无用功压缩到了物理极限。

3 epoll 原理:红黑树、就绪队列与回调通知机制

epoll_create1() 会创建一个 struct eventpoll 内核对象,并将它的地址保存到 epoll 文件描述符对应的 struct file 的 private_data 中。 注意:这里指的是 epoll 自己的 struct file,不是被监听的 socket 对应的 struct file。

select 和 poll 每次调用时,都需要应用层把几十万个文件描述符硬塞给内核,内核再去遍历这几十万个连接,系统调用返回后,应用层还得自己再遍历一遍。这就像是你每次去快递站,都要把全镇人的名字报一遍,快递员把你领到仓库,让你自己挨个包裹翻看有没有自己的。

epoll 彻底掀翻了这种愚蠢的"大锅饭"模式。它的核心架构改变只有一句话:把"长期管理哪些文件描述符"与"本轮哪些文件描述符已经就绪"彻底物理分离。

在 Linux 内核中,一个 epoll 实例主要维护着两套截然不同的数据结构:

  1. 兴趣集合(Interest List) :记录应用层长期关注哪些 fd 以及什么事件。由 红黑树(RB-Tree) 管理。
  2. 就绪集合(Ready List) :专门记录当前已经发生事件、可以直接处理的 fd。由双向链表管理。

epoll 的运转逻辑极其优雅:你通过 epoll_ctl 把关心的 fd 挂到红黑树上;当网卡收到数据时,内核通过底层硬件中断触发自动回调 ,直接把对应的节点塞进就绪链表中;而 epoll_wait 就像个无情的收割机,它根本不看红黑树,只盯着就绪链表,有东西就打包带回应用层。

下面,我们将顺着 epoll 的三大接口,劈开 Linux 源码,直视这套机制的内核真容。

3.1 epoll_create:在内核中拔地而起的 eventpoll 监控室与等待队列

当我们执行 int epfd = epoll_create(1); 时,底层到底发生了什么?很多资料会笼统地概括为"在内核创建了一棵红黑树",这个说法不仅片面,而且掩盖了 epoll 架构的精妙之处。

真实的过程是,内核调用 do_epoll_create,在系统底层申请分配了一个极其庞大且核心的结构体:struct eventpoll。不仅如此,内核还会为这个对象创建一个匿名的 inode 文件,把这个 eventpoll 对象的指针藏在 file->private_data 中,最后把这个匿名文件的描述符(也就是 epfd)返回给用户态。

我们来看这个 eventpoll 实例的内核本体(保留核心字段):

c 复制代码
struct eventpoll {
    // 1. 兴趣集合:一颗红黑树的根,长期保存所有被注册的 epitem 节点
    struct rb_root_cached rbr;

    // 2. 就绪集合:一个双向链表,只保存当前可立即返回给用户的 epitem
    struct list_head rdllist;

    // 3. 🌟 核心枢纽:阻塞等待队列 (Wait Queue)
    // 当没有就绪事件时,调用 epoll_wait 的用户线程就睡在这里
    wait_queue_head_t wq;

    // 4. 溢出暂存链表:当 epoll_wait 正在拷贝数据时,暂存突发到达的新事件
    struct epitem *ovflist;
    
    // 5. 锁机制:保护 rdllist、ovflist 的自旋锁,保护操作的互斥锁等
    spinlock_t lock;
    struct mutex mtx;
    
    // 6. 反向指针:指向代表当前 epoll 实例的匿名 struct file
    struct file *file;
};

【硬核拆解:什么是等待队列 wq?】

在 Linux 内核中,"等待队列(Wait Queue)" 是实现进程阻塞与唤醒的绝对基石。它本质上是一个带有自旋锁的双向链表,链表里挂着的,是一个个因为等不到资源而被迫交出 CPU 执行权、陷入睡眠状态(如 TASK_INTERRUPTIBLE)的进程/线程描述符(task_struct)。

当你调用 epoll_wait 且当前没有任何网络数据时,你的当前进程就会被打包成一个等待队列节点,挂载到这个 eventpoll->wq 链表上,然后彻底沉睡。直到将来底层的网卡收到数据,内核才会顺藤摸瓜找到这个 wq,把你从梦中强行唤醒。

刚执行完 epoll_create 时,红黑树和就绪链表都是空的。所以,epoll_create 并不是简单地建了棵树,而是搭建了一个包含红黑树、就绪链表以及进程睡眠舱(等待队列)的完备监控室。

【图解补充:进程通过 fd 管理 epoll 模型的纽带】

正如参考图所示,当应用层调用 epoll_create 拿到返回值 epfd 后,进程的控制流与 OS 内部 epoll 模型的桥梁就彻底打通了。进程拿着 epfd,会在其打开文件描述符表中索引到一个对应的 struct file 结构体。内核巧妙地利用了这个 struct file 中的 void *private_data; 字段,将其直接指向 OS 内部创建的这个 epoll模型 (即 eventpoll 对象)。

这意味着,进程根本不需要知道底层树和队列在哪,后续只需通过 epoll_ctl 或 epoll_wait 传入这个简单的整数 epfd,系统就能顺着 file->private_data 瞬间定位到这颗红黑树(rb_tree 默认是空的)和就绪队列,实现统一的高效管理。

刚执行完 epoll_create 时,红黑树和就绪链表都是空的。所以,epoll_create 并不是简单地建了棵树,而是搭建了一个设施完备的监控室。

3.2 epoll_ctl 与 struct epitem:红黑树上的哨兵节点

3.2.0 epoll_ctl 在做什么
c 复制代码
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);

一句话:

"epfd,帮我盯着 fd,它发生 event 里关心的事件就通知我。"

内核要为这条监控关系长期保存一份记录,于是给这个连接分配一个结构体:

c 复制代码
struct epitem

它就是内核发给每个被监控连接的"监控工牌",挂在 epoll 实例的红黑树上,直到 EPOLL_CTL_DEL 或 fd 关闭。

3.2.1 epitem 结构
c 复制代码
struct epitem {
    union {
        struct rb_node rbn;    // 身份 1:红黑树节点
        struct rcu_head rcu;   // 延迟释放
    };

    struct list_head rdllink;   // 身份 2:就绪链表节点
    struct epitem *ovflist_next; // 身份 3:扫描期间临时挂 ovflist

    struct epoll_key ffd;       // 核心标识:(file 指针, fd 整数)
    struct eppoll_entry *pwqlist; // 通往 Socket 等待队列的桥梁
    struct eventpoll *ep;       // 反向指向所属 eventpoll
    struct epoll_event event;   // 关注事件 + 用户数据
};

字段分三类:

分类 字段 作用
身份 rbn、rdllink、ovflist_next 不同时刻挂在不同的数据结构上
标识 ffd 我是谁(哪个 file,哪个 fd)
业务 event、pwqlist、ep 关心什么?属于谁?怎么联系 Socket?
3.2.2 身份字段:一个节点,三种挂法

同一个 epitem,可以同时出现在多个数据结构里。

身份 1:rbn ------ 红黑树节点

回答:

"这个 fd 归我管吗?"

只要还在监控,epitem 就一直在红黑树里。

回答:

"这个 fd 现在有事件了吗?"

数据到达时,内核通过 rdllink 把 epitem 挂到就绪链表 rdllist。

关键点:挂就绪链表时,不从红黑树删除
text 复制代码
数据到达
↓
找到红黑树里的 epitem
↓
用 rdllink 挂到就绪链表
↓
rbn 仍留在红黑树,不动

所以一个 epitem 可以同时:

text 复制代码
红黑树:在(还在监控)
就绪链表:在(现在有事件)
身份 3:ovflist_next ------ 扫描期间的暂存链表

只在"内核正在扫描就绪链表、又有新事件到达"时用,避免边遍历边插入破坏链表。本轮扫描结束后合并。不是长期身份。

3.2.3 标识字段:epoll_key ffd
c 复制代码
struct epoll_key ffd;  // { struct file *file; int fd; }
为什么 key 不用 fd,而用 (file, fd)?

因为 fd 不是全局唯一的:

c 复制代码
int fd2 = dup(fd1);   // fd1、fd2 指向同一个 struct file
fork();               // 父子进程相同 fd 整数也可能指向同一 file

只用一个 fd 整数做 key,不同连接可能撞车。

所以 epoll 用组合键:

text 复制代码
(file 指针, fd 整数)
  • file 指针:保证物理连接唯一
  • fd 整数:区分同一连接的不同 fd

dup、fork 场景下 key 仍唯一。

3.2.4 业务字段
字段 作用
event 保存应用关心的 EPOLLIN/EPOLLOUT 和 data.ptr;epoll_wait 时拷回用户
pwqlist epitem 与 Socket 等待队列之间的桥;数据到达时靠它找到 epitem
ep 反向指针,指向所属 eventpoll,用于把 rdllink 挂到正确就绪链表
3.2.5 完整流程

epoll_ctl(ADD):

text 复制代码
epoll_ctl(epfd, ADD, fd, &event)
↓
分配 epitem
↓
填 ffd = (file, fd)
↓
填 event = 关注事件
↓
建立 pwqlist,挂到 Socket 等待队列
↓
rbn 插入 epoll 红黑树
↓
返回

数据到达:

text 复制代码
网卡收包
↓
Socket 等待队列 → pwqlist → 找到 epitem
↓
rdllink 挂到就绪链表 rdllist
↓
(rbn 仍在红黑树,不删)
↓
epoll_wait 唤醒,扫描就绪链表
↓
把 epitem.event 拷回用户

epitem 是内核给每个被监控连接发的"监控工牌"。

  • rbn 挂红黑树 → "我还在被监控"
  • rdllink 挂就绪链表 → "我现在有事件"
    两个挂钩可同时使用,数据到达只挂就绪链表,不从红黑树删除 。
    工牌编号用 (file, fd) 而非单个 fd,是为了在 dup、fork 下仍唯一。

3.3 核心魔法:从硬件中断到 ep_poll_callback 的全链路回调机制

3.3.0 先搞清这一节要解决什么问题

上一节说:epoll_ctl(ADD) 会把 epitem 挂到红黑树上。

但红黑树只是"登记簿",它不会自己发现"谁有数据了"。

问题来了:

epoll 不轮询,它怎么知道某个 fd 来数据了?

答案是:

在数据到达之前,epoll 提前往 Socket 的等待队列上"埋"了一个回调函数。数据一到,协议栈自动调用这个回调,回调再把 epitem 挂到就绪链表。

这一节就讲这条链路:从网卡收包,到 epoll_wait 被唤醒。

3.3.1 第一阶段:埋雷(epoll_ctl 时安装探针)

调用:

c 复制代码
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);

内核除了把 epitem 挂红黑树,还会做一件关键的事:

调用目标 Socket 的 poll 函数(TCP 对应 tcp_poll)。

tcp_poll 里会调用 poll_wait(),最终执行到 epoll 注入的钩子:

c 复制代码
ep_ptable_queue_proc

这个钩子干了两件事:

  1. 分配一个桥梁对象 eppoll_entry
  2. 把回调函数 ep_poll_callback 挂到 Socket 的内核等待队列上

用大白话讲:

在 Socket 的"有事叫我"名单上,写下了 ep_poll_callback 的电话号码。

埋完雷,内核就不管了,不会轮询。


3.3.2 第二阶段:引爆(网卡收包 → 数据进 Socket)

客户端发来数据,服务器这边发生:

text 复制代码
网卡收到包
↓
DMA 写入内存,发硬件中断(IRQ)
↓
CPU 响应,触发软中断 NET_RX_SOFTIRQ
↓
协议栈层层解析:MAC 头 → IP 头 → TCP 头
↓
确认属于某个 Socket
↓
封装成 sk_buff,推入该 sock 的接收队列 sk_receive_queue

到这一步,数据已经躺在 Socket 的接收队列里了。

但应用层还在 epoll_wait 里睡着,它怎么知道?


3.3.3 第三阶段:收网(协议栈调用回调)

数据进队列后,协议栈必须通知上层。

调用链:

c 复制代码
// 1. 数据入队后,调用 sock 的状态通知函数
sk->sk_data_ready(sk);

// 2. TCP 下默认指向 sock_def_readable
void sock_def_readable(struct sock *sk) {
    struct socket_wq *wq;

    rcu_read_lock();
    wq = rcu_dereference(sk->sk_wq);  // 拿到 Socket 自己的等待队列

    if (skwq_has_sleeper(wq))
        // 唤醒等待队列上的节点
        wake_up_interruptible_sync_poll(&wq->wait,
            EPOLLIN | EPOLLPRI | EPOLLRDNORM | EPOLLRDBAND);

    rcu_read_unlock();
}
关键点:等待队列上挂的不是"睡觉的进程"

普通阻塞 I/O 时,进程会把自己挂到 Socket 等待队列上睡觉。但 epoll 不一样:等待队列上挂的是第一阶段埋下的 ep_poll_callback。 所以 wake_up_interruptible_sync_poll 一执行,就直接调用了 ep_poll_callback。这就是"引爆地雷"。

3.3.4 ep_poll_callback 做了什么

核心逻辑:

c 复制代码
static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode,
                            int sync, void *key) {
    // 1. 顺藤摸瓜:从等待队列节点找到 eppoll_entry,再找到 epitem
    struct epitem *epi = ep_item_from_wait(wait);

    // 2. 找到 epitem 所属的 eventpoll
    struct eventpoll *ep = epi->ep;

    spin_lock_irqsave(&ep->lock, flags);

    // 3. 记录真实发生的事件
    epi->revents |= (unsigned long)key;

    // 4. 如果这个 epitem 还不在就绪链表里
    if (!ep_is_linked(epi)) {
        // 把它的 rdllink 挂到 eventpoll 的就绪链表尾部
        list_add_tail(&epi->rdllink, &ep->rdllist);
    }

    // 5. 如果有进程正在 epoll_wait 里睡着,唤醒它
    if (waitqueue_active(&ep->wq)) {
        wake_up(&ep->wq);
    }

    spin_unlock_irqrestore(&ep->lock, flags);
    return 1;
}

逐条翻译:

步骤 大白话
1 从"电话"反查到"工牌" epitem
2 找到工牌所属的 epoll 实例
3 在工牌上记一笔:这次是 EPOLLIN 就绪
4 把工牌的 rdllink 挂到就绪链表(不删红黑树里的 rbn)
5 叫醒正在 epoll_wait 里睡觉的进程
3.3.5 为什么说这是 O(1)

对比 select:

text 复制代码
select:
数据到达
↓
进程醒来
↓
for 遍历所有 fd,逐个检查谁就绪
↓
O(N)

epoll:

text 复制代码
数据到达
↓
协议栈直接调用 ep_poll_callback
↓
回调直接把对应 epitem 挂到就绪链表
↓
epoll_wait 醒来,只遍历就绪链表
↓
O(1)(准确说是 O(就绪数))

关键区别:

select 是"醒了再找谁有事";epoll 是"有事的人自己来报到"。

全程没有任何 for/while 去遍历 10 万个连接。

3.3.6 全链路一张图
text 复制代码
【埋雷】epoll_ctl(ADD)
    ↓
分配 epitem,挂红黑树
    ↓
调用 tcp_poll → poll_wait → ep_ptable_queue_proc
    ↓
把 ep_poll_callback 挂到 Socket 等待队列
    ↓
(内核不再轮询)


【引爆】网卡收包
    ↓
硬件中断 → 软中断 → 协议栈解析
    ↓
数据入 sk_receive_queue
    ↓
sk_data_ready → sock_def_readable
    ↓
唤醒 Socket 等待队列
    ↓
调用 ep_poll_callback


【收网】ep_poll_callback
    ↓
从 wait 找到 epitem
    ↓
epi->revents 记录事件
    ↓
epi->rdllink 挂到 ep->rdllist(就绪链表)
    ↓
wake_up(&ep->wq) 叫醒 epoll_wait 的进程


【返回】epoll_wait
    ↓
遍历就绪链表 rdllist
    ↓
把 epitem.event 拷回用户空间

3.4 epoll_wait:精准收割与 ovflist 护航

最后,应用层调用 epoll_wait(epfd, events, maxevents, timeout),它是如何提取事件的?

进入内核的 do_epoll_wait 后,逻辑非常干脆:

  1. 看一眼链表 :检查 eventpoll->rdllist 是否为空。
  2. 没货就睡 :如果为空且没超时,把当前线程挂到 eventpoll->wq 上,让出 CPU,陷入睡眠。
  3. 有货就搬 :如果 rdllist 里有节点,把这些就绪的 epitem 批量摘下来。
  4. 【二次验货】 :为什么要再次调用目标文件的 poll() 确认状态?因为从网卡触发回调到线程真正苏醒被调度,期间有时间差,状态可能发生改变。只有当前仍然满足读写条件的事件,才会把真实的 revents 连同用户最开始存入的 data 复制到用户空间的 events 数组中。

【极限并发下的护航者:ovflist】

这里隐藏了一个极度硬核的并发问题:当 epoll_wait 正在遍历 rdllist 并往用户空间拷贝数据时,为了防止链表错乱,必定要加上自旋锁。但如果就在这毫秒级的拷贝期间,网卡又收到了一大波新数据,触发了 ep_poll_callback 怎么办?

锁被占了,新来的回调难道要死等阻塞,导致底层网卡堆积吗?

内核的解法是:引入 struct epitem *ovflist(溢出单链表)。

  • 当 epoll_wait 正在扫描就绪链表时,如果有新事件回调触发,内核直接把新就绪的节点暂存挂入 ovflist 中,绝不阻塞硬件级的中断回调。
  • 等 epoll_wait 这一批拷贝完、松开锁之后,再把 ovflist 里的节点无缝合并回 rdllist 里,留给下一次收割。

【破除迷思 1:就绪数据是严格按照 0 到 n 存放的吗?】

绝对严格! 内核在遍历 rdllist 时,会维护一个计数器(假设最终有 n 个事件就绪),它会严格从 events[0] 填充到 events[n-1] 。

这带给用户态极大的性能解放:当 epoll_wait 返回 n 时,用户态只需要写一个 for(int i = 0; i < n; ++i),直接对 events[i] 进行业务处理即可。这个数组的前 n 个位置,100% 都是真实就绪的活跃事件,绝对没有空洞,也绝对不需要去按位遍历空闲连接!

【破除迷思 2:epoll 到底用没用到 mmap 内存映射技术?】

互联网上充斥着大量似是而非的八股文,宣称"epoll 高效是因为使用了 mmap,实现了内核态与用户态共享内存,避免了拷贝"。

这纯属无稽之谈,是彻头彻尾的谣言!

在 Linux 内核的 epoll 源码(fs/eventpoll.c)中,捞取就绪节点时调用的核心函数是 ep_send_events_proc,在其内部,清晰地调用了 __put_user (一种在内核态向用户态空间安全写入数据的宏,本质就是内存拷贝)。

内核之所以必须执行拷贝,是因为内核空间和用户空间有着严格的页表隔离与权限鸿沟。如果让用户态直接通过映射访问内核中的 epitem 数据结构,不仅会暴露内核内存布局,用户态进程甚至可以恶意篡改内核链表指针,导致整个操作系统崩溃。

结论:epoll 必须,且确确实实进行了内存拷贝。 它的高效不在于"不拷贝",而在于"只拷贝那些真正发生了事件的极少数节点",从而将拷贝量从 O(总连接数) 骤降到了 O(活跃连接数)。

补充 :拔除暗桩,不用了直接 close(fd) 行不行?

当一个客户端断开连接,我们不再需要监控这个 fd 时,很多初学者会图省事,直接调用 close(fd),而不去调用 epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL)。

这种做法在绝大多数简单的场景下是"看似正常的",因为 Linux 内核在 VFS(虚拟文件系统)层面为你兜了底。

当你调用 close(fd) 时,内核会减少对应 struct file 的引用计数。当引用计数降为 0,触发 file 销毁流程(__fput)时,内核会自动调用 eventpoll_release_file,顺藤摸瓜找到所有挂载过该 file 的 epoll 树,把那些暗中关联的 epitem 节点强行抹除,并注销等待队列上的回调函数。

但这种"偷懒"会埋下极其惨烈的定时炸弹:

如果你在多进程/多线程架构中,对该 fd 调用过 dup() 或者 fork() 继承,导致底层同一个 struct file 的引用计数大于 1。

此时你调用 close(fd) 仅仅是关闭了其中一个描述符,底层的 file 并没有销毁。这个连接对应的 epitem 会依然死死地挂在红黑树上,底层网卡的探针也没有拔除!

结果就是:虽然你的应用层以为连接关了,但只要客户端再发数据,底层的 ep_poll_callback 依然会被疯狂触发,导致 epoll_wait 不断返回一个你已经无法处理的"幽灵 fd",瞬间引发 CPU 100% 的空转灾难(这在业界被称为 epoll 的幽灵句柄问题)。

因此,工业级的硬核铁律是:在调用 close(fd) 归还系统句柄之前,必须绝对显式地调用 epoll_ctl(..., EPOLL_CTL_DEL, ...),亲手将这个节点从红黑树上拔除,将底层的回调探针彻底销毁,绝不把垃圾留给内核的垃圾回收器去猜。

3.5 LT 与 ET 的底层状态抉择

在 epoll_wait 拷贝完事件准备返回前,内核还要做最后一个决策:刚拿出来的这些 epitem,要不要重新塞回就绪队列? 这取决于你设置的触发模式。

  • LT(水平触发,默认) :只要 Socket 接收缓冲区中仍有未读取的数据,fd 就持续处于可读状态。下一次调用 epoll_wait() 仍会收到通知,不要求一次读完。

  • ET(边缘触发, EPOLLET) :只在就绪状态发生变化时通知,不会因为缓冲区还有残留数据就反复通知。因此必须使用非阻塞 Socket ,循环 recv(),直到返回 -1 且 errno == EAGAIN(或 EWOULDBLOCK),确保数据读尽。

补充 :epoll 的工作模式,LT 与 ET 的底层抉择

在 epoll 的世界里,当我们通过 epoll_wait 捞取就绪事件时,内核面临着一个极度核心的决策:如果你这次没把数据读干净,下次还要不要继续通知你?

为了解答这个问题,epoll 提供了两种截然不同的工作模式:LT(Level Triggered,水平触发) 与 ET(Edge Triggered,边缘触发)。

在深入代码和底层机制前,我们先通过一个极度写实的"送快递"场景,把这两个模式的物理直觉彻底打通。

1 暴躁的李四与卑微的张三:一秒看懂 LT 与 ET

假设你(用户进程)是个重度网购狂(接收缓冲区),今天到了 5 个快递(网络数据包)。负责给你送货的,是两个性格截然不同的快递员:张三(LT) 和 李四(ET)。

  • 张三的作风(LT 模式):极其卑微,死缠烂打
    张三把 5 个快递送到你楼下,给你打电话:"你的快递到了,快下来拿!"。你接了电话,但正忙着打游戏,随口敷衍了一句就挂了。
    张三一看你没来,过了一会儿又给你打电话 。你还是没动。
    这时,另一个快递员又送来 1 个你的新包裹交给了张三,张三拿着 6 个包裹,继续给你打电话 。
    最后你终于下楼了,但你双手拿不下,只拿走了 3 个包裹,跟张三说:"剩下的你先拿着,我等会儿再拿"。张三毫无怨言,只要他手里还有你的包裹,他就会无休止地给你打电话,直到你把所有包裹全部取完。
  • 李四的作风(ET 模式):极度暴躁,过时不候
    李四拿着 5 个快递到你楼下,打电话给你:"你的包裹到了,我不等,你不拿我就走!"。你沉迷游戏,没搭理他。
    过了一分钟,张三刚好路过,把你买的另一个新包裹递给了李四。李四手里的包裹从 5 个变成了 6 个(发生了变化) ,于是他再次给你打了一个电话 :"包裹变多了,赶紧滚下来拿!"。
    你终于下楼了,同样因为拿不下,只拿走了 3 个包裹,让李四等一下。李四冷笑一声:"我不管你拿走几个,反正我通知过了,剩下的你自己看着办,我马上走人!"说完直接消失。如果你下楼一趟什么都不拿,或者没拿完,只要后续没有新的包裹再送来 ,李四这辈子都不会再给你打第二个电话。
2 剥开表象看本质:什么是通知?

在 Linux 网络编程中,很多初学者会把"通知"和"处理"混为一谈。我们要明确一个底层事实:通知 != 处理事件。

我们在前面讲过,epoll 的红黑树上挂着 epitem 节点。当网卡收到数据触发硬中断时,底层的回调函数会把这个 epitem 节点"激活",并把它强行拽进 eventpoll 的就绪双向链表(rdllist)中。

当用户调用 epoll_wait 时,内核会把这个就绪链表里的节点取走并清空,然后把事件拷贝给用户。

请注意:节点被 epoll_wait 取走,意味着本次"通知"已经下达。但此时红黑树上的那个 epitem 节点依然存在!

  • LT(水平触发): 就像张三。只要你的 Socket 接收缓冲区里一直有数据 ,内核在 epoll_wait 交付完事件后,会慷慨地把这个 epitem 节点重新塞回就绪队列的尾部 。你下次调用 epoll_wait,它还会马上弹出来通知你。epoll 默认就是处在这个模式下(select 和 poll 也是如此)。
  • ET(边缘触发): 就像李四。只要从就绪队列取走了节点,内核绝对不会主动把它放回去 。只有当底层的 Socket 接收缓冲区数据从无到有,或者从有到多(本质上是数据量发生了增量变化)时,底层的硬件回调才会再次触发,把节点重新放进就绪队列。它对每一次状态跃迁,只会通知一次。

为什么叫 LT 和 ET?(示波器的启发)

这两个词借用于电子工程中的示波器概念。

缓冲区有数据,代表高电平(1);缓冲区没数据,代表低电平(0)。

LT(Level) 关心的是"电平状态":只要处于高电平状态,就一直触发。

ET(Edge) 关心的是"边缘跳变":只有从低电平跳变到高电平的瞬间(上升沿),才触发一次。

3 倒逼出的极限编程:ET 模式与非阻塞循环

在 LT 模式下,因为内核兜底,你可以很从容:缓冲区有 10KB 数据,你每次只读 1KB,分 10 次读完也毫无毛病。

但在 ET 模式下,如果缓冲区有 10KB 数据,你只读了 1KB,剩下的 9KB 只要对端不再发新数据过来,你就再也读不到了,这就造成了极其惨烈的数据丢失与死锁。

因此,ET 模式直接倒逼 出了极其严苛的工业级编程范式:你必须在本次通知中,把数据全部读干榨净!

你怎么保证把数据全读完了?答案是:写一个 while 循环一直读!

但是,致命的问题来了:如果你用普通的阻塞 fd 去循环调用 recv,当缓冲区里的数据被你读干的那一瞬间,最后一次 recv 就会因为没有数据可读而死死地阻塞挂起! 整个线程直接瘫痪,服务器瞬间失去响应!所以,ET 模式的铁律诞生了:必须将 fd 设置为非阻塞(O_NONBLOCK)!

搭配 ET 模式的代码骨架永远是这样极其暴力的压榨流:

cpp 复制代码
// 必须是非阻塞 fd
while (true) {
    ssize_t n = recv(fd, buffer, sizeof(buffer), 0);
    if (n > 0) {
        // 读到了数据,存起来,继续读!绝不停下!
        continue; 
    } else if (n == 0) {
        // 对端关闭连接
        break;
    } else {
        // n < 0,出错了?
        if (errno == EINTR) continue; // 被信号打断,继续读
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            // 🌟 核心出口:底层明确告诉你"实在榨不出一滴水了"
            // 这时你才能心安理得地退出循环!
            break; 
        }
        // 真正的读取错误
        break;
    }
}
4 为什么顶级框架(如 Nginx)钟爱 ET 模式?

既然 ET 模式写起来这么麻烦,一不小心就死锁丢数据,为什么 Nginx、Redis 等工业级顶流依然对其趋之若鹜?

除了"通知次数少,减少了频繁唤醒和系统调用的开销(无效通知少,通知效率高)"之外,ET 模式在网络架构上带来了一个极其硬核的隐藏收益:更大限度地压榨 TCP 的吞吐量!

我们要知道,TCP 协议是有滑动窗口(流量控制)的。发送方能发多少数据,取决于接收方在 ACK 报文中通告的"接收窗口(Receive Window)"有多大。接收窗口的大小,本质上等于接收缓冲区剩余的空闲空间。

  • LT 模式允许你"慢慢吞吞"地读,这导致缓冲区经常处于半满状态。上层不着急,底层 TCP 只能告诉发送方:"我快满了,你慢点发。",网络吞吐量直接被上层代码拖垮。
  • ET 模式 的暴力循环机制,强迫你只要一有机会,就瞬间把接收缓冲区彻底抽干 !缓冲区一旦清空,TCP 就会立刻向发送方通告一个巨大的接收窗口。这就相当于在概率和机制上,告诉对端:"我这里路况极佳,给我全速开火发数据!"

在单机十万甚至百万并发的海量请求下,这种通过强制尽快抽干缓冲区来提高整体网络吞吐量的滚雪球效应,就是 ET 模式傲视群雄、登顶性能之巅的终极秘密。

3.6 辟谣与修正:epoll 的时间复杂度真的是绝对的 O(1) 吗?

很多八股文无脑宣称 epoll 的一切都是 O(1),这是极不严谨的。

  • epoll_ctl 的增删改 :需要在红黑树中查找节点,时间复杂度严格来说是 O(log N)(N 为监控总数)。
  • 回调将节点挂入就绪链表 :这是 O(1) 的极速操作。
  • epoll_wait 拷贝返回 :内核需要将就绪事件挨个复制给用户空间,时间复杂度是 O(K)(K 为本次实际就绪的事件数量)。

所以,epoll 真正的革命性在于:它的核心阻塞开销(epoll_wait)彻底脱离了"总连接数 (N)"的魔咒,降维成了只与"当前活跃连接数 (K)"成正比。

3.7 终极流转图:epoll 的六步生命周期闭环

至此,我们将整个 epoll 的底层链路打通,形成如下工业级的数据流转闭环:

  1. 创建 (Create) :epoll_create 在内核中开辟持久化的 eventpoll 实例,搭建空红黑树与空就绪链表。
  2. 注册 (Add/Mod) :epoll_ctl 申请 epitem,将其插入红黑树,并在目标 Socket 的等待队列上挂载内核级的 ep_poll_callback 探针。
  3. 硬件触发 (Trigger):网卡收包,协议栈解析,数据落入接收缓冲区,唤醒 Socket 等待队列。
  4. 自动入队 (Callback) :ep_poll_callback 顺藤摸瓜,将该 epitem 的 rdllink 追加到 eventpoll 的 rdllist 就绪链表中,并唤醒睡眠的 epoll_wait 线程。
  5. 收割 (Harvest) :epoll_wait 从睡眠中苏醒,抽出 rdllist 中的节点,二次验证状态后,将 data 和掩码拷贝到用户态 events 数组。
  6. 清理 (Del) :epoll_ctl(DEL) 彻底解绑并注销等待队列上的回调探针,从红黑树中抹去节点,归还内核内存。

这就是单机百万并发背后的终极黑魔法,也是现代网络编程无法逾越的性能之巅。

ctor 再次派发对应事件。**

epoll示例代码

cpp 复制代码
#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/epoll.h>

using namespace std;

const int PORT = 8080;
const int MAX_EVENTS = 1024;

// 发送全部数据(处理 send 可能部分发送的情况)
bool SendAll(int fd, const char* buf, int len)
{
    int total = 0;

    while (total < len)
    {
        int n = send(fd, buf + total, len - total, MSG_NOSIGNAL);

        if (n > 0)
            total += n;
        else if (n < 0 && errno == EINTR)
            continue;
        else
            return false;
    }

    return true;
}

// 删除客户端
void CloseClient(int epfd, int fd)
{
    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, nullptr);
    close(fd);
}

int main()
{
    // 1. 创建 TCP 监听 Socket
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);

    if (listenfd < 0)
    {
        perror("socket");
        return 1;
    }

    // 允许端口快速复用
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 2. 绑定 IP 和端口
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(listenfd, (sockaddr*)&addr, sizeof(addr)) < 0)
    {
        perror("bind");
        close(listenfd);
        return 1;
    }

    // 3. 开始监听
    if (listen(listenfd, 128) < 0)
    {
        perror("listen");
        close(listenfd);
        return 1;
    }

    // 4. 创建 epoll 实例
    int epfd = epoll_create1(0);

    if (epfd < 0)
    {
        perror("epoll_create1");
        close(listenfd);
        return 1;
    }

    // 5. 将监听 Socket 注册到 epoll
    epoll_event ev{};
    ev.events = EPOLLIN;       // 监听读事件
    ev.data.fd = listenfd;

    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    cout << "Server started: " << PORT << endl;

    // 6. 事件循环
    epoll_event events[MAX_EVENTS];

    while (true)
    {
        // 等待就绪事件
        int n = epoll_wait(epfd, events, MAX_EVENTS, -1);

        if (n < 0)
        {
            if (errno == EINTR)
                continue;

            perror("epoll_wait");
            break;
        }

        // 7. 遍历本次返回的就绪事件
        for (int i = 0; i < n; i++)
        {
            int fd = events[i].data.fd;

            // 情况一:监听 Socket 可读,有新连接
            if (fd == listenfd)
            {
                sockaddr_in client{};
                socklen_t len = sizeof(client);

                int connfd = accept(
                    listenfd,
                    (sockaddr*)&client,
                    &len
                );

                if (connfd < 0)
                {
                    perror("accept");
                    continue;
                }

                cout << "New client: " << connfd << endl;

                // 将新连接注册到 epoll
                epoll_event client_ev{};
                client_ev.events = EPOLLIN; // 默认 LT 模式
                client_ev.data.fd = connfd;

                if (epoll_ctl(epfd, EPOLL_CTL_ADD,
                              connfd, &client_ev) < 0)
                {
                    perror("epoll_ctl ADD");
                    close(connfd);
                }
            }
            // 情况二:普通客户端 Socket 可读
            else if (events[i].events & EPOLLIN)
            {
                char buf[1024];

                int ret = recv(fd, buf, sizeof(buf), 0);

                if (ret > 0)
                {
                    cout << "Recv: "
                         << string(buf, ret) << endl;

                    // 回显数据
                    if (!SendAll(fd, buf, ret))
                    {
                        CloseClient(epfd, fd);
                    }
                }
                else if (ret == 0)
                {
                    // 客户端正常关闭连接
                    cout << "Client closed: " << fd << endl;
                    CloseClient(epfd, fd);
                }
                else if (errno != EINTR &&
                         errno != EAGAIN &&
                         errno != EWOULDBLOCK)
                {
                    perror("recv");
                    CloseClient(epfd, fd);
                }
            }
            // 情况三:连接异常
            else if (events[i].events & (EPOLLERR | EPOLLHUP))
            {
                CloseClient(epfd, fd);
            }
        }
    }

    close(epfd);
    close(listenfd);

    return 0;

第四章 基于 epoll 的 Reactor 网络计算器:从事件派发到协议处理

在前面的深水区中,我们已经从内核态的红黑树、就绪队列与硬件中断机制,彻底打通了 epoll 为什么能够降维打击 poll 的全量轮询。但底层机制再神,它也仅仅是一个"高效的通知机器"。在真实的工业级 C++ 开发中,我们绝不能让裸露的 epoll API 散落在业务代码里。

本章,我们将跨越从"底层机制"到"上层架构"的天堑。不再纠结于内核源码,而是直接围绕一套完整的 Reactor 事件驱动网络计算器 源码,带你拆解现代高性能服务器是如何利用 epoll 进行对象封装、事件派发以及 TCP 粘包处理的。

本章的核心目标只有两个:打通架构对象的咬合关系,跑通从网卡收包到协议解析的完整流转链路。

1 架构降维:Reactor 模型到底在干什么?

很多人初学高并发服务器时,会被各种"反应堆(Reactor)"、"多路复用"、"异步非阻塞"等名词砸晕。其实,整套服务器的核心运转机制,可以概括为一条高度解耦的流水线:

text 复制代码
Epoller (情报局)
   ↓ 负责底层调用 epoll_create/ctl/wait,死盯内核状态
Reactor (总调度室)
   ↓ 拿到就绪的情报,负责将读写事件精准派发给具体的连接
Connection (通用抽象层)
   ↓ 统一描述"监听套接字(大门)"和"通信套接字(包间)"
Listener / IOManager (具体打工人)
   ↓ Listener只负责 accept 迎客;IOManager只负责 recv/send 收发数据
Protocol (翻译官)
   ↓ 面对 TCP 无边界字节流,负责斩断粘包、反序列化、重新封包
Calculator (业务核心)
   ↓ 纯粹的 CPU 密集型模块,执行最终的加减乘除业务逻辑

一句话总结这套工业级架构的精髓:

Epoller 负责"等",Reactor 负责"派",Connection 负责"统",Listener 负责"建",IOManager 负责"搬",Protocol 负责"解",Calculator 负责"算"。

1.1 为什么 Reactor 必须维护一个 Connection 映射表?

当 epoll_wait 返回时,内核只告诉我们两件事:"哪个 fd 就绪了" 以及 "它发生了什么事件(读/写/异常)"。

但对于应用层来说,拿到一个干瘪的整数 fd 根本无法开展业务!我们需要知道:

  1. 这个 fd 到底是大门(监听套接字)还是普通包间(通信套接字)?
  2. 这个客户端上次没发完的数据(半包)存在哪里?
  3. 这个客户端因为网卡满了没写完的响应数据还剩多少?
  4. 它的 IP 和端口是什么?

因此,我们必须在应用层使用一个面向对象的 Connection 类对连接进行全方位立体描述,并在 Reactor 中维护一个核心的哈希表:

cpp 复制代码
std::unordered_map<int, std::shared_ptr<Connection>> _connections;

利用 fd 作为 Key,实现 O(1) 的极速对象寻址。事件一来,瞬间锁定对应的上下文。

1.2 为什么 Listener 和 IOManager 都要继承 Connection?

这是面向对象中多态 的极致应用。从 epoll 的视角看,无论你是监听套接字还是通信套接字,你们统统都是"会产生事件的文件描述符"。

  • 监听套接字产生 EPOLLIN :说明底层 TCP 全连接队列里有新客人握手成功了,应用层该调用 accept 了。
  • 通信套接字产生 EPOLLIN :说明底层接收缓冲区有数据包到达了,应用层该调用 recv 了。

如果不在基类做抽象,Reactor 的派发代码将充斥着恶心的 if-else。抽象成 Connection 后,规定三大纯虚原语:

cpp 复制代码
virtual int Sender() = 0;
virtual int Recver() = 0;
virtual int Excepter() = 0;

Reactor 只需要无脑调用 _connections[sockfd]->Recver() 即可。至于底层到底执行的是拉客(accept)还是收数据(recv),由子类在运行时的多态指针自行决断。

1.3 必死铁律:为什么 ET 模式必须强绑定非阻塞(Non-Block)?

本项目所有核心套接字都采用了极致压榨性能的配置:EPOLLIN | EPOLLET。

我们在上一章深度剖析过,边缘触发(ET)模式极其冷酷,状态跳变只通知一次。这倒逼我们必须写一个 while(true) 循环,把接收缓冲区里的数据一次性彻底抽干,直到榨不出哪怕一滴水。

但致命危机就在这里:如果你的 fd 是阻塞模式,当 while 循环读到最后一次、缓冲区空了的时候,recv 会被死死卡住!这会导致整个单线程的 Reactor 引擎瞬间瘫痪,所有并发连接全部卡死。

工业级铁律:EPOLLET(边缘触发) + O_NONBLOCK(非阻塞 fd) + while 循环读写,这三者是三位一体的,少一个就是服务器灾难。

2 Calculator.hpp:绝对纯净的业务计算引擎

Calculator 是业务流的最末端,它根本不知道什么是网络、什么是 epoll、什么是 JSON。它只接收结构化的 Request 对象,执行 CPU 计算,然后吐出结构化的 Response 对象。这正是架构解耦的魅力。

cpp 复制代码
#pragma once

#include "Protocol.hpp" // Request和Response的结构体定义在协议层
#include <iostream>
#include <string>

class Calculator
{
public:
    // 🌟 纯业务计算逻辑
    // 输入:已经经过 Protocol 层解析与反序列化洗礼的纯净 Request
    // 输出:携带计算结果与错误码的纯净 Response
    Response Execute(const Request &req)
    {
        // 默认构造:_result = 0, _code = 0 (0代表正常,非0代表各类业务错误)
        Response resp;

        // 经典的运算分流状态机
        switch (req._oper)
        {
        case '+':
            resp._result = req._data_x + req._data_y;
            break;
        case '-':
            resp._result = req._data_x - req._data_y;
            break;
        case '*':
            resp._result = req._data_x * req._data_y;
            break;
        case '/':
        {
            // 严密的防御性编程:防止除零引发的浮点数异常导致整个服务器进程崩溃 (SIGFPE)
            if (req._data_y == 0)
                resp._code = 1; // 业务错误码 1:除0错误
            else
                resp._result = req._data_x / req._data_y; // 整数除法
        }
        break;
        case '%':
        {
            if (req._data_y == 0)
                resp._code = 2; // 业务错误码 2:模0错误
            else
                resp._result = req._data_x % req._data_y;
        }
        break;
        default:
            resp._code = 3; // 业务错误码 3:接收到了非法的运算符
            break;
        }

        return resp;
    }
};

3 Comm.hpp:公共基础设施与非阻塞魔改

在使用 ET 模式前,我们必须通过内核提供的 fcntl 系统调用,强行修改文件描述符的属性,将其改造为非阻塞模式。

cpp 复制代码
#ifndef __COMMON_HPP
#define __COMMON_HPP

#include <iostream>
#include <fcntl.h>      // 提供 fcntl 以及 O_NONBLOCK 宏
#include "Logger.hpp"

using namespace NS_LOG_MODULE;

// 统一定义程序的系统级退出码,便于运维通过 echo $? 快速排障
enum EXIT_CODE
{
    SUCCESS,            // 0:正常退出
    EPOLLER_ERROR,      // 1:内核分配 eventpoll 失败
    EPOLLER_WAIT_FATAL  // 2:事件轮询核心发生系统级重创
};

// 🌟 核心原语:将指定的 fd 爆改为非阻塞(Non-Block)模式
void SetNonBlock(int sockfd)
{
    // 第一步 (F_GETFL):向内核打报告,获取当前 fd 已有的状态标志位 (Flags)
    int fl = fcntl(sockfd, F_GETFL);
    if(fl < 0) return;

    // 第二步 (F_SETFL):在原有状态标志的基础上,按位或 (|) 追加 O_NONBLOCK。
    // 避坑:千万不要直接 fcntl(sockfd, F_SETFL, O_NONBLOCK),这会把你之前可能设置的其他属性(如异步通知)全部洗掉!
    fcntl(sockfd, F_SETFL, fl | O_NONBLOCK);
}

#endif

底层行为变更 :设置非阻塞后,当 recv/send/accept 无法立即完成时,不再将线程投入睡眠队列,而是立刻返回 -1,并在全局变量 errno 中置位 EAGAIN 或 EWOULDBLOCK。这正是我们打断 while(true) 死循环的唯一出口。

4 Connection.hpp:万物皆可连接的统一抽象

Connection 类是 Reactor 管理连接生命周期的基石。它不仅封装了 fd,更重要的是它保存了 输入/输出缓冲区。在非阻塞网络编程中,缓冲区必须是长期存活的,因为网络数据往往是碎片化到达的。

cpp 复制代码
#ifndef __CONNECTION_HPP
#define __CONNECTION_HPP

#include <iostream>
#include <ctime>
#include <cstdint>
#include <string>
#include <sys/epoll.h>
#include "InetAddr.hpp"

// 前置声明,解决头文件循环依赖。Connection 需要持有 Reactor 指针以实现反向调用。
class Reactor;

class Connection
{
public:
    Connection()
        : _sockfd(-1), _events(EPOLLIN), _active_time(time(nullptr)) {}

    Connection(int sockfd, uint32_t events)
        : _sockfd(sockfd), _events(events), _active_time(time(nullptr)) {}

    // 心跳更新:每次读写活跃时调用,用于后续超时踢除"占着茅坑不拉屎"的僵尸连接
    void Active() { _active_time = time(nullptr); }
    time_t lastActiveTime() { return _active_time; }

    // 🌟 架构核心:三大纯虚回调接口。将底层事件抽象为业务动作,留给子类实现多态
    virtual int Sender() = 0;   // 写事件触发时调用
    virtual int Recver() = 0;   // 读事件触发时调用
    virtual int Excepter() = 0; // 异常/挂断时调用

    int Sockfd() { return _sockfd; }
    
    void Close()
    {
        if (_sockfd >= 0) { close(_sockfd); _sockfd = -1; }
    }

    uint32_t Events() { return _events; }
    void SetEvents(uint32_t events) { _events = events; }
    
    void InitAddr(const InetAddr &addr) { _clinetaddr = addr; }
    InetAddr Addr() { return _clinetaddr; }
    virtual ~Connection() {}

protected:
    int _sockfd;             
    uint32_t _events;        // 当前在内核中注册的关心事件掩码
    time_t _active_time;     

    // 🌟 极其重要的状态载体:
    // 输入缓冲区:TCP 是无边界的字节流,收到的半个 JSON 字符串必须存放在这里,等待下一波数据拼图。
    std::string _inbuffer;

    // 输出缓冲区:非阻塞 send 可能发生"短写"(网卡突然满了,只发了一半)。
    // 剩下的数据必须暂存在这里,等待内核触发 EPOLLOUT 事件时再继续发。
    std::string _outbuffer;

    InetAddr _clinetaddr;

public:
    // 回指指针:子类(如 IOManager)在数据发完时,必须通过它反向调用 Reactor 去关闭 EPOLLOUT。
    Reactor *R;
};

#endif

5 Epoller.hpp:内核事件系统的面向对象封装

将恶心、易错的 epoll_ctl 进行安全封装。注意 events 在底层其实是依靠掩码(如 EPOLLIN | EPOLLET)在位图中传递信息的。

cpp 复制代码
#ifndef __EPOLLER_HPP
#define __EPOLLER_HPP

#include <iostream>
#include <cstdlib>
#include <sys/epoll.h>

#include "Comm.hpp"
#include "Logger.hpp"

using namespace NS_LOG_MODULE;

class Epoller
{
private:
    // 将系统级的增、删、改整合为统一的引擎出口
    bool EpollCtl(int sockfd, int oper, uint32_t events)
    {
        if (oper == EPOLL_CTL_DEL)
        {
            // 从内核红黑树上拔除节点,此时内核不再关心 events 配置,传入 nullptr 最安全
            int n = epoll_ctl(_epfd, oper, sockfd, nullptr);
            (void)n;
            (void)events;
        }
        else
        {
            struct epoll_event ev;
            ev.events = events;
            // 🌟 核心纽带:把 sockfd 藏进 data.fd 里。等中断唤醒时,内核会把它原封不动还给用户态,让我们知道是谁来数据了。
            ev.data.fd = sockfd; 
            int m = epoll_ctl(_epfd, oper, sockfd, &ev);
            (void)m;
        }
        return true;
    }

public:
    Epoller()
    {
        // 陷入内核空间,分配 eventpoll 数据结构
        _epfd = epoll_create(256);
        if (_epfd < 0)
        {
            LOG(LogLevel::FATAL) << "epoll_create error";
            exit(EXIT_CODE::EPOLLER_ERROR);
        }
        LOG(LogLevel::INFO) << "epoll_create success, epfd: " << _epfd;
    }

    // 盲盒收割机:阻塞挂起当前线程,由内核网卡硬中断唤醒并返回就绪数组
    int WaitEvents(struct epoll_event revs[], int event_num, int timeout = 1000)
    {
        return epoll_wait(_epfd, revs, event_num, timeout);
    }

    bool AddEvents(int sockfd, uint32_t events) { return EpollCtl(sockfd, EPOLL_CTL_ADD, events); }
    bool ModEvents(int sockfd, uint32_t events) { return EpollCtl(sockfd, EPOLL_CTL_MOD, events); }
    bool DelEvents(int sockfd) { return EpollCtl(sockfd, EPOLL_CTL_DEL, 0); }

    ~Epoller()
    {
        // epfd 也是占用进程句柄上限的资源,不玩了必须显式销毁归还内核
        if (_epfd > 0) close(_epfd);
    }

private:
    int _epfd;
};

#endif

6 InetAddr & Socket:网络底层兵工厂

在网络编程中,原生的 sockaddr_in 和 socket 接口带有极强的 C 语言历史包袱,我们将它们彻底隔离在基础设施底层。

6.1 InetAddr.hpp(地址洗牌机制)

解决令人抓狂的系统大端机字节序与用户可视字符串 IP 之间的鸿沟。

cpp 复制代码
#pragma once
#include <iostream>
#include <string>
#include <strings.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define CONV(address) ((struct sockaddr *)address)

class InetAddr
{
public:
    InetAddr() {}

    // 反序列化:从 accept 弹出的底层网络二进制结构,转化为人类直观格式
    InetAddr(const struct sockaddr_in &address) : _address(address), _len(sizeof(address))
    {
        char ipstr[32];
        inet_ntop(AF_INET, &(_address.sin_addr), ipstr, sizeof(ipstr));
        _ip = ipstr;
        _port = ntohs(_address.sin_port); // Network to Host Short (网络转主机字节序)
    }

    // 序列化:应用层提供文本 IP 与端口,转化为内核网卡认的二进制大端格式
    InetAddr(uint16_t port, const std::string &ip = "0.0.0.0") : _ip(ip), _port(port)
    {
        bzero(&_address, sizeof(_address));
        _address.sin_family = AF_INET;
        _address.sin_port = htons(_port); // Host to Network Short
        inet_pton(AF_INET, ip.c_str(), &(_address.sin_addr));
        _len = sizeof(_address);
    }

    // ... 运算符重载略 ...
    std::string ToString() { return "[" + _ip + ":" + std::to_string(_port) + "]"; }
    struct sockaddr *NetAddress() { return CONV(&_address); }
    socklen_t Len() { return _len; }
    ~InetAddr() {}
private:
    struct sockaddr_in _address;
    socklen_t _len;
    std::string _ip;
    uint16_t _port;
};

6.2 Socket.hpp(模板方法多态网络)

利用设计模式中的 模板方法 (Template Method) ,固化 TCP 服务的建立流水线,保证架构绝不会漏掉 bind 或者 listen。注意,我们在 CreateSocketOrDie 中为监听套接字注入了非阻塞基因。

cpp 复制代码
#pragma once
// ... 头文件略 ...
namespace NS_SOCKET_MODULE
{
    static const int gbacklog = 16; // 决定内核层面全连接队列 (Accept Queue) 的长度

    // 抽象基类,规范统一原语
    class Socket
    {
    protected:
        virtual void CreateSocketOrDie() = 0;
        virtual void BindSocketOrDie(uint16_t port) = 0;
        virtual void ListenSocketOrDie() = 0;
    public:
        virtual int Accepter(InetAddr &addr, int *errcode) = 0;
        // ... Recv / Send / Close 接口定义略 ...

        // 🌟 模板方法:子类只实现步骤,基类掌控总流程
        void BuildTcpSocketMethod(uint16_t port)
        {
            CreateSocketOrDie();
            BindSocketOrDie(port);
            ListenSocketOrDie();
        }
    };

    // TCP 具体实现类
    class TcpSocket : public Socket
    {
    public:
        TcpSocket() : _sockfd(0) {}
        TcpSocket(int sockfd) : _sockfd(sockfd) {}

        void CreateSocketOrDie() override
        {
            _sockfd = socket(AF_INET, SOCK_STREAM, 0);
            if (_sockfd < 0) exit(SOCKET_ERR);

            int opt = 1;
            // 地址/端口复用,防止服务器异常挂掉后端口卡在 TIME_WAIT 导致无法重启
            setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));

            // 🌟 监听套接字必须非阻塞化!因为在 ET 模式下,我们会用 while(true) 疯狂调用 accept。
            SetNonBlock(_sockfd);
        }

        void BindSocketOrDie(uint16_t port) override
        {
            InetAddr addr(port);
            if (bind(_sockfd, addr.NetAddress(), addr.Len()) != 0) exit(BIND_ERR);
        }

        void ListenSocketOrDie() override
        {
            if (listen(_sockfd, gbacklog) != 0) exit(LISTEN_ERR);
        }

        // 增强版 Accepter:必须向上层透传 errcode 供 while 循环跳出校验
        int Accepter(InetAddr &clientaddr, int *errcode) override
        {
            struct sockaddr_in addr;
            socklen_t len = sizeof(addr);
            int sockfd = accept(_sockfd, CONV(&addr), &len);

            *errcode = errno; // 保存系统调用现场状态
            if(sockfd < 0) return -1;

            // 🌟 新生下来的小宝宝 (通信 fd) 也必须强制改造为非阻塞!
            SetNonBlock(sockfd);
            clientaddr = addr;
            return sockfd;
        }

        // ... Recv/Send/Close 包装基本系统调用,不再赘述 ...
    };
}

7 Reactor.hpp:掌控全局的事件派发大脑

Reactor 是整个架构的指挥中心。它的核心运转依赖两样东西:底层的 _epoller 对象用来等情报,以及一张 _connections 大表用来存对象。

它完美诠释了"把同步网络操作变为异步事件回调"的工程哲学。

cpp 复制代码
#ifndef __TCPSERVER_HPP
#define __TCPSERVER_HPP

#include <iostream>
#include <memory>
#include <unordered_map>
#include "Logger.hpp"
#include "Epoller.hpp"
#include "Connection.hpp"

using namespace NS_LOG_MODULE;

static const int grevs_num = 64; // 单次 epoll_wait 允许的最大就绪提取数

class Reactor
{
private:
    // 防御性机制:在执行写事件前,检查这个连接刚才在读事件里有没有因为异常被干掉
    bool IsLegalConnection(int sockfd)
    {
        return _connections.find(sockfd) != _connections.end();
    }

public:
    Reactor() : _epoller(std::make_unique<Epoller>()) {}

    // 🌟 核心派发器:对 epoll 送来的几十个就绪事件进行精准拆解分流
    void Dispatcher(int n)
    {
        for (int i = 0; i < n; i++)
        {
            int sockfd = revs[i].data.fd;
            uint32_t revents = revs[i].events;

            // 【异常归一化处理】如果底层协议栈直接丢上来了错误(ERR)或挂断(HUP),
            // 我们不在这里写繁琐的清理代码,而是暴力追加读写标记。
            // 这样后续必定会调进 Recver/Sender 内部,在那里触发 recv 返回 0 或 -1,从而统一走优雅的清理流。
            if (revents & EPOLLERR) revents |= (EPOLLIN | EPOLLOUT);
            if (revents & EPOLLHUP) revents |= (EPOLLIN | EPOLLOUT);

            // 派发读事件 (由于多态,大门 fd 就会去调 Listener::Recver 执行 accept,包间 fd 就会调 IOManager::Recver)
            if ((revents & EPOLLIN) && IsLegalConnection(sockfd))
                _connections[sockfd]->Recver();

            // 派发写事件
            if ((revents & EPOLLOUT) && IsLegalConnection(sockfd))
                _connections[sockfd]->Sender();
        }
    }

    // 发动机气缸的单次做功循环
    void LoopOnce(int timeout = 1000)
    {
        int n = _epoller->WaitEvents(revs, grevs_num, timeout);
        switch (n)
        {
        case 0:
            LOG(LogLevel::INFO) << "Time out...";
            break;
        case -1:
            LOG(LogLevel::FATAL) << "Epoll error";
            exit(EXIT_CODE::EPOLLER_WAIT_FATAL);
        default:
            Dispatcher(n); // 命中事件,装弹发射!
            break;
        }
    }

    // 服务器死亡引擎
    void Loop()
    {
        int timeout = 2000;
        while (true) { LoopOnce(timeout); }
    }

public:
    // 🌟 登记造册:当有新客来临时,必须通过此处录入系统
    void AddConnection(std::shared_ptr<Connection> conn)
    {
        // 1. 下沉到内核态:挂入 epoll 的红黑树,让硬件接手监听
        _epoller->AddEvents(conn->Sockfd(), conn->Events());
        // 2. 滞留应用态:保存在哈希表映射中,防止生命周期结束被析构
        _connections[conn->Sockfd()] = conn;
        // 3. 赐予尚方宝剑:让通信连接拥有随时修改自身内核 epoll 状态的能力
        conn->R = this;
    }

    // 🌟 控制中枢:绝对禁止长时间注册写事件!
    void EnableReadWrite(int sockfd, bool readable, bool writeable)
    {
        if (IsLegalConnection(sockfd))
        {
            // 根据需求,动态缝合掩码。始终保持 EPOLLET 底色。
            uint32_t events = (EPOLLET | (readable ? EPOLLIN : 0) | (writeable ? EPOLLOUT : 0));
            _connections[sockfd]->SetEvents(events);
            // 向内核同步改动
            _epoller->ModEvents(_connections[sockfd]->Sockfd(), _connections[sockfd]->Events());
        }
    }

    // 🌟 优雅回收:死守"先 DEL 后 close"的工业铁律
    void DelConnection(int sockfd)
    {
        if(IsLegalConnection(sockfd))
        {
            // 1. 【斩断网卡根系】必须在 fd 合法的情况下,清除红黑树和等待队列的回调探针
            _epoller->DelEvents(sockfd);
            // 2. 【物理释放】向内核发送 TCP 挥手包并释放文件描述符资源
            _connections[sockfd]->Close();
            // 3. 【应用层销毁】剥离智能指针,自动触发对象析构
            _connections.erase(sockfd);
        }
    }

private:
    std::unique_ptr<Epoller> _epoller;
    struct epoll_event revs[grevs_num];
    std::unordered_map<int, std::shared_ptr<Connection>> _connections;
};

#endif

避坑警告 :为什么 EPOLLOUT 要提供动态开启与关闭的接口 EnableReadWrite?

因为底层 TCP 发送缓冲区 99% 的时间都是空闲且可写的。如果你像注册读事件一样,一开始就把 EPOLLOUT 永久挂在树上,epoll_wait 就会像发疯一样疯狂返回写就绪,导致事件循环空转,瞬间干爆 CPU。

正确姿势是:按需开闭。平时只盯读事件,只有当上层代码发现 send 遇到网卡阻塞发不出去时,才把剩下的数据丢进暂存区,并向内核打开 EPOLLOUT 监听。当内核下次通知你写完了,赶紧再次把它关掉。

8 Listener 与 IOManager:连接的具体打工人

现在,我们揭开这两位多态兄弟的面纱,看看 ET 模式的非阻塞压榨是如何落地的。

8.1 Listener.hpp(迎宾小哥)

它的责任及其专一:它根本不收业务数据,它的 Recver 唯一任务就是把全连接队列里握手成功的客户,全部领进门,发给他们包间号(新 sockfd),并注册进系统。

cpp 复制代码
#ifndef __LISTENER_HPP
#define __LISTENER_HPP

// ... 头文件略 ...
class Listener : public Connection
{
public:
    Listener(on_message_t on_message_helper, uint16_t port = 8080)
        : _on_message_helper(on_message_helper), _port(port), _listensock(std::make_unique<TcpSocket>())
    {
        _listensock->BuildTcpSocketMethod(_port);
        _sockfd = _listensock->Sockfd();
        // 大门永远只关心是否有新客 (EPOLLIN),搭配 ET 模式。
        _events = EPOLLIN | EPOLLET;
        Active();
    }

    // 多态实现:监听套接字的读,就是提取新连接!
    int Recver() override
    {
        // 🌟 必须写 while(true)!
        // 如果全连接队列里同时涌入 5 个新连接,由于是 ET 模式,内核只会通知你 1 次!
        // 你如果不把它循环拔干净,剩下的 4 个连接将永远留在底层吃灰,引发惨烈的连接饥饿。
        while (true)
        {
            InetAddr clientaddr;
            int errcode = 0;
            int sockfd = _listensock->Accepter(clientaddr, &errcode);

            if (sockfd < 0)
            {
                // EAGAIN 标志着:内核全连接队列当前已经被彻底抽干了。这是完美的退出口。
                if (errcode == EWOULDBLOCK || errcode == EAGAIN) break;
                // 被进程间信号意外打断,直接重试
                else if(errcode == EINTR) continue;
                else break;
            }

            // 捞出一个合法连接,为其封装成 IOManager 对象
            std::shared_ptr<Connection> conn =
                std::make_unique<IOManager>(sockfd, EPOLLIN | EPOLLET, _on_message_helper);
            conn->InitAddr(clientaddr);
            
            // 交给总调度室,正式纳入底层监听体系
            R->AddConnection(conn);
        }
        return 0;
    }

    // 监听大门永远不会发业务数据,也不处理常规异常
    int Excepter() override { return 0; }
    int Sender() override { return 0; }

private:
    uint16_t _port;
    std::unique_ptr<Socket> _listensock;
    on_message_t _on_message_helper; // 透传的业务函数,待会丢给小弟 IOManager 去干活
};
#endif

8.2 IOManager.hpp(包间服务员)

这里展现了非阻塞 I/O 最核心的读写骨架。所有的数据必须依靠 _inbuffer 和 _outbuffer 这两个缓冲池来进行中转,绝不允许阻塞等待。

cpp 复制代码
#ifndef __IOMANAGER_HPP
#define __IOMANAGER_HPP

// ... 头文件略 ...
// 上层协议层的回调。给一段乱七八糟的乱码,它会剔除杂质,解析计算,并返回封装好的答案字符串。
using on_message_t = std::function<std::string(std::string &)>;

static const int buffersize = 1024;

class IOManager : public Connection
{
public:
    IOManager(int sockfd, uint32_t events, on_message_t on_message)
        : Connection(sockfd, events), _on_message(on_message) { Active(); }

    // 🌟 暴力抽水机:应对 ET 模式的数据积压
    int Recver() override
    {
        Active();
        char buffer[buffersize];

        while (true)
        {
            ssize_t n = recv(_sockfd, buffer, buffersize - 1, 0);
            if (n > 0)
            {
                buffer[n] = 0;
                // 【极度关键】:一次 recv 读上来的很可能是一个完整的报文,也可能是 0.3 个报文。
                // TCP 不管协议格式,它只是一根水管。所以读上来的水,必须毫无保留地倒进 _inbuffer 池子里攒着!
                _inbuffer += buffer;
            }
            else if (n == 0)
            {
                // 对端正常断开,转入异常处理执行强力清退
                Excepter();
                return -1;
            }
            else
            {
                // EAGAIN:水管里的水终于被抽干了,此时池子 (_inbuffer) 里的水可能已经凑够好几个完整报文了。跳出抽水循环!
                if (errno == EWOULDBLOCK || errno == EAGAIN) break;
                if (errno == EINTR) continue;
                Excepter(); // 遭遇物理链路异常
                return -2;
            }
        }

        // 业务层介入:调用 Protocol 模块开始切分 _inbuffer 这个大水池,提纯出完整响应。
        // 未被提取的"半个包裹"会原封不动地留在 _inbuffer 里,等待下次凑齐。
        if (_on_message) _outbuffer += _on_message(_inbuffer);
        
        // 如果成功算出了结果,产生要发送的响应数据了,我们立马去向内核打报告:开启 EPOLLOUT 关注,老子要发数据!
        if(!_outbuffer.empty()) R->EnableReadWrite(_sockfd, true, true);

        return _inbuffer.size();
    }

    // 🌟 短写终结者
    int Sender() override
    {
        Active();
        while (true)
        {
            ssize_t n = send(_sockfd, _outbuffer.c_str(), _outbuffer.size(), 0);
            if (n > 0)
            {
                // 非阻塞发送能发多少取决于网卡拥挤程度。发出去多少,就从头上删多少。
                _outbuffer.erase(0, n);
                if (_outbuffer.empty()) break; // 发送完毕,极其顺利!
            }
            else
            {
                // EAGAIN 表明网卡写缓冲满了。这是正常现象。
                if (errno == EWOULDBLOCK || errno == EAGAIN) break;
                else if (errno == EINTR) continue;
                Excepter();
                return -1;
            }
        }

        // 🌟 控制中枢回溯闭环
        if (!_outbuffer.empty())
        {
            // 数据没发完(网卡卡住了)。保持住 EPOLLOUT,让 epoll 下次就绪时继续喊我们来发。
            R->EnableReadWrite(_sockfd, true, true);
        }
        else
        {
            // 数据彻底空了!大功告成,火速把 EPOLLOUT 关掉,防止下一秒引发 CPU 100% 死锁空转!
            R->EnableReadWrite(_sockfd, true, false);
        }
        return 0;
    }

    int Excepter() override
    {
        // 交给总监直接进行毁尸灭迹,底层会保证完美遵循"先 DEL 后 close"的安全退流
        R->DelConnection(_sockfd);
        return 0;
    }
private:
    on_message_t _on_message;
};
#endif

9 Protocol.hpp:降伏"面向字节流"的粘包凶兽

当网络报文来到 Protocol 这一层时,我们必须直面网络编程中最臭名昭著的问题:TCP 粘包与半包 。

TCP 协议保证数据不丢,但绝不保证每次你 recv 上来的刚好是一个完整的 JSON 字符串。你可能读到 1 个,也可能读到 3.5 个。

如何破局?报文定界 。我们在报文外围包裹一层简单的壳:正文长度\r\nJSON正文\r\n。

利用这一特征,Protocol 的核心算法通过切割 _inbuffer,精准地提取出合法的原子请求。

cpp 复制代码
#pragma once
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>
#include <functional>
#include "Logger.hpp"

// ... Request 和 Response 的 JSON 序列化类略 ...

const std::string gsep = "\r\n"; // 分隔符标志

using HandlerRequest_t = std::function<Response(Request &)>;

class Protocol
{
public:
    Protocol(HandlerRequest_t handler) : _handler_request(handler) {}

    // 序列化后补壳算法:将干净的 JSON 补全为 "长度\r\n报文\r\n"
    std::string Packet(const std::string &json_string)
    {
        return std::to_string(json_string.size()) + gsep + json_string + gsep;
    }

    // 🌟 最硬核的解壳斩包算法
    // 如果成功分离出一个报文,返回 1;如果是残缺半包,返回 0 拒绝处理。
    int Unpack(std::string &packet, std::string *json_string)
    {
        if (packet.empty()) return 0;

        // 1. 寻找第一个报头的分隔符。找不到说明连报头都还没收全,属于半包。
        auto pos = packet.find(gsep);
        if (pos == std::string::npos) return 0;

        // 2. 剥离报头,解析声明的包体总长
        std::string lenstr = packet.substr(0, pos);
        int len = std::stoi(lenstr);

        // 3. 严格计算总长度:声明长度 + "长度字符串的物理长度" + 两个 \r\n 的长度
        int total = lenstr.size() + len + 2 * gsep.size();

        // 4. 防线校验:声明的总长度大于目前底池子里攒的水的长度?依然是半包!直接 return 0,等下次 recv 补全!
        if (packet.size() < total) return 0;

        // 5. 破茧成蝶:既然长度达标,精准抠出干净的 JSON 包体给上层业务
        *json_string = packet.substr(pos + gsep.size(), len);

        // 6. 销毁遗骸:从底池中直接剔除已经被消费掉的 total 长度的字符!
        // 剩下的残余字符(可能是下一个请求的头部)会自动往前推移,等待下一轮处理。
        packet.erase(0, total);
        return 1;
    }

    // 流水线加工总厂
    std::string ParseRequest(std::string &inbuffer)
    {
        std::string result;
        while (true)
        {
            std::string json_string;
            // 疯狂尝试拆包,如果里面粘了 3 个包,就会完美循环 3 次。
            int n = Unpack(inbuffer, &json_string);
            if (n < 0) return std::string();
            if (n == 0) return result; // 半包警告!立马停止流水线,把前面已经做好的成品 (result) 发还给客户。

            Request req;
            if (!req.Deserialize(json_string)) return std::string();

            // 丢给最底层的 Calculator 算账
            Response resp;
            if (_handler_request) resp = _handler_request(req);

            std::string resp_json_string;
            resp.Serialize(&resp_json_string);

            // 把做好的响应再加壳装好,追加到流水线上
            result += Packet(resp_json_string);
        }
    }
};

10 骨架闭环:Main.cc 的惊艳组装

现在,我们将各个彻底解耦的模块,通过 Lambda 表达式和回调闭包,在最顶层像搭乐高一样组装起来。这使得底层网络引擎根本不知道自己在算数学题,算数引擎也不知道自己跑在网络上。

cpp 复制代码
#include "Calculator.hpp"
#include "Protocol.hpp"
#include "Reactor.hpp"
#include "Listener.hpp"
#include <memory>

int main(int argc, char *argv[])
{
    if (argc != 2) return 1;
    ENABLE_CONSOLE_LOG_STRATEGY();
    uint16_t port = std::stoi(argv[1]);

    // 1. 分配计算节点:唯一的 CPU 密集型苦力
    std::unique_ptr<Calculator> cal = std::make_unique<Calculator>();

    // 2. 分配协议车间:通过闭包将 Calculator 的计费口子 (Execute) 注入
    std::unique_ptr<Protocol> protocol = std::make_unique<Protocol>(
        [&cal](Request &req) -> Response { return cal->Execute(req); });

    // 3. 分配迎宾大门:将协议车间的入口 (ParseRequest) 注入监听大门。
    // 等新客人一进来,大门就会把这条闭包法则塞给接待他的 IOManager 小弟。
    std::shared_ptr<Connection> listener = std::make_shared<Listener>(
        [&protocol](std::string &inbuffer) -> std::string { return protocol->ParseRequest(inbuffer); },
        port);

    // 4. 搭建总调度室
    std::unique_ptr<Reactor> R = std::make_unique<Reactor>();

    // 5. 把大门安装到调度室,系统底层开始呼叫 epoll_ctl 进行挂载
    R->AddConnection(listener);

    // 6. 点火起飞!主线程放弃执行权,彻底死磕在 epoll_wait 里面
    R->Loop();

    return 0;
}

配合使用支持 C++17 标准的 Makefile 进行极简编译:

makefile 复制代码
reactor:Main.cc
	g++ -o $@ $^ -std=c++17 -ljsoncpp
clean:
	rm -f reactor
.PHONY:clean

11 最终沙盘推演:单线程大心脏的完整跳动

至此,我们的现代工业级 Reactor 闭环彻底修筑完毕。回顾整个从接收到响应的生命周期沙盘推演:

  1. 【客人敲门】网卡收包 -> listenfd 爆出 EPOLLIN -> 唤醒 epoll_wait -> 派发 Listener::Recver -> 疯狂 accept 把新客人全部接走,包装成新 IOManager 并丢进内核红黑树。
  2. 【客人下单】客户端发送请求 -> clientfd 爆出 EPOLLIN -> 派发 IOManager::Recver -> 疯狂 recv 到 EAGAIN -> 碎片数据全部倒进 _inbuffer -> Protocol::Unpack 将乱码切分成规整原子 JSON -> 反序列化 -> Calculator 秒出结果 -> 加壳并返回到 _outbuffer -> 立马向内核开启 EPOLLOUT 特权!
  3. 【菜品上桌】由于我们申请了写关注 -> epoll_wait 下次瞬间苏醒,爆出 EPOLLOUT -> 派发 IOManager::Sender -> 从 _outbuffer 向内核网卡疯狂 send -> 发现发完了 -> 立马向内核申请关闭 EPOLLOUT 关注,防止死锁空转。
  4. 【客人买单走人】收到 0 字节包 -> 走入 Excepter 分支 -> DelConnection 先强硬抹去底层红黑树哨兵 -> 断 TCP 四次挥手释放描述符 -> 清除哈希表。

这,就是一台无论遭遇几万次并发请求,都不会被任何无意义的 wait 卡住,将 CPU 压榨到极致的高性能网络计算器引擎!

第五章 Reactor 反应堆模式:从单事件循环到 One Thread One Loop

在前面的章节中,我们已经深入操作系统内核,解构了 epoll 的红黑树与就绪队列,并手写了一套基于 epoll 的单线程网络计算器源码。但掌握了 epoll_wait、recv 和 send,仅仅是拿到了网络编程的底层零件。

epoll 只是一个高效率的事件检测雷达,而如何根据雷达的情报来调兵遣将,则是一门架构艺术。本章,我们将视线从内核态拔高到应用层架构态,彻底打通现代高性能服务器的终极心脏------Reactor(反应堆)模式。

我们将从单事件循环的微观推演,一路剖析到 Nginx、Redis、Netty 等高性能系统都在不同程度采用的 One Thread One Loop(OTOL) 设计思想。解答那些在源码中让你困惑的终极问题:为什么必须用面向对象封装 Connection?为什么多线程下不能直接用条件变量唤醒?eventfd 和 SO_REUSEPORT 究竟在架构中承担着怎样不可替代的使命?

1 Reactor 解决的问题

在古老的阻塞式网络编程中,服务器的并发模型极其简单粗暴:一连接一线程(Thread-Per-Connection)。

text 复制代码
客户端 1 ──> 线程 1 ──> 阻塞在 recv 等待数据
客户端 2 ──> 线程 2 ──> 阻塞在 recv 等待数据
客户端 3 ──> 线程 3 ──> 阻塞在 recv 等待数据

这种模型在并发量极低时勉强可用,可一旦面对万级并发(C10K),就会引发资源灾难:

  1. 内存被抽干:每个线程默认占用数兆的栈空间,成千上万个线程直接吃掉大量内存。
  2. CPU 被颠覆:操作系统的调度器在海量线程间频繁进行上下文切换(Context Switch),极度浪费 CPU 周期。
  3. 算力被闲置:绝大部分长连接在 99% 的时间里都在等待网络包,但服务器却为它们各自保留了一个死等阻塞的线程。

面对这种随着连接数线性暴增的资源枯竭,Reactor 模式 给出了架构层面的解法:

将"连接驱动"转变为"事件驱动"。不再让一个线程阻塞等待一个连接,而是让一个线程通过多路转接同时监控海量连接。哪个连接发生事件,就去派发处理哪个连接。

2 epoll 与 Reactor 的关系

无数人将 epoll 和 Reactor 混为一谈,但这二者的职责边界非常清晰。

epoll 是底层的事件检测雷达。它只能回答极其底层的物理事实:

  • "fd=5 发生 EPOLLIN(可读)了!"
  • "fd=8 发生 EPOLLOUT(可写)了!"

但 epoll 是个纯粹的底层组件,它没有业务智商。它不知道 fd=5 应该调用 accept 还是 recv,更不知道收上来的字节流该如何解析。

Reactor 是高层的总调度室 。它依托于 epoll 的情报,负责在应用层回答三个终极业务问题:

  • 这个 fd 属于谁?
  • 这个事件应该派发给谁处理?
  • 处理完成后状态如何流转?

简而言之:epoll 是底层提供动力的发动机,而 Reactor 是围绕发动机构建出来的完整车辆架构。 (对比 Windows 平台的 IOCP 完成端口,那是另一种异步 I/O 哲学:内核完成数据操作后直接向用户层交付结果,用户侧不再像 Reactor 那样仅凭就绪通知再主动去调用 recv/send。)

3 Reactor 四个核心对象

结合上一章的源码,一套严密的 Reactor 架构由四大核心角色咬合而成:

  1. 多路分离器(Epoller) :它是对 epoll_create、epoll_ctl、epoll_wait 的封装,全权负责与内核打交道,屏蔽底层 API 细节。
  2. 事件循环(Reactor):它是服务器的心脏。内部运行着一个死循环,不断调用 Epoller 获取就绪事件,然后执行分发(Dispatcher)。
  3. 事件对象(Connection) :它将整数 fd 包装成具备状态的上下文对象,保存着连接的读写缓冲区、对端 IP 和生命周期状态。
  4. 事件处理器(Handlers) :具体干活的执行逻辑。针对不同事件,执行 Accepter(建立连接)、Recver(接收数据)、Sender(发送数据)或 Excepter(异常处理)。

4 Connection 与回调

在真正的架构中,Reactor 不能只维护一个干瘪的 fd 数组,而是必须维护一张全局哈希表:

cpp 复制代码
std::unordered_map<int, std::shared_ptr<Connection>> _connections;

为什么必须把 fd 包装成 Connection?

因为在非阻塞 I/O 中,上下文就是一切。当 epoll 通知你 fd=5 可读时,你必须知道:

  • 它之前读了一半的 JSON 半包存在哪里?
  • 上次网卡写满没发完的数据还剩多少?

因此,Connection 对象本质上是物理连接在应用层的载体。更重要的是,它通过回调函数 实现了逻辑的解耦。

我们为 Connection 留出 _recver、_sender、_excepter 三个插槽(或虚函数):

  • 监听大门建立时,将 _recver 绑定为 Accepter。
  • 普通包间建立时,将 _recver 绑定为 IOManager::Recver。

当事件到来时,Reactor 无脑执行 conn->_recver(conn)。这就是控制反转(IoC):Reactor 作为框架不理解业务,Connection 提前注册好处理方法,事件发生时由 Reactor 统一扣动扳机。

5 单 Reactor 完整运行流程

我们将单 Reactor 的流转链路拆解为五个核心阶段:

5.1 accept 流程

当客户端完成三次握手,监听 fd 触发 EPOLLIN,Reactor 派发至 Accepter 回调。

在 ET(边缘触发)模式下,一次通知可能对应全连接队列中的多个新连接。因此,必须循环调用 accept,直到返回 EAGAIN 。若只 accept 一次,剩余连接可能无法及时获得通知,从而造成连接处理延迟甚至长期饥饿。

5.2 多执行单元 accept 的原子性

这是一个常被忽略的底层细节:如果多个线程或多进程同时阻塞等待同一个监听套接字,当新连接到来时,会发生什么?

内核对全连接队列的出队操作是原子的 。这意味着,一个已经完成握手的连接,只会被一个执行单元成功 accept 取走,绝不会出现一个连接被分发给两个线程的情况。

但是,accept 的原子性并不等同于单一唤醒 。当监听 fd 可读时,可能多个执行单元同时被唤醒。线程 A 手快取走了最后一个连接,随后线程 B 调用 accept 时,就会遇到队列为空,直接返回 EAGAIN。因此,并发 accept 依然需要配合非阻塞与循环读取的范式。

5.3 recv 与协议处理

普通通信连接触发 EPOLLIN 时,Recver 使用非阻塞 recv 循环读取,直到 EAGAIN,并将所有字节流追加到 _inbuffer 中。

绝不能读一次就直接交给业务 。TCP 是无边界的流式协议,必须将数据暂存池中,由协议层通过报文定界符(如 \r\n)或长度字段尝试拆包。拆出完整报文才送去业务计算,半包则原封不动留在 _inbuffer 等待下次拼图。

5.4 send 与 EPOLLOUT

业务处理完毕后,响应数据放入 _outbuffer,此时尝试非阻塞 send。

由于网卡缓冲区大小限制,极易发生"短写"。如果没发完,剩余数据继续保留,并向内核申请开启 EPOLLOUT 事件关心 。

注意:EPOLLOUT 必须按需开启 。普通 TCP 套接字在绝大部分时间都是可写的。如果永久注册 EPOLLOUT,epoll_wait 会陷入死循环疯狂返回可写事件,导致 CPU 空转。只有数据没发完时才打开,发完必须立即关闭。

5.5 连接删除

当收到 0 字节(对端正常挥手)或读写错误时,必须执行强力清退。

工业级铁律的清理顺序:

  1. 先从内核注销 :epoll_ctl(DEL),拔除底层的事件监听探针。
  2. 再释放文件描述符 :close(sockfd)。
  3. 最后应用层销毁 :从 _connections 中 erase 掉 Connection 对象。

6 为什么不能直接把 fd 交给普通线程池?

面对海量并发,单线程 Reactor 遇到耗时业务(如查数据库)就会阻塞整个事件循环。很多人第一直觉是:epoll_wait 拿到就绪的 fd 后,直接把它扔进一个多线程的 Worker 线程池里并发处理不就行了?

这种分发方式存在严重的并发与顺序风险,不能直接用于有状态的连接处理。

普通线程池无法保证同一个 fd 的事件严格串行。假设 fd 第一次就绪,任务交给线程 A 执行 recv;还没读完,fd 再次就绪,任务又交给了线程 B。此时线程 A 和 B 会在没有锁保护的情况下,并发篡改同一个 Connection 的 _inbuffer,导致协议彻底崩溃,响应顺序也必然错乱。

正确的职责边界是 :不能交给普通线程池的是 fd 的 I/O 操作和 Connection 状态管理。但是,当 Reactor 完成 recv 并彻底拆包后,已经脱离具体 fd 的纯业务计算请求,完全可以交给业务线程池处理 。业务完成后,应通过响应队列与事件通知机制(如 eventfd)将结果交回原 Reactor,由原 Reactor 独占完成 _outbuffer 更新和发送。

这就自然引出了现代并发架构的核心设计:One Thread One Loop。

7 OTOL:一个 fd 的唯一归属

One Thread One Loop(OTOL) 的核心公式非常明确:

One fd ──> One Connection ──> One Reactor ──> One Thread / One Process

这并不是说一个线程只能处理一个 fd,而是一个 Reactor 可以管理海量 fd,但同一个 fd 在同一时刻只能由一个固定的 Reactor 执行单元负责 。

一个连接一旦建立并分配给某个 Reactor 线程,它终生的 recv、send、close 都只在这个线程内串行执行。这从根本上免除了多个线程抢夺同一个 _inbuffer 的死锁与竞争问题。

8 Master-Slave Reactor

为了落地 OTOL,工业界演化出了经典的 Master-Slave 多 Reactor 架构:

  • Master Reactor :专职负责监听大门。通过 epoll_wait 发现新连接,执行 accept 获取 clientfd,然后按照轮询或最小负载策略,将 clientfd 分配给某个 Slave。
  • Slave Reactor:通常有多个(与 CPU 核心数相当)。每个 Slave 拥有自己独立的 Reactor、epoll 实例和 Connection 容器。它接收 Master 派发的 clientfd,将其加入自己的监听体系,负责后续所有的 I/O 操作。

9 为什么用户队列和条件变量不能直接解决问题?

Master 将 clientfd 选定给某个 Slave 后,如何通知它?

如果在 Slave 内部定义一个用户任务队列,Master 加锁把 clientfd 放进去,然后用条件变量(Condition Variable)唤醒 Slave。这看似合理,实则行不通。

核心痛点在于"两个等待"冲突 :

Slave 线程不能同时阻塞在两个独立的地方。如果它阻塞在条件变量等待新任务,就无法感知 epoll_wait 里的网络 I/O;如果它正阻塞在 epoll_wait 里,Master 扔进队列的新任务就无法即时唤醒它,只能干等到下一次网络事件触发或超时。

解决之道不是取消用户队列,而是将"队列中有新任务"这一物理事实,也转化为操作系统认可的文件描述符 I/O 事件。

10 eventfd 统一等待模型

在现代 Linux 中,最佳的跨线程唤醒机制是 eventfd。

cpp 复制代码
int efd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);

eventfd 内部主要维护一个 64 位计数器,不需要像管道(Pipe)那样维护用于传递字节流的庞大缓冲区,因此通知开销更低。

完整的对象归属与事件打通流程如下 :

每个 Slave 线程内部,除了 Reactor,还独占一个 eventfd 和一个 TaskQueue。Slave 提前将自己的 eventfd 注册到自己的 epoll 中。

  1. Master 分发 :Master 将新 clientfd 压入目标 Slave 的任务队列,随后对该 Slave 的 eventfd 执行 write(efd, 1)。
  2. Slave 唤醒 :eventfd 内部计数器增加,立刻触发 EPOLLIN 可读事件,原本沉睡在 epoll_wait 中的 Slave 瞬间被唤醒。
  3. Slave 处理 :Slave 发现是 eventfd 亮了,执行 read 将计数器清零,然后回头将自己任务队列中的 clientfd 统统取空,调用 AddConnection 加入自己的 Reactor 体系。

如此一来,普通 Socket 读写、定时器超时、新任务到达,全部被收束在同一个 epoll_wait 的统一等待模型中。

11 SO_REUSEPORT 多进程模型

除了 Master-Slave 线程模型,Linux 3.9 之后提供的 SO_REUSEPORT(端口复用)为多进程并发提供了另一种解法。

它允许多个独立的进程各自创建一个 listenfd,并绑定在完全相同的 IP 和端口上。

注意,setsockopt 设置 SO_REUSEPORT 必须在调用 bind 之前完成。

当客户端发起新连接时,内核依据连接的四元组哈希及相应的分配机制,将新连接分配给其中一个进程的监听套接字。对应进程的 epoll_wait 被独立唤醒,自己执行 accept 并接管后续 I/O。

这种方式的直接收益是:可以显著减少多个执行单元竞争同一个监听套接字带来的惊群效应和锁竞争问题;并且天然符合 One Process One Loop 哲学,不需要 Master 转发和 eventfd 唤醒。

但需要明确:SO_REUSEPORT 负责的仅仅是新连接的负载分配 ,连接被某个进程成功 accept 后,后续所有的 I/O 读写依然只归属该进程处理,不可越界。

12 enable_shared_from_this 与生命周期

在多 Reactor 和异步任务架构中,Connection 对象常常需要向外部(如业务线程池)投递任务。当任务执行完毕回调时,如果连接已经被关闭析构,裸指针访问就会导致灾难性的 Core Dump。

为此,必须使用智能指针彻底接管生命周期。Reactor 通过 shared_ptr 拥有 Connection,而 Connection 为了反向调用 Reactor(如执行 Excepter 自毁),应该只持有 weak_ptr<Reactor> 以避免循环引用导致的内存泄漏。

在使用 shared_ptr 的复杂网络库中,经常需要让对象安全地获取指向自身的 shared_ptr,这就需要继承 std::enable_shared_from_this<T>。

要安全使用它,必须严格遵守三条底线规则:

  1. 该类的实例必须由 std::shared_ptr 创建 (如使用 std::make_shared)。
  2. **在对象尚未被 shared_ptr 管理前,绝对不能调用 shared_from_this()**(严禁在类的构造函数中调用)。
  3. 绝不能使用 std::shared_ptr<T>(this) 来代替,这会为同一个底层裸指针创建出两个完全独立的控制块,导致对象被双重释放(Double Free)。

13 总结

从最底层的视角来看,epoll 仅仅负责高效地发现事件。

而 Reactor 模式 ,则是把所有能够产生事件的对象统一包装成承载状态的 Connection,由一个事件循环通过 epoll 统一监听,再根据事件类型多态派发给提前注册好的回调函数。

单 Reactor 证明了"一个线程也能高效管理万级连接"的物理可行性;而 One Thread One Loop 配合 eventfd 或 SO_REUSEPORT,则完美解决了"多核心多执行单元如何互不干扰地瓜分海量连接"的架构难题。Nginx、Redis、Netty 等高性能网络系统,皆在此底层哲学之上,各自绽放出了璀璨的工业级花朵。

相关推荐
最强小杰1 小时前
某 OpenAI 兼容网关上的 `kimi-k3.1-pro`:Cline、Zed 接入与 SSE 排错示例
java·服务器·网络·ai
郝学胜-神的一滴2 小时前
Effective STL 条款03:容器中的对象复制要廉价且正确
开发语言·数据结构·c++·算法·rpc·stl
西西弗Sisyphus3 小时前
C++ explicit 关键字工程实践
开发语言·c++
AIgorithmGEEK5 小时前
std::unordered_map 与 std::unordered_set:接口、算法技巧与权衡 (速查)
c++·算法·哈希表·负载因子·桶·unordered_map·unordered_set
上海潭龙东海科技有限公司7 小时前
智慧堆场动态模型三维实时孪生重构智能管控
大数据·网络·数据库·算法·重构
一拳一个呆瓜7 小时前
【STL】头文件:<cmath>
c++·stl
草莓熊Lotso8 小时前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构
慧都产品智能化8 小时前
Qt 开发 CAD/CAM 工序表的隐性成本分析
c++·qt·qt5·qt6.3
eggwyw10 小时前
linux下的C\C++多进程多线程编程实例详解
开发语言·c++