一、epoll 内核全景：从 select/poll 到 epoll 的设计哲学
在 Linux 高性能网络编程领域，epoll 是实现百万级并发连接的核心基础设施。理解 epoll 不能仅停留在 API 层面，更需要深入理解内核中红黑树与就绪链表的双数据结构协同模型。
1.1 select/poll 的根本缺陷
select 和 poll 都基于輪询（polling）模型，每次调用都需要将整个文件描述符集合从用户态拷贝到内核态，内核再线性扫描所有 fd 确定就绪状态，最后再将结果拷贝回用户态。当并发连接数达到数万时，O(n) 的扫描开销变得不可接受。
// select 的典型瓶颈：fd_set 大小限制 + 线性扫描
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(sockfd, &readfds);
select(maxfd+1, &readfds, NULL, NULL, &timeout);
// poll 解决了 fd_set 大小限制，但仍需 O(n) 扫描
struct pollfd fds[MAX_EVENTS];
fds[0].fd = sockfd;
fds[0].events = POLLIN;
poll(fds, nfds, timeout); // 仍然是 O(n)epoll 的核心分离思想是"注册一次，就绪时通知"，将 fd 的管理与就绪事件的等待解耦为两个独立操作。
1.2 epoll 的双数据结构模型
epoll 在内核中使用两个核心数据结构：
- 红黑树（rb_tree） — 管理所有被 epoll 监控的 fd，操作复杂度 O(log n)
- 就绪链表（rdllist） — 存储当前就绪的 epitem，追加/删除 O(1)
当调用 epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event) 时，内核执行以下步骤：在红黑树中查找 fd 是否已存在（O(log n)），分配 epitem 节点并插入红黑树，注册回调函数 ep_poll_callback 到该 fd 的 wait_queue。当 fd 上有数据到达时，内核协议栈通过回调链触发 ep_poll_callback，将对应 epitem 加入就绪链表，并唤醒正在 epoll_wait 阻塞的进程。
二、epoll 三个系统调用的内核行为
2.1 epoll_create1(int flags)
epoll_create1 替代了旧的 epoll_create，flags 参数目前只支持 EPOLL_CLOEXEC（exec 时自动关闭 fd）。
// 现代推荐写法：
int epfd = epoll_create1(EPOLL_CLOEXEC);
// 内核中的关键操作：
// 1. 分配 eventpoll 结构体
// 2. 初始化红黑树根节点 rbr = RB_ROOT
// 3. 初始化就绪链表 rdllist = LIST_HEAD_INIT
// 4. 初始化等待队列 wq
// 5. 将 eventpoll 与一个匿名 inode 关联（eventpoll 不走文件系统）epoll fd 本身也占用一个文件描述符名额。在百万级连接场景下，建议提前调优：
# /etc/sysctl.conf
fs.file-max = 2097152
fs.nr_open = 1048576
# /etc/security/limits.conf
* soft nofile 1048576
* hard nofile 10485762.2 epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
epoll_ctl 指向 epoll 实例添加、修改或删除监控事件：
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET; // 边缘触发模式
ev.data.ptr = my_connection; // 泛型指针，生产环境首选
int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, conn->fd, &ev);内核中 ep_insert 操作的完整流程：红黑树查找（O(log n)），若 EPOLL_CTL_ADD 且已存在则返回 EEXIST；分配 epitem，设置 ffd、event、nwait、pwqlist；调用 ep_item_poll 执行一次即时 poll，若已就绪则直接加入就绪链表；将 fd 的 wait queue 节点关联到 epitem 的回调 ep_poll_callback；红黑树插入（O(log n)）。
2.3 epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
struct epoll_event events[MAX_EVENTS];
int nfds = epoll_wait(epfd, events, MAX_EVENTS, timeout);epoll_wait 返回 0 表示超时，-1 且 errno=EINTR 表示被信号中断。内核中的核心循环是：检查就绪链表是否非空，若非空直接返回；将当前进程加入 ep->wq 等待队列；设置进程状态为 TASK_INTERRUPTIBLE；双检锁检查就绪链表；若就绪链表仍空且 timeout > 0，调用 schedule_timeout 进入真正的休眠；被唤醒后 ep_send_events() 将就绪链表事件拷贝到用户空间。
三、EPOLLET 边缘触发：非阻塞范式与状态机模型
EPOLLET（Edge-Triggered，边缘触发）是 epoll 从"好用"到"真正高性能"的关键分界线。边缘触发只在 fd 状态从"未就绪"变为"就绪"时通知一次，必须配合非阻塞（O_NONBLOCK）使用。
3.1 读事件的边缘触发状态机
边缘触发的"边缘"具体是：内核 socket 接收缓冲区从空变成非空这一转换点。边缘触发只在此转换点通知一次。因此必须在一次通知中把缓冲区数据彻底读尽。
// 错误示范：边缘触发下只读一次
void handle_read_et(int fd) {
char buf[4096];
ssize_t n = read(fd, buf, sizeof(buf)); // 如果还有更多数据未读则丢失！
}
// 正确范式：边缘触发 + 非阻塞 + 循环 read 到 EAGAIN
void handle_read_et(int fd) {
while (true) {
ssize_t n = read(fd, buf, sizeof(buf));
if (n > 0) {
// 处理数据...
continue;
} else if (n == 0) {
close(fd); // 对端关闭连接
break;
} else {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
break; // 缓冲区读尽，等待下一次边缘触发
}
if (errno == EINTR) continue;
close(fd);
break;
}
}
}3.2 写事件的边缘触发状态机
对于写事件，边缘触发的"边缘"是：内核 socket 发送缓冲区从满变成不满这一转换点。因此通常不需要一开始就注册 EPOLLOUT，只有当 write 返回 EAGAIN 时才注册 EPOLLOUT 等待可写通知。
typedef struct {
int fd;
buffer_t send_buf;
bool waiting_for_write;
} connection_t;
void try_write(connection_t *conn) {
while (buffer_len(&conn->send_buf) > 0) {
ssize_t n = write(conn->fd, buffer_data(&conn->send_buf),
buffer_len(&conn->send_buf));
if (n > 0) {
buffer_consume(&conn->send_buf, n);
continue;
} else {
if (errno == EAGAIN) {
if (!conn->waiting_for_write) {
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
ev.data.ptr = conn;
epoll_ctl(epfd, EPOLL_CTL_MOD, conn->fd, &ev);
conn->waiting_for_write = true;
}
}
break;
}
}
// 缓冲区清空后注销 EPOLLOUT，避免空转
if (buffer_len(&conn->send_buf) == 0 && conn->waiting_for_write) {
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;
ev.data.ptr = conn;
epoll_ctl(epfd, EPOLL_CTL_MOD, conn->fd, &ev);
conn->waiting_for_write = false;
}
}四、EPOLLONESHOT 与多线程 Reactor 安全
设置 EPOLLONESHOT 后，fd 在第一次触发并被处理（即某线程通过 epoll_wait 获取事件并执行了读/写）后，会被自动从就绪链表移除但不会从 epoll 实例中删除。fd 变为休眠状态，必须通过 epoll_ctl(EPOLL_CTL_MOD) 显式重新激活。
4.1 多线程架构
典型的 "M主 + N从" Reactor 架构：主线程 Acceptor Reactor 通过 epoll_wait 只处理 EPOLLIN（新连接），接受后 round-robin 分配到从线程的 epoll 实例。每个从线程使用 EPOLLONESHOT 保证同一 fd 在同一时刻只被一个线程处理。
4.2 生产注意事项
使用 EPOLLONESHOT 时必须确保"重新激活"操作在 fd 上的 I/O 真正完成后再执行，否则可能在同一 fd 上的数据尚未读完时就被另一个线程"抢走"剩余事件。推荐模式是：I/O 操作完全结束后（对于读：读到 EAGAIN；对于写：写完整个响应），再重新 MOD 激活。
五、惊群效应与解决方案
5.1 EPOLLEXCLUSIVE (Linux 4.5+)
EPOLLEXCLUSIVE 确保当 fd 就绪时，内核只唤醒多个等待线程中的一个（而不是全部唤醒）：
ev.events = EPOLLIN | EPOLLET | EPOLLEXCLUSIVE;
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
// 只有在新事件到达时，内核才唤醒一个 epoll_wait 的线程
// 适用场景：SO_REUSEPORT 下多 worker 共享 listen fd5.2 SO_REUSEPORT 替代方案
Nginx 从 1.9.1 开始支持 SO_REUSEPORT，允许每个 worker 进程独立创建 listen socket，由内核通过四元组哈希将新连接分发到特定 worker。结合 EPOLLEXCLUSIVE 可以避免惊群同时实现连接均衡。
六、生产级 epoll 服务器架构
6.1 连接管理结构
#define MAX_EVENTS 4096
#define MAX_CONNECTIONS 100000
typedef struct {
int fd;
uint32_t events;
buffer_t read_buf;
buffer_t write_buf;
time_t last_active;
uint32_t state;
size_t parse_offset;
bool parse_complete;
http_request_t request;
http_response_t response;
} connection_t;
typedef struct {
int epfd;
int listen_fd;
connection_t *connections[MAX_CONNECTIONS];
struct epoll_event events[MAX_EVENTS];
} reactor_t;6.2 EPOLLRDHUP：半关闭检测
TCP 半关闭是应用中极为常见的场景，不处理 EPOLLRDHUP 会导致对端已关闭写端，本端仍继续写入触发 RST，或 epoll 持续返回可读的 EOF 空转。
// 注册时添加 EPOLLRDHUP：
ev.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
// 事件处理：
if (ev->events & EPOLLRDHUP) {
// 对端关闭了写方向（发送了 FIN）
if (conn->state == STATE_SENDING_RESPONSE && !buffer_empty(&conn->write_buf)) {
shutdown(conn->fd, SHUT_RD); // 标记本地不再读，等响应发完
} else {
close_connection(reactor, conn);
}
}七、epoll 与 io_uring 的协同：混合事件模型
在实际生产中，许多服务器需要同时处理"网络 fd 的事件通知"和"磁盘 I/O 的异步完成"。推荐的混合架构是：
int epfd = epoll_create1(EPOLL_CLOEXEC);
struct io_uring ring;
io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
// 将 io_uring 的完成事件 fd 注册到 epoll
struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;
ev.data.ptr = &uring_context;
epoll_ctl(epfd, EPOLL_CTL_ADD, ring.ring_fd, &ev);
// 主循环统一等待两种事件源
while (running) {
int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.ptr == &uring_context) {
handle_uring_completions(&ring); // io_uring 完成事件
} else {
handle_network_event(events[i]); // 网络 fd 事件
}
}
}这种混合模型的优势：网络层用 epoll 的 O(1) 事件通知，磁盘 I/O 通过 io_uring 实现真正的异步零拷贝，中断机制统一无需额外线程切换。
八、生产级调优清单
8.1 内核参数
# /etc/sysctl.conf — epoll 高并发场景核心参数
fs.file-max = 2097152
fs.nr_open = 1048576
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.core.netdev_max_backlog = 65535
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_moderate_rcvbuf = 1
net.netfilter.nf_conntrack_max = 10485768.2 常见编程错误
- 边缘触发下未读尽数据 — 数据丢失，后续不再通知。正确：循环 read 到 EAGAIN
- 阻塞 fd + 边缘触发 — read 阻塞整个事件循环。正确：所有 epoll fd 必须 O_NONBLOCK
- 忽略 EPOLLERR/EPOLLHUP — 事件循环空转 CPU 100%。正确：先处理错误事件并关闭 fd
- 读取到 EAGAIN 后未重新 MOD — ONESHOT 后 fd 永久失活。正确：I/O 完成后重新 MOD ALL 事件
- EPOLLOUT 初始注册 — 水平触发下 CPU 空转。正确：仅在 write EAGAIN 后注册
- 未处理 errno=EINTR — 事件循环意外退出。正确：遇到 EINTR 继续 epoll_wait
九、从 epoll 到 io_uring：AIO 的进化
epoll 的本质是"I/O 就绪通知"——它告诉你"这个 fd 可以读/写了"，但实际 read/write 仍是同步的。io_uring 的本质是"I/O 提交与完成"——异步提交请求，完成后异步通知。
两种技术的适用场景分化：
- epoll 主宰网络 I/O — 网络 fd 的就绪通知效率极高，Reactor 模式已足够高效
- io_uring 擅长文件 I/O — 唯一能提供真正异步文件 I/O 的机制
- 混合模型 — epoll 管理网络就绪 + io_uring 管理异步文件 I/O
从内核版本演化的角度看，io_uring 一直在整合 epoll 功能。IORING_OP_POLL_ADD 可通过 io_uring 异步执行 epoll_wait，IORING_OP_EPOLL_CTL (Linux 5.19+) 可直接通过 io_uring 操作 epoll。这意味着未来可能完全以 io_uring 替代 epoll。
总结
epoll 在 Linux 2.5.44 引入（2002 年），历经二十多年仍是高性能网络编程的基石。理解 epoll 的核心不仅是掌握 API，更是理解其内核实现——红黑树管理 fd 的生命周期，就绪链表管理事件流，回调机制实现零等待通知。掌握这一完整模型，才能写出真正生产级的高并发服务器：边缘触发 + 非阻塞 + EPOLLONESHOT 线程安全 + EPOLLRDHUP 半关闭检测 + SO_REUSEPORT 负载均衡，构建出可承载百万级并发连接的稳定系统。
发表评论 取消回复