深入理解 Linux epoll：高性能 I/O 事件处理机制实战

1. 检查 rdllist 是否为空
2. 如果有就绪事件，从链表中取出并拷贝到用户态 events 数组（无需遍历红黑树）
3. 如果 rdllist 为空且 timeout != 0，将自己加入等待队列，进入睡眠
4. 当有 fd 就绪触发回调后，ep_poll_callback 唤醒等待队列上的进程

4. 工作模式：LT vs ET

4.1 水平触发 (Level-Triggered, LT)

LT 模式是 默认模式。当 fd 处于就绪状态时，epoll_wait 会 持续通知 你，直到该 fd 上的事件被完全处理。

特点：

• 编程简单，不易出错
• 不需要一次性读完所有未处理数据
• 如果数据未处理完，内核会持续通知，产生大量重复事件通知

典型代码：

// LT 模式：不需要循环读取
if (events[i].events & EPOLLIN) {
    // 只读一次，下次 epoll_wait 还会通知你
    n = read(fd, buf, sizeof(buf));
    // 如果数据没读完，epoll_wait 返回时会再次通知
}

4.2 边缘触发 (Edge-Triggered, ET)

ET 模式需要设置 EPOLLET 标志。只有当 fd 状态 从未就绪变为就绪 的瞬间，才会通知一次。

特点：

• 事件只在状态变化时通知一次
• 必须循环 read/write 直到返回 EAGAIN/EWOULDBLOCK
• 必须使用非阻塞 I/O（否则会阻塞在 read/write 上）
• 事件通知次数大幅减少，性能更高

典型代码：

// ET 模式：必须循环读取直到 EAGAIN
if (events[i].events & EPOLLIN) {
    while (1) {
        n = read(fd, buf, sizeof(buf));
        if (n > 0) {
            // 处理数据
            process_data(buf, n);
        } else if (n == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                // 数据已全部读完
                break;
            }
            // 真实错误
            break;
        } else {
            // n == 0，对端关闭连接
            close(fd);
            break;
        }
    }
}

4.3 LT vs ET 性能对比

5. Reactor 模式架构

epoll 通常与 Reactor 模式 配合使用，其核心思想是：将 I/O 事件分发与业务处理解耦。

5.1 架构组成

┌─────────────────────────────────────────┐
│              Reactor 核心                │
├─────────────────────────────────────────┤
│  ┌─────────────┐    ┌──────────────┐    │
│  │ Dispatcher  │───▶│  Event Loop  │    │
│  │(epoll_wait) │    │              │    │
│  └──────┬──────┘    └──────────────┘    │
│         │ 分离 I/O 事件                   │
│         ▼                                │
│  ┌─────────────┐    ┌──────────────┐    │
│  │ Event Handler│   │   Acceptor   │    │
│  │ (读写处理)   │    │ (新连接处理) │    │
│  └─────────────┘    └──────────────┘    │
└─────────────────────────────────────────┘

5.2 完整 Reactor 模式代码

#include <sys/epoll.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define MAX_EVENTS 1024
#define BUFFER_SIZE 4096
#define PORT 8080

// 设置非阻塞 fd
static int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

// 添加 fd 到 epoll（ET 模式，一次性注册 EPOLLIN | EPOLLET）
static void epoll_add(int epfd, int fd, uint32_t events) {
    struct epoll_event ev;
    ev.events = events | EPOLLET;  // 边缘触发
    ev.data.fd = fd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
    set_nonblocking(fd);
}

// 修改 fd 监听事件（用于写就绪后再监听可读）
static void epoll_mod(int epfd, int fd, uint32_t events) {
    struct epoll_event ev;
    ev.events = events | EPOLLET;
    ev.data.fd = fd;
    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
}

// 处理新的客户端连接
static void handle_accept(int epfd, int listen_fd) {
    while (1) {
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        int client_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_len);
        
        if (client_fd == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                // 所有新连接已处理完毕
                break;
            }
            perror("accept");
            break;
        }
        
        // 将客户端 fd 加入 epoll，监听可读 + 边缘触发
        epoll_add(epfd, client_fd, EPOLLIN);
        printf("新连接: fd=%d\n", client_fd);
    }
}

// ET 模式下循环读取所有数据
static void handle_read(int epfd, int fd) {
    char buffer[BUFFER_SIZE];
    while (1) {
        ssize_t count = read(fd, buffer, sizeof(buffer));
        
        if (count == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                // 全部数据已读取完毕
                break;
            }
            // 真实错误
            perror("read");
            epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
            close(fd);
            return;
        } else if (count == 0) {
            // 对端关闭连接
            printf("连接关闭: fd=%d\n", fd);
            epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
            close(fd);
            return;
        }
        
        // 处理接收到的数据
        printf("fd=%d 收到 %zd 字节数据\n", fd, count);
        
        // 切换为监听可写，准备回写响应
        // echo 服务器：将收到的数据写回去
        write(fd, buffer, count);
    }
}

