云计算百科
云计算领域专业知识百科平台

Linux epoll 一篇讲透:从 select/poll 到红黑树、LT/ET,再到完整 TCP 服务器

/* MD / 富文本中的 .toc(含博客园搬家等嵌套结构);.toc-box 在侧栏,不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p(:empty 仍占 20px),一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后,紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}

一万个客户端已经连上服务器,眼下只有十个客户端发来了数据。服务器怎样把时间花在这十个连接上?

理解这个问题,就抓住了 epoll 的主线。接下来,我们沿着“为什么需要它 → 接口怎么用 → 内核如何实现 → LT/ET 怎么写 → 完整服务器怎么运行”的顺序,把知识连起来。

**阅读基础:**了解 socket、bind、listen、accept 的基本用途即可。本文示例面向 Linux,服务器使用 C++17,实验脚本使用 Python 3。

@TOC

一、先把问题说清楚:epoll 到底在“等”什么?

1.1 一个连接没有数据,为什么会影响其他连接?

假设服务器已经与三个客户端建立连接,对应三个文件描述符:

fd = 5:暂时没有数据
fd = 6:已经发来请求
fd = 7:已经发来请求

如果服务器这样处理阻塞套接字:

recv(5, buf, sizeof(buf), 0);
recv(6, buf, sizeof(buf), 0);
recv(7, buf, sizeof(buf), 0);

程序可能停在第一行。即使 6、7 号连接已经有数据,当前线程也没有机会处理它们。

给每个连接分配一个线程,可以绕开这个问题。但随着连接数增长,线程栈、调度、上下文切换也会带来成本。

另一个方向是:把所有套接字改为非阻塞,不停地挨个 recv。这样不会卡在一个连接上,却会在大量没有数据的连接上反复得到 EAGAIN,消耗 CPU。

我们需要一种更合适的等待方式:

把多个 fd 交给内核统一关注;没有事情可做时休眠;有事情可做时,只处理返回的那些 fd。

这就是 I/O 多路复用,也叫 I/O 多路转接。select、poll、epoll 都在解决这个问题。

“多路”指多个 I/O 对象,“复用”指一个线程可以交替服务这些对象。它并不意味着一个线程在同一瞬间执行多次 recv。

1.2 “就绪”是可以尝试操作,业务请求还需要自己判断

对普通 TCP 连接来说,常见的就绪情况包括:

场景通常接下来做什么
监听套接字读就绪 调用 accept 取出已经建立、等待应用接收的连接
已连接套接字读就绪 调用 recv 读取数据,也可能读到 EOF 或错误
已连接套接字写就绪 尝试 send,具体能写多少以返回值为准

因此,收到读事件后,仍然需要检查 recv 的返回值;收到写事件后,仍然需要处理部分发送和错误。

尤其要记住:

读就绪不代表一条完整请求已经到齐;写就绪不代表任意长度的数据都能一次发完。

非阻塞 I/O 可以应对“收到事件后,实际操作时条件已经变化”的情况。例如,另一个线程先读走了数据,当前线程再读就可能得到 EAGAIN。就绪条件的基础定义可参见 select(2)。

1.3 epoll 返回以后,数据仍然要由应用读取

可以把一次普通 TCP 接收分成两个阶段:

  • 等待内核中出现可处理的 I/O 条件。
  • 调用 recv,把数据交给用户空间的程序。
  • epoll 主要组织第一个阶段的等待和通知。普通 recv 的数据接收仍由应用发起,协议解析和业务处理也需要应用完成。

    所以,epoll 属于同步 I/O 多路复用。内核能够主动唤醒等待线程,并不等于应用提交的整个读取操作已经异步完成。

    还要区分两件事:

    • 非阻塞套接字:recv、send 暂时无法推进时及时返回。
    • 阻塞的 epoll_wait:没有可处理事件时,让事件循环线程休眠。

    “非阻塞 socket + 可以阻塞的 epoll_wait”恰好是事件驱动服务器的常见组合。

    二、从 poll 走向 epoll:为什么要把“注册”和“等待”拆开?

    2.1 poll 已经比 select 好用了一些

    poll 的接口如下:

    #include <poll.h>

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

    struct pollfd {
    int fd;
    short events; // 应用关心哪些事件
    short revents; // 内核返回哪些事件已经发生
    };

    例如,同时关心两个连接的读事件:

    struct pollfd fds[2] = {
    {.fd = fd1, .events = POLLIN},
    {.fd = fd2, .events = POLLIN}
    };

    int ready = poll(fds, 2, 1000); // 最多等待 1000 毫秒
    if (ready > 0) {
    for (int i = 0; i < 2; ++i) {
    if (fds[i].revents & POLLIN) {
    // 尝试读取,并检查实际返回值。
    }
    // 完整程序还应处理 POLLERR、POLLHUP、POLLNVAL。
    }
    }

    这里的示意片段使用 C 语法。注意事件使用 & 判断,因为一个 fd 可能同时带有多个事件位。

    与 select 相比,poll 用数组保存关注项,把输入事件与返回事件分开,也没有 fd_set 固定大小带来的那种限制。Linux 上常见的 glibc fd_set 要求 fd 数值小于 FD_SETSIZE,通常是 1024;这也不等于进程总共只能打开 1024 个文件。接口细节分别见 poll(2) 和 select(2)。

    2.2 问题出在“每次都把全部关注项再交一遍”

    假设关注一万个连接,这一轮只有十个活跃:

    • 调用 poll 时,仍然需要提交这一万个关注项。
    • 内核需要检查这些关注项。
    • 返回以后,应用还需要检查数组中的 revents,找到可处理的连接。

    如果大部分连接长期空闲,这些重复工作就比较明显。

    epoll 的设计把两类工作拆开:

    工作什么时候做
    告诉内核关注哪些 fd、哪些事件 新连接加入、关注事件改变、连接退出时
    等待并取回当前可处理的事件 每一轮事件循环

    于是,三个接口自然出现了:

    epoll_create1:创建一个 epoll 实例
    epoll_ctl:增加、修改、删除关注项
    epoll_wait:等待并取得一批就绪事件

    这就是全文的第一条联系:接口拆分,是为了让关注项能够长期保存在内核中。

    三、三个接口讲透:每个参数到底代表什么?

    3.1 epoll_create1:创建实例,得到 epfd

    #include <sys/epoll.h>

    int epoll_create(int size);
    int epoll_create1(int flags);

    新代码可以这样写:

    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) {
    perror("epoll_create1");
    // 处理创建失败。
    }

    成功返回非负文件描述符,失败返回 -1。

    EPOLL_CLOEXEC 设置 close-on-exec 标志,在成功执行 exec 系列操作时关闭这个描述符。它与套接字是否非阻塞没有关系。

    旧接口 epoll_create(size) 中,size 在现代 Linux 上已经不用于决定容量,但仍必须大于 0。因此:

    int epfd = epoll_create(1);

    不表示只能关注一个 fd,也不要求后面的 maxevents 小于等于 1。相关历史与参数规则见 epoll_create(2)。

    使用结束后要关闭:

    close(epfd);

    **关闭 epfd 会释放对应实例的资源,但不会替应用关闭所有被关注的业务 socket。**业务连接需要单独管理。

    3.2 epoll_ctl:维护关注项

    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

    参数含义
    epfd 要操作哪个 epoll 实例
    op 增加、修改还是删除
    fd 被关注的目标文件描述符
    event 关注的事件,以及应用附带的数据

    三个操作分别是:

    EPOLL_CTL_ADD:增加关注项
    EPOLL_CTL_MOD:修改已有关注项
    EPOLL_CTL_DEL:删除关注项

    注册一个连接的读事件:

    epoll_event ev{};
    ev.events = EPOLLIN;
    ev.data.fd = client_fd;

    if (epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev) == -1) {
    perror("epoll_ctl ADD");
    }

    删除关注项:

    if (epoll_ctl(epfd, EPOLL_CTL_DEL, client_fd, nullptr) == -1) {
    perror("epoll_ctl DEL");
    }

    DEL 的最后一个参数被忽略,可以传空指针。**删除关注项不会关闭 client_fd。**这两个操作的责任不同。定义见 epoll_ctl(2)。

    3.3 epoll_event:events 传事件,data 帮你认出连接

    用户态常用结构可以理解为:

    typedef union epoll_data {
    void *ptr;
    int fd;
    uint32_t u32;
    uint64_t u64;
    } epoll_data_t;

    struct epoll_event {
    uint32_t events;
    epoll_data_t data;
    };

    这里最容易混淆的是 data:

    它由应用填写,内核保存,返回事件时再带回来。

    epoll_ctl 的第三个参数已经说明了要关注哪个 fd,所以 ev.data.fd = client_fd 并不是在第二次注册 fd,而是在约定:“以后返回事件时,请把这个值交还给我。”

    也可以保存连接编号:

    ev.data.u64 = connection_id;

    或者保存连接对象指针:

    ev.data.ptr = connection;

    但它是联合体,成员共享存储空间,不能同时把 fd 和 ptr 当作两个独立字段使用。保存指针时,内核只保存指针值,不会复制对象,更不会延长对象寿命。结构定义见 epoll_event(3type)。

    3.4 常用事件,先分清“状态”与“选项”

    标志用途
    EPOLLIN 关注可读条件
    EPOLLOUT 关注可写条件
    EPOLLRDHUP 对端关闭连接或关闭 TCP 写方向,需要显式关注
    EPOLLERR 发生错误,无须在关注集合中额外声明也会报告
    EPOLLHUP 挂断,无须额外声明也会报告;仍可能有数据未读
    EPOLLPRI 高优先级或异常条件,例如 TCP 带外数据
    EPOLLET 启用边缘触发,后文展开
    EPOLLONESHOT 事件交付后暂停该关注项的后续通知,需重新激活

    前几项描述 I/O 条件,后两项影响通知方式。不要把它们都理解成“收到了一种业务消息”。详细语义见 epoll_ctl(2)。

    事件判断也要按位进行:

    if (events[i].events & EPOLLIN) {
    // 处理读方向。
    }
    if (events[i].events & EPOLLOUT) {
    // 处理写方向;它可能与读事件同时出现。
    }

    3.5 epoll_wait:取回一批事件

    int epoll_wait(int epfd, struct epoll_event *events,
    int maxevents, int timeout);

    典型调用:

    epoll_event events[128];
    int n = epoll_wait(epfd, events, 128, -1);

    • events:应用预先准备的输出数组。
    • maxevents:这一轮最多返回多少项,必须大于 0,并且不能超过实际数组容量。
    • timeout:等待时长,单位毫秒;-1 表示无限等待,0 表示立即检查并返回。
    • 返回 n > 0:本次返回了 n 项事件。
    • 返回 0:本次等待没有取得事件。
    • 返回 -1:出错,通过 errno 判断原因,例如 EINTR。

    **128 是单批上限,和总共关注多少连接没有直接关系。**关注一万个连接、每轮最多返回 128 项,是完全正常的用法。如果当前可报告项超过一批,后续调用还能继续取得其他项;内核也有轮转处理机制。规则见 epoll_wait(2)。

    取回事件后,只遍历本次有效范围:

    for (int i = 0; i < n; ++i) {
    // events[0] 到 events[n – 1] 才是本次返回的内容。
    }

    至此,可以把接口记成三句话:

    create:建立容器。ctl:维护关注项。wait:取回就绪项。

    四、回到内核:红黑树、就绪队列和回调怎样配合?

    理解接口后,再看实现,很多结构就有了用途。

    4.1 epfd 为什么也是文件描述符?

    fd 可以理解为进程访问内核对象的一把索引钥匙。它对应的对象不一定是磁盘文件,也可以是 socket 或 epoll 实例。

    在常见 Linux 实现中,可以沿着下面的关系理解 epfd:

    进程的文件描述符表
    ↓ 用 epfd 找到
    struct file
    ↓ private_data
    struct eventpoll

    课件里的 eventpoll 保存了管理关注项和交付就绪项所需要的结构。示意如下,省略锁、引用计数等实现细节:

    eventpoll
    ├── 关注集合:常见实现使用红黑树
    ├── 就绪队列:记录需要检查和交付的关注项
    └── 等待队列:组织正在等待事件的线程

    关注集合、就绪队列、等待线程的队列,是三种不同用途的结构。“有多少连接”“哪些连接可能就绪”“哪些线程正在睡眠”,不能混成一个问题。

    4.2 一个 epitem 可以同时属于红黑树和链表

    每个注册的关注项通常对应一个 epitem。同一个对象内,可以嵌入红黑树节点成员和链表节点成员:

    epitem
    ├── 红黑树节点成员:用于组织关注集合
    ├── 就绪链表节点成员:用于链接就绪项
    ├── 目标文件与 fd 的信息
    ├── 关注事件与用户 data
    └── 所属的 eventpoll

    因此,一个对象能够同时参与多种数据结构:树和链表通过不同的链接成员引用它,无须各自复制一份连接数据。

    红黑树主要服务于关注项的查找、增加、删除等管理操作。教学时常简写为“按 fd 管理”,更严格地说,关注项的身份与 fd 数值及其关联的内核打开文件描述有关,不能把所有场景都简化成一个整数。尤其在涉及 dup、fork 时,要留意这一点。

    树中有 N 个节点时,红黑树相关操作通常用 O(log N) 描述;这里的 N 是节点数量。

    4.3 fd 就绪以后,谁把它放进就绪队列?

    这一步由内核中的通知与回调机制衔接。

    注册关注项时,epoll 会借助目标文件的 poll 支持,把相关等待项挂到目标对象的等待队列上。网络协议栈使 socket 状态变化并触发唤醒时,相关回调便有机会运行。

    可以把普通接收路径概括成下面的示意图;它省略了具体网卡、NAPI、软中断等实现细节:

    flowchart TD
    A[应用通过 epoll_ctl 注册关注项] –> B[建立目标对象的等待与回调关联]
    C[网络数据经过协议栈到达 socket] –> D[socket 状态变化并触发唤醒]
    B –> E[相关 epoll 回调运行]
    D –> E
    E –> F[符合条件的关注项进入就绪队列]
    F –> G[唤醒等待中的 epoll_wait]
    G –> H[向用户数组交付事件]
    H –> I[应用调用 recv 或 send]

    这里有两个关键细节:

  • 回调关联已经建立,因此回调能够关联到对应的关注项,不需要每来一份数据都遍历整棵关注树。
  • 注册时也会检查当前状态。即使数据先到、应用后执行 ADD,也不能简单认为“错过到达时刻就永远收不到事件”。
  • ep_poll_callback 运行在内核中。我们在应用里编写的读处理函数,是事件循环拿到事件后自行调用的,两者处在不同层次。

    上述结构与路径可以对照 Linux v6.12 的 fs/eventpoll.c 阅读。课件截取了较早版本源码,字段名称与现代版本可能不同;学习时重点理解职责与关联。

    4.4 就绪队列保存的是线索,数据还在 socket 中

    “就绪队列里有 fd”很容易让人产生另一个误解:队列中是不是已经放好了一条条完整请求?

    实际应当这样理解:

    • 队列组织的是关注项及其就绪线索。
    • 接收到的 TCP 数据仍由 socket 的接收路径管理。
    • 多次状态变化可能合并成一次事件交付。
    • 内核交付事件时还可能复查当前状态。
    • 应用最终仍以 recv、send 的结果推进连接状态。

    因此,事件数量不能当作 TCP 报文段数量,更不能当作应用请求数量。

    就绪队列也可以从“内核产生待处理线索,应用消费线索”的角度帮助理解,但它具有合并、复查、重新入队等语义,不能套用普通消息队列的逐条消息模型。

    五、epoll 为什么快?把 O(1) 的说法讲准确

    5.1 优势来自减少与空闲连接有关的重复工作

    回到开头的一万个连接、十个活跃连接:

    • 关注关系已经保存在内核里。
    • 状态变化通过已有机制关联到关注项。
    • epoll_wait 从就绪候选项中收集可交付事件。
    • 应用遍历本次返回的事件数组。

    与每轮重新处理整份关注数组相比,这种方式减少了大量空闲连接带来的重复检查与传递成本。

    5.2 “检查队列是否为空”和“交付 K 个事件”要分开

    假设总关注项为 N,本次实际交付 K 项事件:

    操作合理的理解方式
    看就绪队列是否为空 这个局部判断可以是常数级操作
    管理红黑树中的关注项 通常涉及 O(log N) 的树操作
    复制并遍历本次 K 项结果 至少与 K 有关
    读取、解析、发送业务数据 与实际数据量和业务逻辑有关

    所以,“epoll 的所有操作都是 O(1),连接再多也不影响性能”并不准确。

    常见的“select/poll 约为 O(N),epoll 约为 O(K)”是一种突出主要差异的教学模型。真实内核还有候选状态复查、并发控制、回调、缓存访问等成本,不能把这个模型当成所有负载下的严格性能保证。

    5.3 epoll 仍然需要复制事件结果

    我们已经看到,events 数组由应用提供,内核把结果写到这块用户内存中。

    所以,不能把 epoll 的高效解释成“用 mmap 把就绪队列映射给用户,因此完全没有复制”。正确的理解是:它减少了重复传递完整关注集合的工作,并集中交付当前事件结果。

    普通 recv 的数据复制又是另一层开销,不应和 epoll 的事件结果复制混为一谈。

    5.4 没有 fd_set 那种固定限制,也仍然有资源上限

    epoll 的实际规模会受到进程 fd 限额、系统资源、内核关注项限额、socket 缓冲区和应用内存等因素影响。

    可以先查看:

    ulimit -n
    cat /proc/sys/fs/epoll/max_user_watches

    第二项属于按真实用户 ID 计算的 epoll 关注项资源限制之一。大规模服务还要评估连接对象、收发缓冲区和总内存预算。

    5.5 什么场景最容易体现优势?

    “连接多,而且大部分连接在多数时候空闲”,是很典型的场景。

    如果只有几个连接,或者几乎所有连接一直很忙,或者连接注册、删除极其频繁,epoll 的优势可能不明显,其他成本也可能成为主导。

    连接少时也完全可以使用 epoll,尤其是已有框架已经统一采用事件循环时。具体选型要看复杂度、平台需求和实测结果。

    六、LT 与 ET:用“来了 2KB,只读 1KB”理解通知方式

    6.1 LT:条件仍然成立,就还能再次得到通知

    LT 是 Level Triggered,水平触发,也是 epoll 的默认方式。

    对于没有关闭、没有其他特殊状态的普通 TCP 连接,假设:

  • 接收缓冲区原本为空。
  • 对端发来 2KB 数据。
  • epoll_wait 返回读事件。
  • 应用只读取 1KB,缓冲区里还有 1KB。
  • 应用再次调用 epoll_wait。
  • 因为可读条件仍然成立,这个连接仍可以再次被报告。

    LT 给应用提供了比较直观的处理方式:这一轮只处理一部分,后面还可以继续接到通知。

    但它也有代价:如果应用一直不读,读就绪可能反复返回;如果一直关注一个通常可写的 socket,写事件也可能反复返回。

    补充一个边界:即使缓冲区的数据读完了,EOF 或错误等条件仍可能让读方向可报告。因此,“读空以后就绝对没有读事件”也不是通用结论。

    6.2 ET:不能依赖旧条件持续成立来获得重复提醒

    ET 是 Edge Triggered,边缘触发,通过 EPOLLET 启用:

    ev.events = EPOLLIN | EPOLLET;

    仍然使用刚才的例子:收到 2KB,只读取 1KB,然后直接回到 epoll_wait。

    在 ET 下,剩余 1KB 并不保证让内核再次提醒。如果此后没有新的相关变化,线程可能一直等,而数据其实就在接收缓冲区里。

    这正是最常见的 ET 卡住原因。

    同一个过程LTET
    数据到达并形成可读条件 可以报告读事件 可以报告读事件
    应用只读取一部分 可读条件继续存在 可读条件继续存在
    再次等待,期间没有新的相关变化 通常仍可报告 不能依赖再次报告
    基础处理策略 可以分次处理,也可以读到暂时无数据 非阻塞读取到 EAGAIN,或自行保存待继续处理的状态

    这里要纠正两个过度简化的记忆法:

    • **ET 不等于一个连接一生只通知一次。**后续 I/O 活动还可能触发通知。
    • **ET 也不应机械理解为只在“空变非空”的唯一时刻触发。**Linux 的具体通知来自底层唤醒机制,新数据、重新激活等情况都需要结合实际语义理解。

    对写程序最有用的规则是:**收到通知后,自己推进 I/O;不要靠下一次通知替你补做这一轮剩下的工作。**LT/ET 的基础行为和使用建议见 epoll(7)。

    6.3 为什么 ET 通常必须配合非阻塞 I/O?

    为了解决“只读一部分”的问题,我们会循环读取:

    读到数据 → 继续读 → 继续读 → ……

    如果 socket 是阻塞的,读完当前全部数据以后,再执行一次 recv,线程就可能停下来等下一批数据。

    结果是:一个连接拖住整个事件循环。

    改成非阻塞后,当前没有数据可读时,recv 会返回 -1,并把 errno 设置为 EAGAIN 或 EWOULDBLOCK。线程据此结束当前读处理,转去服务其他连接。

    所以这里的逻辑是完整的一条链:

    ET 不保证持续提醒未处理完的可读条件
    ↓
    应用要主动推进当前可读取的数据
    ↓
    循环读取需要一个“目前读完了”的退出信号
    ↓
    非阻塞 recv 返回 EAGAIN,事件循环得以继续服务其他连接

    内核接口并不会因为 socket 是阻塞的就拒绝设置 EPOLLET。非阻塞是编写可靠事件循环的工程要求。

    同样,即使使用 LT,服务器通常也建议使用非阻塞 socket。LT 解决通知方式问题,无法替你消除阻塞 send 或其他阻塞操作造成的停顿。

    6.4 非阻塞读的四种结果,要分别处理

    对于请求长度大于 0 的 TCP recv:

    返回结果含义通常怎么处理
    n > 0 收到 n 字节 按实际长度保存,继续推进
    n == 0 对端发送方向结束,读取到 EOF 标记读端结束,再决定何时关闭连接
    n == -1,EINTR 被信号中断 重试本次操作
    n == -1,EAGAIN/EWOULDBLOCK 当前没有更多数据可读 结束当前读处理,等待后续事件
    n == -1,其他错误 连接或操作出错 按错误策略处理,常见做法是关闭连接

    这些结果的区别可参见 recv(2)。对应的基础循环是:

    for (;;) {
    ssize_t n = recv(fd, buf, sizeof(buf), 0);
    if (n > 0) {
    input.append(buf, static_cast<std::size_t>(n));
    continue;
    }
    if (n == 0) {
    peer_eof = true;
    break;
    }
    if (errno == EINTR) continue;
    if (errno == EAGAIN || errno == EWOULDBLOCK) break;
    // 其他错误:记录、清理连接。
    break;
    }

    注意 append 必须带上长度。网络数据中可能包含 \\0,不能把所有接收内容都当作以零结尾的 C 字符串。

    6.5 EAGAIN 是交还执行权的时机

    下面这种写法很危险:

    if (errno == EAGAIN) {
    continue;
    }

    如果它位于同一个连接的读取循环中,且没有其他调度机制,就会反复调用一个暂时读不到数据的 recv,造成忙等。

    正确的基础行为是退出这个连接的读循环,回到外层事件循环。

    写方向也是一样。EAGAIN 表示现在暂时推进不了,应用应当保留状态,等合适的事件后再继续。

    6.6 读到 EAGAIN,也不代表一条请求已经收完

    假设应用协议规定:每条请求固定 10KB。

    客户端先发送 3KB,剩下 7KB 过一会儿才到。服务器读完当前 3KB 后遇到 EAGAIN,只能得出:

    当前这个时刻,没有更多字节可读。

    它无法得出“10KB 请求已经完整”的结论。已经读到的 3KB 要保存在连接输入缓冲区里,等后续数据到达后继续拼接。

    同理,recv 返回的长度小于所提供的缓冲区长度,也不代表一个应用请求结束。基础示例统一以 EAGAIN、EOF 或错误作为读处理的停止依据,更容易形成清晰的状态机。

    6.7 ET 是否一定比 LT 快?

    ET 可以减少某些情况下的重复通知,但结果取决于活跃连接比例、处理策略、数据大小和调用开销。

    LT 如果每次也积极处理当前可处理的数据,就不会因为“只读一点”而产生那么多重复提醒。两者的性能不能只凭名字判断。

    另外,“ET 必须立刻把所有事情做完”也太绝对。应用可以维护自己的待处理队列,把连接分批轮转处理。关键是保留“它还有工作没做完”的状态,不能尚未处理完就完全依赖内核下一次边缘通知。

    这既关系到正确性,也关系到公平性:一个持续发送数据的连接,不能无限占用事件循环。

    七、写事件、accept 与关闭:把一个连接的生命周期补齐

    7.1 非阻塞状态需要设置在正确的 fd 上

    对已有 fd,可以保留原有状态位,再加上非阻塞标志:

    #include <fcntl.h>

    bool set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) return false;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1;
    }

    Linux 也支持创建 socket 时使用 SOCK_NONBLOCK,以及用 accept4 给新连接设置 SOCK_NONBLOCK | SOCK_CLOEXEC。

    特别注意:**在 Linux 上,不能假设 accept 返回的连接会自动继承监听 socket 的 O_NONBLOCK。**要为新连接明确设置。监听 socket 本身如果采用非阻塞接受,也需要事先设置好。相关规则见 accept(2)。

    7.2 监听 socket 使用 ET,也要接收到 EAGAIN

    监听 socket 可读,通常说明它的已完成连接队列中有连接可以取出。

    如果这一轮同时来了多个连接,只 accept 一次就回去等待,在 ET 下可能留下没有处理的连接。

    基础写法是:

    for (;;) {
    int fd = accept4(listen_fd, nullptr, nullptr,
    SOCK_NONBLOCK | SOCK_CLOEXEC);
    if (fd >= 0) {
    // 为新连接建立状态,并注册到 epoll。
    continue;
    }
    if (errno == EINTR) continue;
    if (errno == EAGAIN || errno == EWOULDBLOCK) break;
    // 区分可重试的连接错误与资源耗尽等错误。
    break;
    }

    这里的 break 只说明示意循环的停止位置。生产程序需要对 EMFILE、ENFILE 等情况安排资源恢复和重试,尤其不能让 ET 监听器遗留任务后再也不尝试。

    7.3 为什么只监听 EPOLLIN 的 echo 示例还不够?

    一个常见的教学示例是:收到读事件 → recv → 处理 → send。

    小数据、本机测试时,它往往看起来正常。但客户端读取很慢时,服务器发送缓冲区可能装不下全部响应。

    此时非阻塞 send 可能:

    • 只接受一部分字节。
    • 暂时无法接受更多字节,返回 EAGAIN。

    如果忽略返回值,响应会丢;如果原地反复重试,事件循环会忙等。

    所以每个连接需要保存:

    待发送缓冲区 + 已发送位置

    这里的“已发送”指已经交给本机内核,并不代表对端应用已经处理完。发送接口的语义见 send(2)。

    7.4 EPOLLOUT 应当和待发送数据配合

    一种容易理解的处理策略是:

    产生响应
    ↓
    先立即尝试 send
    ├── 全部交给内核 → 不再关注 EPOLLOUT
    └── 仍有数据,遇到 EAGAIN → 保存位置,关注 EPOLLOUT
    ↓
    收到写事件后继续 send

    当待发送缓冲区为空时,就没有必要为了业务响应一直处理可写通知。

    在 LT 下,持续关注一个空闲且通常可写的连接,会使写事件反复返回,可能导致 CPU 占用很高。

    在 ET 下,还要注意另一个细节:**产生新的应用输出时,应主动尝试发送,不能只等未来的 EPOLLOUT。**socket 可能一直可写,此刻未必会出现一个新的可写边缘。

    这套策略不是唯一实现方式,但适合建立正确的基本模型。

    7.5 对端半关闭以后,服务器还可能需要发送响应

    客户端可以这样做:

    发送请求 → shutdown(SHUT_WR) → 继续读取服务器响应

    这意味着客户端不再发送数据,但它仍然可以接收数据。

    如果服务器一看到 EPOLLRDHUP 就直接关闭,有可能丢掉尚未读取的请求或尚未发出的响应。

    更合理的基础流程是:

  • 根据读事件或关闭提示,继续读取已经到达的数据。
  • 通过 recv == 0 确认读方向结束。
  • 若协议允许且没有致命错误,继续发送已经产生的响应。
  • 待发送数据处理完后,再关闭连接。
  • EPOLLHUP 也不能直接等同于“接收缓冲区已经空了”。挂断与残留数据可以同时存在,这一点在 epoll_ctl(2) 中有说明。

    对于 EPOLLERR,可以通过 getsockopt(fd, SOL_SOCKET, SO_ERROR, …) 获取相关 socket 错误,具体选项见 socket(7)。致命错误可以采用立即清理策略;并非任何关闭情形都能保证继续发送成功。

    7.6 DEL、close 与对象释放,各自负责什么?

    可以按这个顺序组织正常清理:

    从 epoll 删除关注项 → close socket → 释放连接对象和应用缓冲区

    DEL 结束关注关系,close 关闭描述符,对象释放处理用户态资源。

    在没有其他引用的普通场景中,关闭相关 fd 会引起内核清理关注项;涉及 dup、fork 后,同一个打开文件描述可能仍被其他 fd 引用,不能用“close 一次就一定完全消失”概括。程序显式管理注销与关闭,职责会更清楚。

    此外,已经由 epoll_wait 复制到用户态数组中的旧事件,不会因为后续 DEL 就自动从数组里消失。对象寿命与事件有效性,必须由应用自己协调。

    八、完整实战:支持 LT/ET 的非阻塞 TCP Echo 服务器

    前面的知识,现在用一个完整程序串起来。

    它采用单线程事件循环,监听 127.0.0.1,支持:

    • 通过命令行切换 LT/ET。
    • 监听 socket 与连接 socket 都使用非阻塞模式。
    • 循环 accept4、循环读取当前数据。
    • 保留未发完的数据,按需关注 EPOLLOUT。
    • 正确回显包括 \\0 在内的二进制字节。
    • 识别读方向 EOF,在输出处理完后关闭连接。
    • 使用递增连接编号识别事件,避免直接把可复用的 fd 数值当作连接的永久身份。

    **示例的边界:**每个连接最多保留 4MiB 待发送数据,超过就关闭该连接。它演示的是断开过载连接的简单策略。正式服务还需要全局内存预算、输入限额、超时、公平调度,以及资源耗尽后的恢复策略。

    保存为 epoll_echo.cpp:

    #ifndef _GNU_SOURCE
    #define _GNU_SOURCE
    #endif

    #include <arpa/inet.h>
    #include <sys/epoll.h>
    #include <sys/socket.h>
    #include <unistd.h>

    #include <cerrno>
    #include <cstdint>
    #include <cstdio>
    #include <cstdlib>
    #include <cstring>
    #include <iostream>
    #include <string>
    #include <unordered_map>
    #include <utility>

    constexpr int MAX_EVENTS = 128;
    constexpr std::size_t MAX_PENDING = 4 * 1024 * 1024;

    struct Connection {
    int fd = -1;
    std::string out;
    std::size_t sent = 0;
    bool eof = false;
    uint32_t interest = 0;
    };

    [[noreturn]] void die(const char* what) {
    std::perror(what);
    std::exit(EXIT_FAILURE);
    }

    bool would_block(int error) {
    return error == EAGAIN || error == EWOULDBLOCK;
    }

    bool ctl(int epfd, int op, int fd, uint32_t mask, uint64_t id) {
    epoll_event ev{};
    ev.events = mask;
    ev.data.u64 = id;
    return epoll_ctl(epfd, op, fd, &ev) == 0;
    }

    // These errors belong to individual pending connections; keep accepting.
    bool transient_accept_error(int error) {
    switch (error) {
    case ECONNABORTED: case ENETDOWN: case EPROTO:
    case ENOPROTOOPT: case EHOSTDOWN: case ENONET:
    case EHOSTUNREACH: case EOPNOTSUPP: case ENETUNREACH:
    return true;
    default:
    return false;
    }
    }

    bool read_available(Connection& c) {
    char buf[16 * 1024];
    for (;;) {
    ssize_t n = recv(c.fd, buf, sizeof(buf), 0);
    if (n > 0) {
    // Compacting happens before this handler, so out is all pending.
    if (static_cast<std::size_t>(n) > MAX_PENDING – c.out.size()) {
    std::cerr << "pending output limit reached, fd=" << c.fd << '\\n';
    return false;
    }
    c.out.append(buf, static_cast<std::size_t>(n));
    continue;
    }
    if (n == 0) {
    c.eof = true; // Peer finished sending; our output may remain.
    return true;
    }
    if (errno == EINTR) continue;
    if (would_block(errno)) return true;
    std::perror("recv");
    return false;
    }
    }

    bool write_available(Connection& c) {
    while (c.sent < c.out.size()) {
    ssize_t n = send(c.fd, c.out.data() + c.sent,
    c.out.size() – c.sent, MSG_NOSIGNAL);
    if (n > 0) {
    c.sent += static_cast<std::size_t>(n);
    continue;
    }
    if (n < 0 && errno == EINTR) continue;
    if (n < 0 && would_block(errno)) return true;
    if (n < 0) std::perror("send");
    return false;
    }
    c.out.clear();
    c.sent = 0;
    return true;
    }

    int main(int argc, char** argv) {
    if (argc != 3 || (std::strcmp(argv[2], "lt") != 0 &&
    std::strcmp(argv[2], "et") != 0)) {
    std::cerr << "usage: " << argv[0] << " <port> <lt|et>\\n";
    return EXIT_FAILURE;
    }
    char* end = nullptr;
    errno = 0;
    long port = std::strtol(argv[1], &end, 10);
    if (errno != 0 || end == argv[1] || *end != '\\0' ||
    port < 1 || port > 65535) {
    std::cerr << "invalid port\\n";
    return EXIT_FAILURE;
    }
    const bool et = std::strcmp(argv[2], "et") == 0;
    const uint32_t mode = et ? static_cast<uint32_t>(EPOLLET) : 0u;

    int lfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
    if (lfd < 0) die("socket");
    int one = 1;
    if (setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0)
    die("setsockopt");

    sockaddr_in address{};
    address.sin_family = AF_INET;
    address.sin_port = htons(static_cast<uint16_t>(port));
    address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    if (bind(lfd, reinterpret_cast<sockaddr*>(&address), sizeof(address)) < 0)
    die("bind");
    if (listen(lfd, SOMAXCONN) < 0) die("listen");

    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd < 0) die("epoll_create1");
    // ID 0 belongs to the listener; client IDs never follow reused fd numbers.
    if (!ctl(epfd, EPOLL_CTL_ADD, lfd, EPOLLIN | mode, 0)) die("ADD listener");

    std::unordered_map<uint64_t, Connection> clients;
    uint64_t next_id = 1;
    auto remove_client = [&](uint64_t id) {
    auto it = clients.find(id);
    if (it == clients.end()) return;
    if (epoll_ctl(epfd, EPOLL_CTL_DEL, it->second.fd, nullptr) < 0)
    std::perror("DEL client");
    close(it->second.fd);
    clients.erase(it);
    };

    epoll_event events[MAX_EVENTS];
    std::cout << "listen 127.0.0.1:" << port << " mode="
    << (et ? "ET" : "LT") << std::endl;
    bool running = true;
    while (running) {
    int count = epoll_wait(epfd, events, MAX_EVENTS, -1);
    if (count < 0) {
    if (errno == EINTR) continue;
    std::perror("epoll_wait");
    break;
    }
    for (int i = 0; i < count; ++i) {
    const uint64_t id = events[i].data.u64;
    const uint32_t mask = events[i].events;
    if (id == 0) {
    if (mask & (EPOLLERR | EPOLLHUP)) {
    std::cerr << "listener error\\n";
    running = false;
    break;
    }
    // The listener is nonblocking too: drain its accept queue.
    for (;;) {
    int fd = accept4(lfd, nullptr, nullptr,
    SOCK_NONBLOCK | SOCK_CLOEXEC);
    if (fd < 0) {
    if (errno == EINTR) continue;
    if (would_block(errno)) break;
    if (transient_accept_error(errno)) continue;
    // Demo policy: fail on resource exhaustion, rather
    // than silently strand an ET listener's pending work.
    die("accept4");
    }
    if (next_id == 0) {
    std::cerr << "connection ID space exhausted\\n";
    close(fd);
    std::exit(EXIT_FAILURE);
    }
    uint64_t new_id = next_id++;
    Connection c;
    c.fd = fd;
    c.interest = EPOLLIN | EPOLLRDHUP | mode;
    if (!ctl(epfd, EPOLL_CTL_ADD, fd, c.interest, new_id)) {
    std::perror("ADD client");
    close(fd);
    continue;
    }
    clients.emplace(new_id, std::move(c));
    }
    continue;
    }

    auto it = clients.find(id);
    if (it == clients.end()) continue; // Ignore a retired connection.
    Connection& c = it->second;
    if (mask & EPOLLERR) {
    int error = 0;
    socklen_t length = sizeof(error);
    if (getsockopt(c.fd, SOL_SOCKET, SO_ERROR, &error, &length) < 0)
    std::perror("SO_ERROR");
    else
    std::cerr << "socket error: " << std::strerror(error) << '\\n';
    remove_client(id);
    continue;
    }

    // Remove only bytes already accepted by send(), preserving the rest.
    if (c.sent != 0) {
    c.out.erase(0, c.sent);
    c.sent = 0;
    }
    bool ok = true;
    if (!c.eof && (mask & (EPOLLIN | EPOLLRDHUP | EPOLLHUP)))
    ok = read_available(c);
    // Newly produced output is tried immediately, even without OUT.
    if (ok) ok = write_available(c);
    if (!ok || (c.eof && c.out.empty())) {
    remove_client(id);
    continue;
    }

    uint32_t wanted = mode;
    if (!c.eof) wanted |= EPOLLIN | EPOLLRDHUP;
    if (c.sent < c.out.size()) wanted |= EPOLLOUT;
    if (wanted != c.interest) {
    if (!ctl(epfd, EPOLL_CTL_MOD, c.fd, wanted, id)) {
    std::perror("MOD client");
    remove_client(id);
    continue;
    }
    c.interest = wanted;
    }
    }
    }
    for (const auto& entry : clients) close(entry.second.fd);
    close(lfd);
    close(epfd);
    return EXIT_FAILURE;
    }

    8.1 编译和运行

    在安装了 g++ 的 Linux 环境中执行:

    g++ -std=c++17 -O2 -Wall -Wextra -pedantic epoll_echo.cpp -o epoll_echo

    # 先用 LT 启动
    ./epoll_echo 8080 lt

    另开一个终端:

    nc 127.0.0.1 8080

    输入一行文本,就可以看到服务器回显。nc 是否显示本地输入、如何发送 EOF,与具体终端和版本有关;后面的 Python 脚本更适合检查字节级结果。

    停止 LT 服务器后,换成 ET:

    ./epoll_echo 8080 et

    程序绑定回环地址,因此测试客户端与服务器运行在同一台机器。需要供其他机器访问时,要调整绑定地址,并按实际环境配置访问路径。

    8.2 读代码时,抓住六处联系

    第一,MAX_EVENTS = 128 只是每批事件数组的容量。

    实际连接状态放在 clients 中,连接数量并不受 128 这个数直接限制。

    第二,data.u64 保存的是连接编号。

    监听 socket 约定使用编号 0,客户端使用递增编号。数组中的旧事件如果找不到对应连接,就会被忽略。fd 关闭后可能复用,连接编号仍能区分前后两个连接。

    第三,read_available 到 EAGAIN、EOF 或错误才结束。

    读到的字节立即按长度追加到输出缓冲区。这是 echo 的业务规则;换成真正的请求协议后,应先放入输入缓冲区并解析,再产生响应。

    第四,write_available 保留未发送完的位置。

    只有 send 返回正数时才推进 sent。遇到 EAGAIN,保留剩余数据,等待后续可写事件。

    第五,读到 EOF 后仍可能关注 EPOLLOUT。

    读方向结束时撤掉读相关关注,输出处理完后关闭。这避免半关闭连接反复触发读关闭提示,也保留了发送响应的机会。

    第六,LT 和 ET 使用相同的非阻塞处理函数。

    这说明“读写循环正确”是应用自己的责任。切换 LT/ET 改变通知语义,不应改变字节流本身的正确处理规则。

    程序还使用 MSG_NOSIGNAL,避免给已关闭写入方向的连接发送时,由 SIGPIPE 的默认行为结束整个进程;发送失败仍要检查返回值。

    这份示例对于不可恢复的监听错误采用退出策略。业务连接发生错误时清理该连接。生产程序则需要进一步设计服务恢复与优雅退出。

    九、动手实验:把通知差异和字节流行为真正跑出来

    9.1 实验一:用 socketpair 对比 LT/ET

    Python 的 select.epoll 封装了 Linux epoll。我们可以用 socketpair 创建本机相连的一对 socket,让实验尽量少受网络时序干扰。

    这个实验有意只读一部分数据,用来展示差异;它不是服务器的推荐读取方式。

    保存为 lt_et_demo.py,在 Linux 上运行:

    """Run with Python 3 on Linux; demonstrate partial reads under LT and ET."""
    import select
    import socket

    def run(edge_triggered):
    reader, writer = socket.socketpair()
    reader.setblocking(False)
    label = "ET" if edge_triggered else "LT"
    with reader, writer, select.epoll() as ep:
    flags = select.EPOLLIN
    if edge_triggered:
    flags |= select.EPOLLET
    ep.register(reader.fileno(), flags)
    writer.sendall(b"A" * 2048)
    first = ep.poll(1)
    assert first, "initial event was not received"
    print(label, "first event count:", len(first))
    assert len(reader.recv(1024)) == 1024
    second = ep.poll(0.1)
    print(label, "second event count:", len(second))
    assert bool(second) == (not edge_triggered)
    # No second ET notification is required for these remaining bytes.
    assert len(reader.recv(4096)) == 1024
    try:
    reader.recv(1)
    except BlockingIOError:
    print(label, "remaining data drained; now EAGAIN")
    else:
    raise AssertionError("expected EAGAIN after draining the socket")

    if __name__ == "__main__":
    run(False)
    run(True)

    python3 lt_et_demo.py

    在该实验条件下,预期结果为:

    LT first event count: 1
    LT second event count: 1
    LT remaining data drained; now EAGAIN
    ET first event count: 1
    ET second event count: 0
    ET remaining data drained; now EAGAIN

    观察最后两步:ET 的第二次等待没有事件,应用仍能读出剩下的 1KB。这就证明了:

    没有新的事件通知,不能推出 socket 里没有未处理数据。

    读完后再尝试一次,才得到 EAGAIN。

    9.2 实验二:验证 Echo 服务器的字节结果

    先启动服务器,再将下面脚本保存为 test_echo.py:

    """Start epoll_echo first, then run: python3 test_echo.py [port]."""
    from concurrent.futures import ThreadPoolExecutor
    import socket
    import sys

    PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 8080

    def check_echo(payload, fragment_size=None):
    with socket.create_connection(("127.0.0.1", PORT), timeout=5) as s:
    s.settimeout(10)
    if fragment_size:
    for pos in range(0, len(payload), fragment_size):
    s.sendall(payload[pos:pos + fragment_size])
    else:
    s.sendall(payload)
    s.shutdown(socket.SHUT_WR)
    result = bytearray()
    while True:
    part = s.recv(65536)
    if not part:
    break
    result.extend(part)
    assert result == payload, (len(payload), len(result))

    check_echo(b"hello epoll\\n")
    check_echo(bytes(range(256)) * 32, fragment_size=7)
    check_echo(bytes(range(256)) * 4096)
    check_echo(b"")
    with ThreadPoolExecutor(max_workers=32) as pool:
    list(pool.map(lambda i: check_echo((f"client-{i}\\n".encode()) * 200),
    range(64)))
    print("PASS: text, fragmented writes, binary data, 1 MiB, half-close, 64 clients")

    执行:

    python3 test_echo.py 8080

    全部断言通过时,脚本会输出:

    PASS: text, fragmented writes, binary data, 1 MiB, half-close, 64 clients

    然后分别对 LT、ET 各运行一遍。

    这些用例检查了几个容易被“小字符串演示”掩盖的问题:

    • 二进制数据中的 \\0 有没有被错误截断。
    • 超过单次接收缓冲区大小的数据能否完整回显。
    • 客户端多次写入后,结果是否仍按字节顺序一致。
    • 客户端结束写方向后,是否仍能收到完整响应。
    • 多个客户端是否能够被同一个事件循环服务。

    其中“每 7 字节发送一次”只是客户端写入方式,不保证服务器恰好每次收到 7 字节。这也是 TCP 字节流的一部分语义。

    这组基础用例不保证每一次运行都触发 send 的 EAGAIN。要专门观察写回压,可以调小服务端连接的 SO_SNDBUF,让客户端延迟或缓慢读取,并观察发送返回值与 EPOLLOUT 的启停;测试数据要与示例的 4MiB 限额协调。

    9.3 实验三:观察系统调用

    在安装了 strace 的 Linux 环境中,可以这样启动服务器:

    strace -e trace=epoll_create1,epoll_ctl,epoll_wait,accept4,recvfrom,sendto \\
    ./epoll_echo 8080 et

    在常见 Linux 环境中,socket 的 recv、send 调用可能显示为 recvfrom、sendto 等底层系统调用名称。具体显示与架构、运行库有关。

    重点观察:

  • 新连接建立后出现 EPOLL_CTL_ADD。
  • 一次读事件后,可能连续出现多次接收调用。
  • 非阻塞接收最终可能返回 EAGAIN。
  • 没有事情可做时,线程停在 epoll_wait。
  • 有未发送完的数据时,关注集合才需要包含 EPOLLOUT。
  • 把源码、事件和系统调用对应起来,epoll 就不再只是几个抽象名词。

    十、知识补全:epoll 无法替你解决 TCP 消息边界

    10.1 一次 send 和一次 recv 没有一一对应关系

    客户端执行:

    send("hello")
    send("world")

    服务器可能读到:

    一次:"helloworld"

    也可能读到:

    第一次:"hel"
    第二次:"lowo"
    第三次:"rld"

    只要字节内容和顺序符合 TCP 语义,这些情况都可能是正常的。TCP 提供可靠、有序的字节流,但不保留应用写入的消息边界,见 tcp(7)。

    因此,大家常说的“粘包、拆包”,需要由应用协议的组帧规则处理。

    10.2 输入缓冲区的寿命,要跨过多次事件

    常见的消息边界设计有:

    方式例子要注意什么
    固定长度 每条请求固定 128 字节 格式灵活性有限
    分隔符 每行一条,以 \\n 结束 正文中的分隔符需要转义或约定
    长度前缀 4 字节长度 + 消息体 长度大小、字节序、最大长度校验

    以“4 字节长度头 + 消息体”为例,每个连接可以维护独立输入缓冲区:

    recv 得到新字节 → 追加到该连接的输入缓冲区
    ↓
    是否至少有 4 字节?
    否:保留,等下次数据
    是:读取并校验消息长度
    ↓
    消息体是否已经到齐?
    否:保留,等下次数据
    是:取出一条消息并处理
    ↓
    继续检查是否还有下一条完整消息

    长度头应按协议指定的字节序解码,并在分配内存或等待消息体前校验最大允许长度。

    有两个边界情况尤其重要:

    • 一次 recv 带来多条完整消息,解析器要能连续取出。
    • 对端 EOF 时还剩不完整消息,要按协议判断截断或错误。

    前面 Echo 服务器没有输入解析器,是因为它的业务规则就是“收到多少字节,就按顺序回显多少字节”。真正的聊天协议、RPC 协议或 HTTP 服务,需要补上自己的解析状态。

    至此,前后两条线接上了:

    epoll 管理何时推进 I/O;连接状态机管理字节如何组成消息。

    十一、进阶边界:线程池、ONESHOT、公平性和惊群

    11.1 单线程事件循环不适合做耗时业务

    即使网络读写都非阻塞,下面的逻辑仍可能让所有连接停下来:

    收到一个连接的请求 → 在事件循环里执行 3 秒计算 → 再处理其他连接

    同步数据库查询、阻塞磁盘访问、等待互斥锁,也可能造成类似问题。epoll 不会把这些操作自动变成非阻塞。

    常见改进方式是:事件循环负责网络状态与轻量调度,线程池处理适合移交的耗时任务,完成后再安全地把结果交回连接所属的事件循环。

    这属于 Reactor 架构的常见组织方式。epoll 提供其中的就绪事件来源,连接对象、任务调度和线程间通信仍需框架设计。

    11.2 EPOLLONESHOT:交付一次后暂停,使用 MOD 重新激活

    多个工作线程处理同一连接时,应用通常希望明确“当前由谁处理它”。EPOLLONESHOT 可以参与这种设计:

    ev.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    ev.data.u64 = connection_id;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

    当该关注项的一次事件被交付后,后续通知暂停。处理完当前状态,准备继续监听时:

    ev.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    ev.data.u64 = connection_id;
    if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {
    // 处理重新激活失败。
    }

    **这里使用 MOD,无需先删除再 ADD。**如果连接还有待发送内容,重新激活时也要把相应写关注保留下来。定义见 epoll_ctl(2)。

    ONESHOT 只控制关注项的事件交付。其他线程如果直接操作同一 socket,或者连接对象的访问没有协调,它并不会自动解决这些竞争。

    11.3 内核接口能并发使用,不代表业务连接天然线程安全

    需要分别考虑:

    • 内核如何同步对同一个 epoll 实例的操作。
    • 应用如何同步连接输入、输出缓冲区。
    • 哪个线程有权关闭 fd。
    • 哪个线程有权释放 data.ptr 指向的对象。
    • 当前事件数组里是否还有指向旧连接的事件。

    特别是使用 data.ptr 时:指针已经返回给应用,但另一个线程把对象释放了,就可能发生悬空访问。

    常见方法包括连接归属线程、引用计数、延迟回收,以及连接编号配合代际信息。本文示例使用单线程管理连接,并用不复用的递增编号关联事件,使生命周期更容易追踪。

    11.4 公平性:ET 不能无限读一个连接

    “读到 EAGAIN”很好地说明了基础正确性,但面对持续高速发送的连接,事件循环可能长时间停留在这一个连接上。

    工程上可以给单个连接设置本轮字节预算或处理次数预算。预算耗尽后,把它留在应用自己的待处理队列里,下一轮继续推进。

    **ET 下提前让出执行权时,必须记住它还有工作。**如果没有读到暂时无数据,就直接把它遗忘并等待新边缘,仍可能回到前面“剩余数据无人处理”的问题。

    本文为了让核心代码容易跟踪,没有加入这套调度器,因此高负载下还需要扩展公平调度。

    11.5 惊群:先分清大家在等哪一个对象

    惊群通常指:一个事件唤醒多个等待者,但只有部分等待者实际取得工作,其余等待者付出唤醒与竞争成本。

    epoll 中不能把所有情况混在一起:

    情形需要理解的区别
    多个线程等待同一个 epoll 实例 对同一实例中以 ET 关注的 fd,手册描述其就绪时唤醒其中一个等待者的行为
    多个 epoll 实例关注同一个监听 socket 普通注册下,多个实例可能收到事件;可结合 EPOLLEXCLUSIVE 讨论
    多个监听 socket 分配连接 可结合 SO_REUSEPORT 等不同架构讨论

    EPOLLEXCLUSIVE 针对的是特定共享关注场景,不能代替 EPOLLONESHOT,也不能被理解为“所有场景严格只唤醒一个”。例如其使用限制包括只能随 ADD 设置、不能与 ONESHOT 任意组合。需要落地时应查看 epoll_ctl(2) 的完整限制。

    讨论并发之前,先画清楚“进程/线程 → epoll 实例 → 监听 socket”的关系,比只背一个“epoll 解决惊群”的结论更有用。

    十二、select、poll、epoll 放在一起比较

    维度selectpollepoll
    关注项形式 多个 fd_set pollfd 数组 内核中持久保存的关注集合
    输入输出 返回时修改集合 events 与 revents 分开 ctl 注册,wait 输出
    每轮是否提交完整关注集合 是 是 无需重复提交,按变化维护
    应用如何找出本轮就绪项 检查返回集合 检查数组的 revents 遍历返回的事件数组
    大量空闲连接的重复检查成本 通常比较明显 通常比较明显 通常更有优势
    通知语义 类似水平触发 类似水平触发 支持 LT 与 ET
    典型规模限制 常见 fd_set 存在固定表示范围 没有该固定范围,仍受资源限制 没有该固定范围,仍受资源限制
    平台 广泛可用 广泛可用 Linux 专有接口
    编程复杂度 集合维护较繁琐 接口相对直观 连接状态与 ET 等高级用法需要更细致设计

    这些机制的选择最终取决于连接规模、活跃比例、平台需求与框架设计。只有少量 fd 时,简单往往也是重要收益。

    还有一个范围提醒:epoll 适合具有相应事件通知语义的对象,例如 socket、管道及一些特殊 fd。**普通磁盘文件通常不能像网络 socket 那样直接加入 epoll,可能得到 EPERM。**不要把“Linux 一切皆文件”理解成所有文件都支持相同的等待语义。

    十三、把最容易记错的地方集中校正

    容易记成的说法更准确的理解
    epoll_create(100) 最多关注 100 个 fd 现代 Linux 忽略旧 size 的容量含义,但要求它大于 0
    maxevents 不能超过创建时的 size 两者没有这种约束;maxevents 受输出数组容量等条件约束
    epoll 每个操作都是 O(1) 队列空判断、关注管理、事件交付、业务处理要分别分析
    红黑树使 epoll 无须做任何遍历 树用于管理关注项,事件交付和应用处理仍有遍历
    epoll 使用 mmap,因此完全没有复制 事件结果仍写入用户数组,普通收发还有自己的数据路径
    ET 一个连接只通知一次 后续活动仍可能通知;重点是不能依赖旧就绪条件持续提醒
    ET 在接口上只允许非阻塞 fd 接口不会据此拒绝注册,可靠事件循环在工程上应采用非阻塞 I/O
    EAGAIN 后立刻原地重试 先保留状态并让出执行权,等待合适时机继续
    读到 EAGAIN 就收完了一条请求 只是当前无更多字节,消息完成与否由应用协议判断
    EPOLL_CTL_DEL 会关闭 socket 它只注销关注,应用仍需 close
    ONESHOT 处理后重新 ADD 通常使用 EPOLL_CTL_MOD 重新激活已有项
    可读一定有正长度数据,可写一定能全部发完 应以实际 I/O 返回值推进状态,并处理 EOF、部分操作和错误

    尤其是“EAGAIN 原地循环”和“半关闭后直接丢弃待发数据”,都可能让一个只在本机小数据下正常的演示,在真实网络中暴露问题。

    十四、用八个问题检查自己是否真正理解

    14.1 epoll 为什么要有三个接口?

    为了让关注集合长期保存在内核中,把关注项的维护与每一轮等待、交付分开。

    14.2 epoll 为什么使用红黑树,还要有就绪队列?

    两者服务不同问题:树管理全部关注项,队列组织当前需要检查和交付的就绪项。同一个 epitem 可以通过不同成员同时参与这两种结构。

    14.3 为什么 epoll 更适合大量空闲连接?

    它减少每一轮围绕全部关注项进行的重复传递与检查,把更多工作集中到活动项上。连接持续忙碌时,数据处理本身也会占据很大成本。

    14.4 LT 和 ET 最关键的区别是什么?

    LT 可以在就绪条件持续成立时继续报告。ET 下,应用不能依赖这种持续条件反复提醒自己,因此要主动推进 I/O,并正确保存未完成状态。

    14.5 为什么 ET 通常配合非阻塞?

    循环读取或发送需要在暂时无法继续时及时返回。否则一个连接可能阻塞整个事件循环。

    14.6 send 返回 EAGAIN 怎么办?

    保留未发完的数据及位置,关注适当的写事件,回到事件循环;后续可写时继续发送,输出清空后撤掉不必要的写关注。

    14.7 收到 EPOLLRDHUP 能立刻关闭吗?

    需要结合协议和状态判断。可能还有输入未读,也可能需要继续发送响应。基础做法是读取到 EOF,保留并处理待发数据,再按生命周期策略关闭。

    14.8 epoll 能解决 TCP 粘包吗?

    消息边界由应用协议规定。epoll 解决等待与就绪通知,输入缓冲区和解析器负责从字节流中恢复消息。

    现在,再回到最初的场景:一万个连接,十个活跃。

    服务器先维护好一万个连接的关注关系;等待期间由内核组织就绪通知;返回后,应用针对这一批连接推进非阻塞 I/O;协议解析器判断请求是否完整;输出缓冲区保存尚未发完的响应;连接状态机决定继续等待、处理半关闭还是清理退出。

    这条路径中的每一步都有明确责任。把它们接起来,才能从“会调用 epoll”走到“能写出正确的事件驱动服务器”。

    赞(0)
    未经允许不得转载:网硕互联帮助中心 » Linux epoll 一篇讲透:从 select/poll 到红黑树、LT/ET,再到完整 TCP 服务器
    分享到: 更多 (0)

    评论 抢沙发

    评论前必须登录!