epoll 是 Linux 内核提供的高效 IO 多路复用机制，专门用于处理高并发场景下的大量文件描述符（File Descriptor，简称 fd）。相比传统的 select/poll，epoll 避免了轮询遍历所有 fd 的性能开销，能更高效地处理数万甚至数十万并发连接（如 Nginx、Redis 等高性能服务器均采用 epoll）。

一、epoll 核心组件及关系

epoll 的工作依赖 3 个核心函数和 1 个关键数据结构，它们的关系可以概括为：通过 epoll_create 创建一个“监控中心”，通过 epoll_ctl 向中心注册要监控的 fd 和事件，通过 epoll_wait 从中心获取就绪的事件，而 epoll_event 是描述“事件”的“数据载体”。

1. 核心函数/类型解析

组件	作用
epoll_create	创建一个 epoll 实例（监控中心），返回一个 epoll 专用的 fd（类似“监控中心的编号”）。
epoll_ctl	向 epoll 实例添加/修改/删除需要监控的 fd 和事件（如“读事件”“写事件”）。
epoll_wait	等待 epoll 实例中监控的 fd 发生事件，返回所有就绪的事件（避免轮询所有 fd）。
struct epoll_event	描述“要监控的事件”或“已就绪的事件”，包含事件类型和关联的 fd 或自定义数据。

2. struct epoll_event 结构体（事件载体）

这个结构体是 epoll 传递事件信息的核心，定义如下：

struct epoll_event {
    uint32_t events;  // 事件类型（如 EPOLLIN 表示“可读”，EPOLLOUT 表示“可写”）
    epoll_data_t data; // 关联的数据（通常存 fd 或自定义指针）
};

