/* 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 接收分成两个阶段:
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]
这里有两个关键细节:
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 连接,假设:
因为可读条件仍然成立,这个连接仍可以再次被报告。
LT 给应用提供了比较直观的处理方式:这一轮只处理一部分,后面还可以继续接到通知。
但它也有代价:如果应用一直不读,读就绪可能反复返回;如果一直关注一个通常可写的 socket,写事件也可能反复返回。
补充一个边界:即使缓冲区的数据读完了,EOF 或错误等条件仍可能让读方向可报告。因此,“读空以后就绝对没有读事件”也不是通用结论。
6.2 ET:不能依赖旧条件持续成立来获得重复提醒
ET 是 Edge Triggered,边缘触发,通过 EPOLLET 启用:
ev.events = EPOLLIN | EPOLLET;
仍然使用刚才的例子:收到 2KB,只读取 1KB,然后直接回到 epoll_wait。
在 ET 下,剩余 1KB 并不保证让内核再次提醒。如果此后没有新的相关变化,线程可能一直等,而数据其实就在接收缓冲区里。
这正是最常见的 ET 卡住原因。
| 数据到达并形成可读条件 | 可以报告读事件 | 可以报告读事件 |
| 应用只读取一部分 | 可读条件继续存在 | 可读条件继续存在 |
| 再次等待,期间没有新的相关变化 | 通常仍可报告 | 不能依赖再次报告 |
| 基础处理策略 | 可以分次处理,也可以读到暂时无数据 | 非阻塞读取到 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 就直接关闭,有可能丢掉尚未读取的请求或尚未发出的响应。
更合理的基础流程是:
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 就不再只是几个抽象名词。
十、知识补全: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 放在一起比较
| 关注项形式 | 多个 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”走到“能写出正确的事件驱动服务器”。
网硕互联帮助中心



评论前必须登录!
注册