epoll 不是“更快的 select”。它换了一套组织方式:fd 只在 epoll_ctl 时注册一次,内核为每个注册项挂一个回调;状态变化时回调把该项塞进就绪链表;epoll_wait 只检查链表,不再遍历全部 fd。

#include <sys/epoll.h>
 
int epoll_create(int size);
int epoll_create1(int flags);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

三个调用各管一段

epoll_create 创建一个 epoll 实例,返回句柄 fd。size 从 Linux 2.6.8 起被忽略,但必须传一个大于 0 的值,否则返回 EINVAL。用完要 close。新代码一般用 epoll_create1(EPOLL_CLOEXEC),免得这个 fd 泄漏到 exec 出来的子进程。

epoll_ctl 是注册函数,op 有三种:

  • EPOLL_CTL_ADD:把 fd 和关心的事件加进 epoll 实例。
  • EPOLL_CTL_MOD:修改已注册 fd 的事件。
  • EPOLL_CTL_DEL:把 fd 从实例里摘掉。它不关闭 fd,该 close 的还要自己 close。

epoll_wait 收集就绪事件。events 是调用方分配好的数组,内核只往里面写,不会替你分配内存。maxevents 是数组容量,必须大于 0;它和 epoll_create 的 size 没有关系。课件写“maxevents 的值不能大于创建 epoll_create 时的 size”,这是 2.5 时代 size 还有意义时的残留说法;从 2.6.8 起 size 被忽略,maxevents 只要求大于 0,想传 1000 而 size 传 10 完全合法。timeout 单位毫秒,0 立即返回,-1 永久阻塞。返回值是本次写进数组的事件个数,0 表示超时,小于 0 表示出错。

eventpoll:一棵树加一条链

调用 epoll_create 时,内核创建一个 struct eventpoll。它有很多内部字段,和这一节直接相关的是这两个:

struct eventpoll {
    struct rb_root  rbr;      /* 红黑树根,存放所有注册项 */
    struct list_head rdlist;  /* 就绪链表,存放已就绪、等待返回的项 */
};

上面是只保留相关成员的摘录,真实结构还包含锁、等待队列等字段。每注册一个 fd,内核建一个 struct epitem。这个结构同时挂在两个地方:

struct epitem {
    struct rb_node   rbn;      /* 红黑树节点 */
    struct list_head rdllink;  /* 就绪链表节点 */
    struct epoll_filefd ffd;   /* 文件与 fd 信息 */
    struct eventpoll *ep;      /* 所属的 eventpoll */
    struct epoll_event event;  /* 关心的事件 */
};

红黑树与就绪链表共用 epitem:树里的节点通过 rbn 组织,同一个 epitem 通过 rdllink 挂进 eventpoll 的 rdllist;图右侧标出了 eventpoll 的 rbr、rdllist 和 epitem 的对应成员

树负责“找得到、不重复”:同一个 fd 重复 ADD 会被 EEXIST 拒绝,查找和插入是 O(log n),n 是注册项总数。课件写“插入时间效率是 lgn,其中 n 为树的高度”,这里把 n 说错了:树高是 O(log n),不是 n;红黑树的节点总数才是那个 n。链表负责“就绪的排队”:一个 epitem 从树里被找到后,通过 rdllink 挂到 rdllist。

真正把事件塞进链表的不是 epoll_wait,是回调。EPOLL_CTL_ADD 时,内核通过 ep_ptable_queue_proc 为目标文件建一个 eppoll_entry,里面包含一个 wait_queue_t 项、指回 epitem 的 base 和等待队列头 whead;这个等待项的 func 被设成 ep_poll_callback,然后 add_wait_queue 挂到 socket 的等待队列上。网卡收数据、协议栈把数据放进接收队列后,sock_def_readable 调用 wake_up_interruptible,__wake_up_common 遍历等待队列并执行 ep_poll_callback,后者执行 list_add_tail(&epi->rdllink, &ep->rdllist)。epoll_wait 醒来只看 rdllist 空不空。

