图解 epoll：从 select 到 epoll，一篇讲透 Linux 高性能 I/O

首页

业界动态

热心网友

转载

2026-04-17

从 Select 到 Epoll：深入理解 Linux 高并发网络模型的核心演进

在服务器开发领域，有一个问题几乎成了面试官的“必考题”：“为什么 Nginx 能同时处理几万个并发连接？”

免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈

如果你的回答停留在“因为它用了 epoll”，那么下一个问题通常会接踵而至：“epoll 为什么比 select 和 poll 快？它的底层原理到底是什么？”

今天，我们就从“一个进程如何监视多个连接”这个根本问题出发，彻底梳理清楚从 select 到 poll，再到 epoll 的技术演化脉络，并深入内核，看看 epoll 究竟是如何实现高性能的。

一、问题的起点：一个进程，多个连接

想象一下，你的服务器需要同时处理 1000 个客户端连接，该怎么办？

1. 方案一：一连接一线程

客户端1 → 线程1
客户端2 → 线程2
...
客户端1000 → 线程1000

这个方案听起来直接，但问题非常明显：每个线程默认需要占用数 MB 的栈内存，1000 个线程光是内存开销就高达数 GB。更致命的是，线程上下文切换的开销会随着并发数上升而急剧增大，系统很快就会被调度拖垮。

2. 方案二：I/O 多路复用

于是，更聪明的方案出现了：只用一个线程，让它同时监视成百上千个文件描述符（fd）。哪个 fd 有数据到达，就去处理哪个。这就像是一个高效的“门卫”，只通知你有访客到来的具体房间号。

┌──────────┐
fd1 (conn1)  ──→    │          │
fd2 (conn2)  ──→    │  一个线程 │──→ 处理就绪的 fd
...          ──→    │          │
fd1000       ──→    └──────────┘
           “告诉我谁准备好了”

这就是 I/O 多路复用（I/O Multiplexing）的核心思想。Linux 为此提供了三种实现：select、poll 和 epoll。它们的演进史，就是一部解决性能瓶颈的奋斗史。

二、select：第一代，能用但很慢

1. 用法

fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(fd1, &read_fds);
FD_SET(fd2, &read_fds);
// 阻塞等待，直到有 fd 就绪
select(max_fd + 1, &read_fds, NULL, NULL, NULL);
// 遍历找出哪个 fd 就绪了
for (int i = 0; i <= max_fd; i++) {
    if (FD_ISSET(i, &read_fds)) {
        // 处理 fd i
    }
}

2. select 的三大硬伤

（1）fd 数量上限 1024
其底层使用的 fd_set 本质上是一个 1024 位的位图（bitmap），这意味着它最多只能监视 1024 个文件描述符。对于现代高并发应用来说，这个限制过于苛刻。

（2）每次都要把 fd 集合从用户空间拷贝到内核
每次调用 select，都需要将整个监视的 fd 集合从用户空间拷贝到内核空间。如果有 1000 个 fd，调用一万次，就意味着拷贝了一万次。大量的数据拷贝是性能杀手。

（3）内核返回后，需要遍历所有 fd 找出就绪的
这是最令人头疼的一点。select 返回后，它只告诉你“有 fd 就绪了”，但具体是哪些，需要应用程序自己遍历整个 fd 集合（从 0 到 max_fd）去检查。即使只有一个连接活跃，你也得遍历完所有 1000 个 fd 才能找到它，时间复杂度是 O(n)。

三、poll：改良版，但换汤不换药

poll 试图改进 select。它用 pollfd 结构体数组替代了固定的位图，从而解决了 1024 的数量限制。然而，核心的性能瓶颈依然存在。

struct pollfd fds[1000];
fds[0].fd = fd1;
fds[0].events = POLLIN;
// ...
poll(fds, 1000, -1);  // 每次还是要把 1000 个 fd 拷进内核
for (int i = 0; i < 1000; i++) {
    if (fds[i].revents & POLLIN) {
        // 还是要 O(n) 遍历
    }
}

所以，poll 和 select 相比，只是去掉了 fd 数量的天花板，但“每次全量拷贝”和“返回后全量遍历”这两个根本性问题，一个都没解决。

说了这么多 select/poll 的问题，我们用一张图来直观对比一下，然后再看 epoll 是怎么一一破解的：

右边那套红黑树 + 就绪链表的设计，就是 epoll 快的根本原因，下面展开讲。

四、epoll：第三代，真正的革命

Linux 2.6 内核引入的 epoll，可以说是对 I/O 多路复用模型的一次彻底革新。它的核心 API 非常简洁，只有三个函数。

// 1. 创建 epoll 实例，返回一个 epfd
int epfd = epoll_create1(0);
// 2. 注册/修改/删除要监视的 fd
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = client_fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);
// 3. 等待就绪事件，直接返回就绪的 fd 列表
struct epoll_event events[64];
int n = epoll_wait(epfd, events, 64, -1);
for (int i = 0; i < n; i++) {
    // events[i].data.fd 就是就绪的 fd，直接处理！
    handle(events[i].data.fd);
}