// data 的定义（联合体，可存 fd 或指针）
typedef union epoll_data {
    void    *ptr;  // 自定义指针（如指向连接上下文）
    int      fd;   // 被监控的文件描述符（最常用）
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

• events：指定要监控的事件类型（如 EPOLLIN 表示“fd 有数据可读”）。
• data：关联的 fd 或自定义数据（方便事件发生时快速定位处理对象）。

3. 函数协作流程（核心关系）

epoll 的工作流程可分为 4 步，形成一个“注册-等待-处理”的循环：

1. 创建监控中心：用 epoll_create 创建 epoll 实例，得到一个 epoll_fd。
2. 注册监控目标：用 epoll_ctl 向 epoll_fd 中添加需要监控的 fd（如 socket fd），并指定要监控的事件（如“当这个 socket 有数据可读时通知我”）。
3. 等待事件发生：用 epoll_wait 阻塞等待，直到有 fd 发生了注册的事件（或超时）。
4. 处理就绪事件：epoll_wait 返回所有就绪的事件（存在 epoll_event 数组中），程序遍历数组处理事件（如读取数据、发送响应），然后回到步骤 3 继续等待。

二、核心函数详解

1. epoll_create：创建监控中心

#include <sys/epoll.h>
int epoll_create(int size);  // 现代内核中 size 被忽略（仅需 >0 即可）

• 作用：创建一个 epoll 实例（内核维护的“监控中心”），用于管理后续注册的 fd 和事件。
• 返回值：成功返回一个 epoll 专用的 fd（epoll_fd）；失败返回 -1 并设置 errno。
• 说明：size 参数在 Linux 2.6.8 后被忽略（仅需传入一个大于 0 的值），内核会动态分配资源。

2. epoll_ctl：注册/修改/删除监控目标

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

• 参数：
  • epfd：epoll_create 返回的 epoll_fd（监控中心编号）。
  • op：操作类型（3 种）：
    • EPOLL_CTL_ADD：向监控中心添加一个要监控的 fd 和事件。
    • EPOLL_CTL_MOD：修改已注册的 fd 的监控事件。
    • EPOLL_CTL_DEL：从监控中心删除一个 fd（不再监控，此时 event 可为 NULL）。
  • fd：需要监控的文件描述符（如 socket fd）。
  • event：struct epoll_event 指针，描述要监控的事件（op 为 EPOLL_CTL_DEL 时可省略）。
• 返回值：成功返回 0；失败返回 -1 并设置 errno。

3. epoll_wait：等待就绪事件

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

• 参数：
  • epfd：epoll_fd（监控中心编号）。
  • events：输出参数（数组），用于存放“已就绪的事件”（由内核填充）。
  • maxevents：events 数组的最大长度（必须 >0）。
  • timeout：超时时间（毫秒）：
    • timeout = -1：永久阻塞，直到有事件发生。
    • timeout = 0：立即返回（非阻塞）。
    • timeout > 0：最多等待 timeout 毫秒，超时后返回 0。
• 返回值：
  • 成功：返回就绪事件的数量（n，0 ≤ n ≤ maxevents）。
  • 失败：返回 -1 并设置 errno（如被信号中断）。

三、epoll 的两种工作模式（关键特性）

epoll 有两种事件触发模式，决定了“事件就绪后如何通知程序”，这是 epoll 灵活性的核心：

1. 水平触发（Level Trigger，LT）—— 默认模式

• 触发逻辑：只要 fd 处于“就绪状态”（如缓冲区有数据未读），epoll_wait 就会一直返回该事件。
• 特点：即使不立即处理事件，下次调用 epoll_wait 仍会再次通知，容错性高（类似 select/poll 的行为）。
• 适用场景：大部分场景（尤其是新手），避免因漏处理导致数据丢失。

2. 边缘触发（Edge Trigger，ET）—— 高效模式

• 触发逻辑：仅在 fd 从“未就绪”变为“就绪”的瞬间触发一次事件（如缓冲区从空变为有数据时）。
• 特点：事件只通知一次，必须一次性处理完所有数据（否则可能漏数据），但减少了通知次数，效率更高。
• 适用场景：高并发、对性能要求极高的场景（如 Nginx），需配合非阻塞 IO 使用（避免一次读不完数据）。

如何设置模式：在 epoll_event.events 中添加 EPOLLET 标志即为 ET 模式（默认 LT 模式）：

struct epoll_event ev;
ev.events = EPOLLIN | EPOLLET;  // 读事件 + 边缘触发
ev.data.fd = sockfd;

四、epoll 优势（对比 select/poll）

特性	select/poll	epoll
性能	随 fd 数量增加而下降（轮询）	几乎不随 fd 数量变化（事件驱动）
最大 fd 限制	受系统限制（如 select 最多 1024）	无上限（仅受系统内存限制）
事件返回	返回所有监控的 fd，需自己判断就绪	直接返回就绪的 fd，无需遍历
触发模式	仅支持水平触发	支持水平触发（LT）和边缘触发（ET）

五、使用场景

epoll 适合高并发、大量连接但活跃连接少的场景（“长连接”场景尤为高效）：

• 网络服务器：Web 服务器（Nginx）、即时通讯服务器（如聊天软件后端）、游戏服务器。
• 高性能中间件：Redis、消息队列（如 Kafka 部分模块）。
• 需要同时监控多个 IO 源的场景：如同时处理 socket、管道（pipe）、文件等多种 fd。

六、mermaid 模型：epoll 工作流程与组件关系

模型说明：

• 内核通过“红黑树”高效管理所有注册的 fd（支持快速添加/删除/修改）。
• 当 fd 发生事件时，内核将其加入“就绪列表”，epoll_wait 直接从就绪列表获取结果（无需遍历所有 fd）。
• epoll_event 是连接用户程序和内核的“数据载体”，既用于注册事件，也用于返回就绪事件。

七、简易代码示例（epoll 服务器框架）

#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_EVENTS 1024  // 最大就绪事件数
#define PORT 8080

int main() {
    // 1. 创建监听 socket
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = INADDR_ANY;
    bind(listen_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(listen_fd, 10);

    // 2. 创建 epoll 实例（监控中心）
    int epoll_fd = epoll_create(1);  // size 忽略，传 1 即可

    // 3. 向 epoll 注册监听 socket 的“读事件”（有新连接时触发）
    struct epoll_event ev;
    ev.events = EPOLLIN;  // 水平触发（默认），监控读事件
    ev.data.fd = listen_fd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev);

    struct epoll_event events[MAX_EVENTS];  // 存放就绪事件

    while (1) {
        // 4. 等待事件发生（永久阻塞，直到有事件）
        int n = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        for (int i = 0; i < n; i++) {
            // 5. 处理就绪事件
            if (events[i].data.fd == listen_fd) {
                // 监听 socket 有新连接
                int client_fd = accept(listen_fd, NULL, NULL);
                // 注册客户端 socket 的“读事件”（有数据时触发）
                ev.events = EPOLLIN | EPOLLET;  // 边缘触发
                ev.data.fd = client_fd;
                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
            } else {
                // 客户端 socket 有数据可读
                char buf[1024];
                ssize_t len = read(events[i].data.fd, buf, sizeof(buf));
                if (len <= 0) {
                    // 连接关闭或出错，移除监控
                    close(events[i].data.fd);
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                } else {
                    // 处理数据（如回声）
                    write(events[i].data.fd, buf, len);
                }
            }
        }
    }

    close(epoll_fd);
    close(listen_fd);
    return 0;
}

总结

epoll 通过“监控中心（epoll 实例）+ 事件注册（epoll_ctl）+ 就绪等待（epoll_wait）”的机制，实现了高效的 IO 多路复用。其核心优势在于事件驱动而非轮询，能轻松应对高并发场景。理解 epoll_event 的作用和两种触发模式，是用好 epoll 的关键。