这条链上有两个容易忽略的点。eppoll_entry 是“挂在文件等待队列上的那一个等待项”,epitem 是“注册在 epoll 里的那一个监视项”,两者通过 base 关联;一个 fd 被多个 epoll 实例监视时,每个实例都有自己的 epitem 和 eppoll_entry。回调执行时拿的是 epitem,所以它知道该往哪个 eventpoll 的 rdllist 里加。

所以复杂度要分开说:

操作复杂度
epoll_ctl 增删改O(log n),n 是注册项总数
检查有没有就绪项O(1),只看链表头
把就绪项拷进用户数组O(k),k 是本次就绪数

“epoll 是 O(1)”指的是等待这一步与总连接数无关,不是整个 API 都 O(1)。连接很多、活跃很少时,这个差别才明显;三五个固定连接,epoll 和 poll 的差距可以忽略。

事件位:有些能申请,有些只能收

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;    /* 用户数据,内核原样带回 */
};

epoll_event 的定义:events 是 32 位位图,data 是四选一的联合体;实际工程里常用 data.fd 记录 fd,或用 data.ptr 指向连接对象

可以写进 events 的位:

位含义
EPOLLIN可读
EPOLLOUT可写
EPOLLPRI有紧急数据可读
EPOLLRDHUP对端关闭了写方向(需显式申请)
EPOLLET边缘触发模式
EPOLLONESHOT只触发一次,之后需重新武装
EPOLLEXCLUSIVE多个 epoll 实例监视同一 fd 时只唤醒一个

EPOLLERR 和 EPOLLHUP 不需要申请。只要 fd 出错或挂断,它们一定会出现在返回的 events 里。这一点和 poll 的 POLLERR/POLLHUP/POLLNVAL 一样:

poll 事件表的下半部分:POLLRDNORM、POLLWRBAND 等可作为请求;POLLERR、POLLHUP、POLLNVAL 在“能否作为 events 传入”一列标为“否”,在“是否可能出现在 revents”一列标为“是”

因此判断事件必须按位与:

if (evs[i].events & EPOLLIN)  { /* 可读 */ }
if (evs[i].events & EPOLLERR) { /* 出错 */ }

写成 evs[i].events == EPOLLIN,遇到 EPOLLIN | EPOLLRDHUP 或 EPOLLIN | EPOLLHUP 就会漏判。对端正常关闭恰好走这条组合。

mmap 的说法是错的

网上常见的说法是:epoll 用 mmap 把内核的就绪队列映射到用户态,因此省掉了数据拷贝。这个说法不成立。struct epoll_event 数组是调用方在用户空间自己分配的,内核必须把就绪项从内核内存拷进这个数组,epoll_wait 的返回值只是拷了多少个。课件在这一点上的判断是对的:没有 mmap 映射就绪队列这回事。

epoll 省下的是“每轮把全部 fd 从用户态拷进内核、再全部扫一遍”,不是“把结果拷回用户态”这一步。只要结果要出现在用户数组里,这次拷贝就省不掉。

LT 与 ET:区别在“沿”还是“电平”

先把场景摆出来:socket 的接收缓冲区里来了 2 KB 数据,epoll_wait 返回可读;程序只 read 了 1 KB,还剩 1 KB。

LT(水平触发,level-triggered)是默认模式。只要缓冲区里还有数据,下一次 epoll_wait 仍然会立刻返回并报告可读。直到数据被读空,它才不再提醒。LT 允许你每次只处理一部分,剩下的下次再说;阻塞和非阻塞 fd 都能用。

ET(边缘触发,edge-triggered)只在状态发生跳变时提醒。数据从无到有,是一次沿;读到一半不读了,缓冲区里剩下的数据不会产生新的沿,下一次 epoll_wait 不会因为它返回。只有又来了新数据,或者状态再次变化,才会再提醒。

课件那句“ET 模式下,文件描述符上的事件就绪后,只有一次处理机会”,容易被读成“这个 fd 一辈子只通知一次”。准确的说法是:同一次状态变化只通知一次。fd 再次发生状态跳变,还会通知。

请求—应答的闭环:客户端发出请求后等服务器应答,收到应答才发下一个请求;服务器若只读了 1 KB 就回去等,剩下的 9 KB 不会产生新的事件沿

这张图解释的是 ET 下最常见的死锁。客户端发 10 KB,服务器只读 1 KB,剩 9 KB 在缓冲区;客户端等响应才发下一批,服务器等下一批数据才继续读。双方都没错,但事件不会再来了。