注意看，epoll_wait 的返回值 n 直接就是就绪 fd 的数量，而 events 数组里装的全是已经就绪的 fd。这意味着，应用程序拿到结果后，完全不需要遍历，可以直接处理。这才是效率的关键。

五、epoll 为什么快？内核原理

1. 原理一：红黑树存储，O(log n) 增删

epoll 在内核中使用一颗红黑树来维护所有需要监视的 fd。当你调用 epoll_ctl 添加一个 fd 时，它被插入红黑树；删除时，则从树中移除。红黑树保证了插入、删除、查找操作的时间复杂度都是 O(log n)，非常高效。

对比一下，select/poll 每次调用都要把全部 fd 列表重新传入内核，是 O(n) 的线性操作，并且伴随着大量的内存拷贝。

2. 原理二：就绪链表，O(1) 获取结果

除了红黑树，内核还维护一个双向链表，称为就绪链表（ready list）。当某个被监视的 fd 上有事件发生时（比如数据到达），网络驱动会通过一个回调函数（callback）迅速将这个 fd 对应的结构体加入到就绪链表中。

这样一来，当应用程序调用 epoll_wait 时，内核只需要检查这个就绪链表是否为空。如果不为空，就将链表中的项拷贝到用户空间，整个过程几乎是 O(1) 的复杂度。

3. 原理三：fd 注册一次，无需反复拷贝

通过 epoll_ctl 将 fd 添加到红黑树后，内核就持有了这个 fd 的引用。在后续的 epoll_wait 调用中，无需再传递整个 fd 集合，避免了 select/poll 那种每次调用都发生的用户态到内核态的数据拷贝。

把这三个原理画成内核结构图，一眼就能看清楚数据是怎么流动的：

整个过程，CPU 只在应用层处理业务逻辑，数据就绪的通知完全由内核通过回调机制驱动，实现了从“主动轮询”到“被动通知”的转变，这才是高性能的基石。

六、LT 模式 vs ET 模式

epoll 提供了两种工作模式，这是理解其行为差异和进行性能调优的关键，也是面试中的高频考点。

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

这是默认的工作模式。只要一个 fd 对应的读/写缓冲区还有数据可读/可写，那么每次调用 epoll_wait 时，它都会通知你。

// LT 模式（默认）
ev.events = EPOLLIN;  // 不加 EPOLLET

它的特点是安全，不容易漏掉事件。但如果你没有一次性把缓冲区数据读完或写完，它会在下一次 epoll_wait 时继续通知你，可能会造成不必要的唤醒。

2. 边缘触发（ET，Edge Triggered）

在这种模式下，只有当被监视的 fd 状态发生变化时（比如从无数据变为有数据），epoll 才会通知你一次。之后，无论缓冲区是否还有数据，都不会再通知，除非又有新的数据到来导致状态再次变化。

// ET 模式
ev.events = EPOLLIN | EPOLLET;

ET 模式的优点是通知次数少，性能更高。但代价是，应用程序必须保证在收到通知时，一次性将缓冲区内的数据全部读完（直到 read 返回 EAGAIN 错误），否则残留的数据将无法被后续的 epoll_wait 感知到，从而造成数据丢失。

两种模式的行为差异，用图来对比最直观：

因此，在 ET 模式下处理读事件的正确姿势，就是下面这段循环读到 EAGAIN 的标准写法——

// ET 模式下，必须循环读到 EAGAIN
while (1) {
    int n = read(fd, buf, sizeof(buf));
    if (n == -1 && errno == EAGAIN) break;  // 数据读完了
    if (n <= 0) break;  // 连接关闭或出错
    process(buf, n);
}

像 Nginx 这样的高性能服务器，就采用了 ET 模式，并配合非阻塞 I/O，将性能压榨到了极致。

七、三者终极对比

（此部分原文为标题，内容需根据上下文补充或保留为标题。为遵循指令“结构保全”，此处保留标题。）

八、epoll 实战：简易服务器骨架

理论讲完了，来看一个最简化的 epoll 服务器骨架代码，它清晰地展示了 Reactor 模式的核心。

int epfd = epoll_create1(0);
int listenfd = create_listen_socket(8080);  // 创建监听 socket

// 把 listenfd 加入 epoll
struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = listenfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

struct epoll_event events[1024];
while (1) {
    int n = epoll_wait(epfd, events, 1024, -1);
    for (int i = 0; i < n; i++) {
        int fd = events[i].data.fd;
        if (fd == listenfd) {
            // 新连接到来
            int connfd = accept(listenfd, NULL, NULL);
            set_nonblocking(connfd); // 通常设置为非阻塞
            ev.events = EPOLLIN | EPOLLET; // 使用ET模式
            ev.data.fd = connfd;
            epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
        } else {
            // 已有连接有数据
            handle_client(fd);
        }
    }
}

这就是现代高性能网络框架（如 Redis、Nginx）所采用的 Reactor 模式的核心骨架：一个事件循环（Event Loop）负责收集所有 I/O 事件，然后分发给对应的处理器（Handler）。

上面的代码骨架，对应的完整事件流转是这样的——这也是 Nginx、Redis 网络层的核心模型：