// 主事件循环
static void event_loop(int listen_fd) {
    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }
    
    // 将监听 socket 加入 epoll（LT 模式更适合 listen_fd）
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = listen_fd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);
    
    struct epoll_event events[MAX_EVENTS];
    
    while (1) {
        int nready = epoll_wait(epfd, events, MAX_EVENTS, -1);
        
        for (int i = 0; i < nready; i++) {
            int fd = events[i].data.fd;
            
            if (events[i].events & (EPOLLERR | EPOLLHUP)) {
                // 错误或挂起
                perror("epoll error");
                epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                close(fd);
                continue;
            }
            
            if (fd == listen_fd) {
                // 监听 socket 可读 = 有新连接
                handle_accept(epfd, listen_fd);
            } else {
                // 客户端 socket 可读
                handle_read(epfd, fd);
            }
        }
    }
    
    close(epfd);
}

int main() {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port = htons(PORT)
    };
    
    bind(listen_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(listen_fd, SOMAXCONN);
    set_nonblocking(listen_fd);
    
    printf("服务器启动，监听端口 %d\n", PORT);
    event_loop(listen_fd);
    
    return 0;
}

6. 综合对比：epoll vs select vs poll

7. 常见问题与陷阱

7.1 为什么 listen_fd 通常用 LT 模式？

listen_fd 使用 ET 模式时，如果一次 accept 没有处理完所有连接（比如 3 个客户端同时连接，但只 accept 了 1 个），那么剩下的 2 个连接就不会再被通知，直到下一次新的连接到来才会触发一次事件。使用 LT 可以确保所有新连接都被正确处理。

7.2 EPOLLOUT 事件何时触发？

EPOLLOUT（可写事件）在以下情况触发：

• fd 的发送缓冲区有空闲空间时（大部分 socket 一直是可写的，所以 EPOLLOUT 经常是"就绪"状态）
• 策略：不要一开始就注册 EPOLLOUT，而是在 write 返回 EAGAIN（缓冲区已满）时才注册 EPOLLOUT，发送完毕后再取消注册

7.3 多线程 epoll 方案

在高并发场景下，单线程事件循环可能无法充分利用多核 CPU，常见架构：

• 每个线程一个 epoll 实例：每个线程独立处理 I/O 事件（Reactor 多线程）
• SO_REUSEPORT：多个线程可以同时 bind 同一端口，内核负责将连接分配到不同线程（Linux 3.9+）
• 主从 Reactor：主线程只处理 accept，通过 Round-Robin 将连接分发给从线程的 epoll 实例

// SO_REUSEPORT 示例：每个线程独立 listen
void *worker_thread(void *arg) {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    
    // 同一端口，多个线程同时 bind
    bind(listen_fd, ...);
    listen(listen_fd, SOMAXCONN);
    
    int epfd = epoll_create1(EPOLL_CLOEXEC);
    epoll_add(epfd, listen_fd, EPOLLIN);
    
    // 每个线程独立的事件循环
    event_loop(epfd);
    return NULL;
}

7.4 epoll 惊群问题 (Thundering Herd)

如果多个线程共享同一个 epoll 实例，一个 fd 就绪时所有阻塞在 epoll_wait 上的线程都会被唤醒，但只有一个能处理该事件。这就是"epoll 惊群"问题。

解决方案：

• 使用 EPOLLEXCLUSIVE 标志（Linux 4.5+）：每个 fd 只唤醒一个 epoll_wait 线程
• 采用每个线程独立 epoll 实例的架构，从根本上避免

8. 性能基准测试

以下是一组简单的性能对比数据（环境：8 核 CPU，10K 并发连接，echo 服务）：

epoll ET 模式相比 select 提升了约 10 倍吞吐量，延迟降低 47 倍。

9. 最佳实践总结

1. listen_fd 使用 LT 模式：避免漏掉新连接
2. 数据 fd 优先使用 ET 模式：减少系统调用，提升吞吐量
3. ET 模式必须配合非阻塞 I/O：否则可能在 read/write 上阻塞
4. ET 模式必须循环读写直到 EAGAIN：确保处理完所有就绪数据
5. EPOLLOUT 按需注册：只在 write 返回 EAGAIN 时才监听可写事件
6. 设置 SO_REUSEPORT：多线程方案下让内核均衡分摊连接
7. 设置 maxevents 合理值：通常设为与预期并发数匹配（如 1024 或 4096）
8. 使用 EPOLLRDHUP 替代 EPOLLIN 检测对端关闭：避免额外 read 调用
9. 复用 epoll 实例：不要为每个连接创建独立的 epoll 实例
10. 关注缓冲区大小：合理设置 SO_RCVBUF/SO_SNDBUF 避免频繁事件通知

总结

epoll 通过红黑树管理 fd、通过就绪链表实现 O(1) 事件发现、通过回调机制代替遍历，从根本上解决了 select/poll 的性能问题。配合 ET 非阻塞 I/O 和多线程 Reactor 架构，epoll 可以轻松应对 C100K 甚至 C1M 级别的并发连接。

理解 epoll 不仅是掌握一个 API 调用，更是理解现代高性能网络编程的基石——事件驱动、非阻塞 I/O、边缘触发三位一体的设计哲学。