同一个场景的双方视角:服务器框里写着“10k 请求,只读了 1k,剩下 9k 在缓冲区中”,客户端框下写着“要把 10k 数据都读完、发出响应,才能发下一个数据”

ET 为什么必须配非阻塞

接口不强制 ET 配非阻塞。内核不会因为 fd 是阻塞的就把 EPOLLET 拒掉。逼你非阻塞的是“读到没有为止”这件事需要退出条件。

ET 要求一次把缓冲区读干净,代码就得循环 read。如果 fd 是阻塞的,循环到缓冲区空的那一次 read 不会返回 EAGAIN,而是把线程挂起,整条事件循环被这一条连接拖住。只有非阻塞 fd 才会在没数据时立刻返回 EAGAIN/EWOULDBLOCK,给循环一个安全的出口。

正确的读循环是:

for (;;) {
    ssize_t n = recv(fd, buf, sizeof(buf), 0);
    if (n > 0) {
        /* 处理这一段数据,继续读 */
        continue;
    }
    if (n == 0) {
        /* 对端关闭 */
        break;
    }
    if (errno == EINTR)
        continue;
    if (errno == EAGAIN || errno == EWOULDBLOCK)
        break;              /* 读干净了,回去等事件 */
    /* 真正的错误 */
    break;
}

课件 ET 版里的 RecvNoBlock 在 EAGAIN 时执行 continue,这会把“读干净了”变成死循环:缓冲区已经空,下一次 recv 还是 EAGAIN,循环永远出不来。SendNoBlock 在 EAGAIN 时同样 continue,也是忙等。两处都应当 break,把控制权还给事件循环。写方向 EAGAIN 表示发送缓冲区满了,数据不能丢,要留在用户态发送缓冲区里,等 EPOLLOUT 再续发。

ET 的写侧比读侧麻烦。send 不保证一次发完,EAGAIN 之后剩余数据必须自己存着,并临时注册 EPOLLOUT;发空后立刻用 EPOLL_CTL_MOD 摘掉写事件。只做 echo 的 demo 可以不写这层,真实服务器早晚要补。

LT 没有这些问题:读不完下次还会被提醒,写不完下次也还会被提醒。ET 减少的是“没读完导致的重复通知”,不是凭空加速。如果 LT 版代码本来就每次读干净,两者的唤醒次数差不多。

ONESHOT、EXCLUSIVE 与惊群

EPOLLONESHOT 让一个 fd 触发一次后自动失效,之后必须用 EPOLL_CTL_MOD 重新武装。课件写“需要再次把这个 socket 加入到 EPOLL 红黑树里”,方向对但动作不对:fd 还在树上,只是事件被禁用了,重新 ADD 会得到 EEXIST,要用 MOD 覆盖事件位。它解决的是多线程处理同一条连接的问题:一个线程被唤醒后开始读,其他线程不该再被同一个 fd 叫醒。处理完、缓冲区状态重新安排好,再武装一次。

EPOLLEXCLUSIVE 从 Linux 4.5 起可用,用在 EPOLL_CTL_ADD 上,让多个 epoll 实例监视同一个 fd 时,内核只唤醒其中一个等待者。它针对的是监听 fd 的惊群:多个进程或线程各自 accept,新连接到来时全被叫醒,只有一个能成功。EPOLLEXCLUSIVE 不能用在 EPOLL_CTL_MOD,也不能和 EPOLLONESHOT 一起用。它只是减少无效唤醒,不保证绝对公平,也不解决同一 epoll 实例内多个线程并发 accept 的竞争。

一份能跑的 LT 服务器

#define _GNU_SOURCE
 
/* epoll_lt_echo.c
 * 编译:gcc -std=c11 -Wall -Wextra epoll_lt_echo.c -o epoll_lt_echo
 * 运行:./epoll_lt_echo,然后 nc 127.0.0.1 8888
 */
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
 
#define MAX_EVENTS 64
 
static int set_nonblock(int fd)
{
    int fl = fcntl(fd, F_GETFL);
    if (fl < 0)
        return -1;
    return fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}
 
static void close_conn(int epfd, int fd)
{
    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);  /* 只摘掉关心,不关闭 fd */
    close(fd);
}
 
int main(void)
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd < 0) {
        perror("socket");
        return 1;
    }
 
    int yes = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
 
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(lfd);
        return 1;
    }
    if (listen(lfd, 128) < 0) {
        perror("listen");
        close(lfd);
        return 1;
    }
 
    if (set_nonblock(lfd) < 0) {
        perror("fcntl");
        close(lfd);
        return 1;
    }
 
    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd < 0) {
        perror("epoll_create1");
        close(lfd);
        return 1;
    }
 
    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.events = EPOLLIN;
    ev.data.fd = lfd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev) < 0) {
        perror("epoll_ctl ADD listen");
        close(epfd);
        close(lfd);
        return 1;
    }
 
    struct epoll_event evs[MAX_EVENTS];
 
    for (;;) {
        int n = epoll_wait(epfd, evs, MAX_EVENTS, -1);
        if (n < 0) {
            if (errno == EINTR)
                continue;
            perror("epoll_wait");
            break;
        }
 
        for (int i = 0; i < n; ++i) {
            int fd = evs[i].data.fd;
            uint32_t events = evs[i].events;
 
            if (fd == lfd) {
                for (;;) {
                    int cfd = accept(lfd, NULL, NULL);
                    if (cfd < 0) {
                        if (errno == EAGAIN || errno == EWOULDBLOCK)
                            break;       /* 连接已经接完 */
                        if (errno == EINTR)
                            continue;
                        perror("accept");
                        break;
                    }
 
                    memset(&ev, 0, sizeof(ev));
                    ev.events = EPOLLIN;
                    ev.data.fd = cfd;
                    if (epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev) < 0) {
                        perror("epoll_ctl ADD client");
                        close(cfd);
                    }
                }
                continue;
            }
 
            if (events & EPOLLIN) {
                char buf[4096];
                ssize_t r = read(fd, buf, sizeof(buf));
                if (r <= 0) {
                    close_conn(epfd, fd);
                    continue;
                }
 
                ssize_t sent = 0;
                while (sent < r) {
                    ssize_t w = write(fd, buf + sent, (size_t)(r - sent));
                    if (w <= 0)
                        break;
                    sent += w;
                }
                continue;
            }
 
            if (events & (EPOLLERR | EPOLLHUP)) {
                close_conn(epfd, fd);
            }
        }
    }
 
    close(epfd);
    close(lfd);
    return 0;
}

LT 版读一次就够:缓冲区里还有数据,下一次 epoll_wait 还会报可读。改成 ET 要做三件事:注册时 events 换成 EPOLLIN | EPOLLET;新连接 set_nonblock;把“读一次”换成上面那个读到 EAGAIN 的循环。监听 fd 若也用 ET,accept 必须循环到 EAGAIN,否则同时来一批连接时只能接一个,剩下的要等下一次状态跳变。

什么样的连接结构值得上 epoll

epoll 的收益来自“注册项很多、活跃项很少”。上万条客户端连接、任意时刻只有一部分在收发,这种入口服务适合 epoll。系统内部几台机器之间的固定长连接,总共三五个 fd,用 epoll 只是把代码写长,不会更快。

三者的账可以直接对照:

selectpollepoll
监视名单fd_set 位图,每次调用重建pollfd 数组,可长期保留epoll_ctl 注册一次
数量上限FD_SETSIZE,默认 1024受内存限制受 fd 上限和内存限制
每轮用户态到内核态拷三张位图拷整个数组不拷名单,只拷就绪事件
每轮扫描从 0 到 nfds - 1遍历全部元素只处理 rdllist 里的就绪项
返回内容就绪位,还要 FD_ISSET 判断revents,还要遍历判断就绪事件数组,直接按 data 分发
触发方式只有 LT只有 LTLT 和 ET

另一个误判是“ET 一定比 LT 快”。ET 省的是重复通知,前提是 LT 代码没有一次读干净。写法正确时,两者的系统调用次数接近;写法不正确时,ET 会把问题从“多绕一圈”变成“连接卡死”。LT 是更安全的默认值,只有确认需要减少通知次数时再换 ET。