QuanZhou's Wiki
更新于

select、poll 与 epoll:一个线程怎样照看多个连接

~/ 分布式#网络#Linux#I/O 多路复用#epoll#RPC

系列入口:分布式阅读路径。前置:Socket 入门。下一篇:RPC 和远程调用。

在 RPC 入门里,笔记本向文件服务查询 report.txt 的大小。异步 RPC 允许程序发出请求后继续工作,响应到了,再处理结果。

但“响应到了,再处理”是谁做的?如果同时有一百个调用,难道要有一百个线程,分别守着一个响应?

这一讲从两个连接开始。我们先写出一个会等错地方的程序,再逐步改进它。最后回到 RPC,看看一次可读通知怎样变成一次调用的完成。

示例约定

只需要能读简单的 C++ 函数和循环。正文给出代码片段与执行结果,不要求先实现网络框架。

使用 C++17 写法,讨论普通流式 socket;select、poll 可用于 Linux、macOS 等系统,epoll 是 Linux 接口。片段省略头文件和连接建立,标明正常路径时不展开全部错误处理。完整示例在文末。

一条连接很好等,两条呢?

先认识程序手里的连接

socket 是操作系统提供的通信端点。在 C/C++ 程序里,我们用一个整数访问它:文件描述符,file descriptor,简称 fd。

假设笔记本已经分别连接文件服务 A 和 B。变量 fdA、fdB 保存这两个 socket 的 fd;为了方便追踪,假定值分别是 7、9。这些数由操作系统分配,给变量赋值 7 并不能创建一条连接。fd 也不是远端端口号,只在当前进程的描述符表里有意义。

先看从一个 socket 取数据的操作:

数据到了,怎样拿到它?

recv:从 socket 取出字节

char buffer[1024];
ssize_t n = recv(fdB, buffer, sizeof buffer, 0);
  • fdB:从 B 连接读取。
  • buffer:把字节放进这块应用内存。
  • sizeof buffer:这次最多取 1024 字节。
  • 0:使用普通接收方式,不加额外标志。

返回值 n 才是这次实际取得的字节数。

到达本机的数据先由内核处理,暂存在 socket 的接收缓冲区。recv 再把可用字节取到程序提供的数组中。这里有两块内存:内核保存尚未被应用取走的数据;buffer 属于应用。

数组能装 1024 字节,不意味着必须装满才返回。已有 8 字节时,普通 recv 可以返回 8;只有 buffer[0..8) 是这次收到的内容,也不会自动添加字符串结尾的 \0。

返回类型 ssize_t 是有符号整数,因为它还要表达失败。对于长度大于零的流式 socket 读取:

recv 返回什么先怎样理解
正数取到了这么多字节
0输入已经结束,之前的数据也已取完,即 EOF
-1查看 errno,确定为什么这次没读成

errno 是错误原因,只在返回失败时检查。成功后遗留的 errno 不能用来判断本次失败。完整语义见 recv(2)。

一个看起来很自然的写法

现在,两个查询都已发出:A 还没回答,B 的接收缓冲区里已有字节。两个 socket 使用默认的阻塞模式。

B 已经回答,程序却没理它

哪一行能先执行完?

char bufferA[1024], bufferB[1024];
recv(fdA, bufferA, sizeof bufferA, 0);
recv(fdB, bufferB, sizeof bufferB, 0);

假定 A 没有数据,也没有关闭、错误或中断。

B 的数据已经到了,这个线程能立即读到吗?

不能。线程进入第一行 recv 后,等的是 A。B 有数据,并不能让 A 的读取成功;线程还没有机会执行下一次 recv。

这里的“阻塞”是当前线程暂时不能继续执行。等待期间它通常睡眠,让出 CPU,而不是不断检查 A。问题不是 CPU 无法做别的事,而是这个线程无法去处理已经有进展的 B。

给每条连接配一个线程可以解决顺序等待,但连接增加时,线程栈、调度和状态协调也会增加。我们想再问一步:能否让一个线程照看这两条连接?

先解决“不准卡在 A 上”

没数据就先回来

非阻塞 socket

int flags = fcntl(fdA, F_GETFL, 0);
fcntl(fdA, F_SETFL, flags | O_NONBLOCK);

对 B 做同样的设置。这里保留原有标志,两次调用都需要检查是否失败。

此后,连接暂时没数据、也没有 EOF 或错误时:

recv → -1,errno 为 EAGAIN 或 EWOULDBLOCK

含义是“现在读不到,稍后再试”,不是连接断开。

O_NONBLOCK 改变的是操作暂时无法推进时的行为。标志的设置方式见 F_GETFL / F_SETFL。

这样就可以先试 A,再试 B:A 没数据立即返回,B 有数据就读取。不过,如果两个连接都没数据呢?

试 A → EAGAIN
试 B → EAGAIN
试 A → EAGAIN
试 B → EAGAIN
……

程序倒是不会睡死在 A 上了,却可能把 CPU 用来反复确认“什么也没发生”。每轮加一次 sleep 又会让刚到达的数据等到下一轮才被发现。

现在问题变得具体了:能否在两边都没事时睡眠,任意一边有事时继续?

把等待条件交给操作系统

我们真正需要的接口

等 A 或 B,不是先等 A 再等 B

把两个连接一起交给内核:

  • 关心 A、B 是否可读。
  • 都没有可处理的情况,就允许当前线程睡眠。
  • 有就绪项就返回,并指出是哪几个。

随后由当前线程执行 recv。

通知我去哪里读,与替我读出数据,是两件事。

这就是本文要讨论的 I/O 多路复用:用一次等待关注多个 I/O 对象,让同一个线程交替推进它们。select、poll、epoll 是提供这种能力的接口,不是必须依次调用的三个步骤。

它们返回的是就绪状态(readiness):对应的 I/O 操作现在有机会不经等待就给出结果。可读通常意味着有字节可取,也可能意味着读取能立即得到 EOF。它不表示一条 RPC 响应已经完整,更不保证数据为当前线程独占。

先只看正常数据到达。下面的时间是教学示意:

时刻AB当前线程
开始等待无数据无数据睡眠,等待这一组连接
约 0.2 秒后无数据收到字节内核使等待线程具备继续运行的条件
线程获得 CPU无数据字节仍在内核中等待函数返回,程序检查 B 的事件
调用 recv(fdB, …)无数据字节被取走处理读取结果

“唤醒”不等于立刻执行。线程先变成可运行状态,调度器再决定何时让它运行。这里也没有为每个 fd 新建一个等待线程。

因此,非阻塞 socket 与可以阻塞的等待函数正好配合:读写某一条连接时不把线程困住;所有连接都暂时无法推进时,集中等待,避免空转。

select:交入关注集合,取回就绪集合

现在用真实接口表达刚才的要求。继续用 fdA = 7、fdB = 9;从这里起,两条连接都已设为非阻塞,只有当前线程读取它们。

先把这一轮等待写出来

从 {7, 9} 开始

fd_set reads;
FD_ZERO(&reads);
FD_SET(fdA, &reads);
FD_SET(fdB, &reads);

timeval timeout{1, 0};
int count = select(10, &reads, nullptr, nullptr, &timeout);

这段代码只准备集合并等待,还没有读取字节。

前四行在准备什么?

fd_set 是系统提供的集合类型,reads 是我们给变量起的名字。先把它想成一张按 fd 编号打勾的表;{7, 9} 表示勾选了 7 和 9。

执行的语句集合内容含义
FD_ZERO(&reads){}清空集合
FD_SET(fdA, &reads){7}加入 A
FD_SET(fdB, &reads){7, 9}再加入 B

FD_ZERO、FD_SET 是系统头文件提供的宏;&reads 把变量地址交给它们,以便修改集合。它们只改内存中的标记,不创建连接,也不读取数据。

最后一行在哪里等?

线程执行到 select(...) 时,才把关注要求交给内核。五个参数分别是:

参数本例中的含义
10检查的 fd 编号范围上界,不包含 10
&reads关注可读的集合,同时接收返回结果
第一个 nullptr不提交可写集合
第二个 nullptr不提交异常条件集合
&timeout本轮等待的超时设置

最大 fd 是 9,所以第一个参数是 9 + 1。它不是连接数量;只关注 7 和 900 时,也得传 901。用变量写就是 std::max(fdA, fdB) + 1。

timeval 的两个字段是秒、微秒,因此 {1, 0} 表示一秒。B 提前就绪,就可以提前返回;不是每次都强制睡一秒。设为 {0, 0} 是立即检查,最后一个参数传 nullptr 才是不设置等待时限。

返回时,集合发生了什么?

只让 B 收到 abcdefgh

猜一猜:返回后的 reads 还有 A 吗?

假定只有 B 可读,调用成功返回:

变量调用前返回后
reads{7, 9}{9}
count尚未获得返回值1

count 是就绪项数;reads 告诉我们具体是谁。

B 的八个字节此时仍在内核接收缓冲区里。

reads 同时是输入和输出:调用前表示“我关心谁”,返回后表示“这次谁就绪”。A 被清掉的只是集合中的标记,连接没有被关闭,fdA 也仍是 7。

这里仅提交了可读集合。若 A、B 都可读,count 为 2,集合保留两者;超时返回 0,集合为空;失败返回 -1,此时查看 errno,不要继续把集合当作本轮就绪结果。定义见 select(2)。

有了 {9},程序如何读到 B?

检查集合,再读取字节

只有 B 能进入这个分支

以下片段接在上面的等待之后,只展开成功路径:

if (count > 0) {
    for (int fd : {fdA, fdB}) {
        if (FD_ISSET(fd, &reads)) {
            char buffer[1024];
            ssize_t n = recv(fd, buffer, sizeof buffer, 0);
            // 检查 n,再处理字节、EOF 或错误。
        }
    }
}

FD_ISSET 检查编号是否仍在集合中,非零表示在。

代入具体数值:循环先检查 7,结果为零,跳过;再检查 9,结果非零,于是当前线程执行 recv(9, ...)。如果它读到八个字节,n 才是 8,而 count 仍是 1。就绪项数与读取字节数没有混在一起。

注意,即使收到可读通知,也要检查 recv 的结果。状态可能变化,就绪通知也不是一次数据预留;使用非阻塞模式,可以在暂时读不到时返回 EAGAIN,避免意外卡住整个线程。

再等一次,错误就可能出现了

停一下:A 会不会被漏掉?

上一轮只有 B 可读,reads 已变成 {9}。如果不重建集合,直接再次调用 select,这一次恰好 A 收到数据,会怎样?

这次传给内核的要求只有“关注 9”。A 不在关注范围内,当然不能靠它结束这次等待。

所以每轮都要重新执行 FD_ZERO 和两个 FD_SET,或者从保留的完整关注集合复制一份。timeout 也要重新初始化,因为 select 可能改写它。重建的是等待参数,不是重建网络连接。

select 的 1024 限制,限制的是哪一个数?

Linux 常见的 glibc fd_set 大小固定,FD_SETSIZE 为 1024;放入的有效 fd 必须非负且小于它。即使只观察两个 socket,其中一个 fd 是 1200,也不能直接放进去。这不是“Linux 最多只能有 1024 个连接”。

另外,exceptfds 用于异常条件,例如 TCP 带外数据,并不是“所有错误的集合”。超时精度还受时钟粒度和调度影响,不是程序一定恰好在一秒处恢复运行。

poll:不要让输入与输出共用一列

select 已经解决了“等 A 或 B”。但它的集合会被改写,fd 数值还有范围限制。换一种数据结构,会不会更容易表达?

poll 给每个 fd 一条记录,分别保存关心什么和发生了什么。

同样的等待,换一张表

pollfd 的三个字段

pollfd fds[] = {
    {fdA, POLLIN, 0},
    {fdB, POLLIN, 0},
};
int count = poll(fds, 2, 1000);

每行依次是 fd、events、revents。

  • events = POLLIN:输入,关注可读。
  • revents:输出,内核填写本轮结果。
  • 2 是数组项数;1000 是等待毫秒数。

让 B 再次收到同样的八个字节,A 仍然没动静。成功返回后,整张数组是这样:

下标fdeventsrevents
07POLLIN0
19POLLINPOLLIN

count == 1 表示一项的 revents 非零。B 仍在下标 1,并没有被搬到下标 0。 因此,不能因为 count 为 1 就只查看数组第一项。

返回 0 是超时,-1 是调用失败。超时参数为 0 表示立即检查,为 -1 表示不设置等待时限。poll 的这些单位和返回约定见 poll(2)。

在原数组中找出可读项

为什么这里遍历整个 fds?

if (count > 0) {
    for (const auto& item : fds) {
        if ((item.revents & POLLIN) != 0) {
            char buffer[1024];
            ssize_t n = recv(item.fd, buffer, sizeof buffer, 0);
            // 检查读取结果;这里只展开正常可读分支。
        }
    }
}

A 的结果是零,跳过;B 包含 POLLIN,尝试读取。

这里的 & 是按位与。事件字段是位掩码,一个整数的不同二进制位表示不同条件;| 可以组合标志,& 检查是否包含某个标志。例如,POLLIN | POLLHUP 不等于单独的 POLLIN,但仍包含可读这一位。关闭和错误分支稍后补齐。

与 select 不同,调用没有把输入的 events 清掉。连接和关注条件不变时,下一轮可以直接重用 fds;内核重新填写 revents。A 上轮没就绪,不会因此被忘掉。

数组也避开了 fd_set 的固定编号范围,但仍受系统资源限制。还有一件事没有改变:每次等待都要提交整张表,返回后再从整张表中找结果。

如果关注一万个连接,大多数时候只有几个活跃,而且关注列表很少变化,还能怎样改?

epoll:把“关注谁”保存下来

我们可以把刚才的接口拆成两类操作:连接发生变化时,更新关注列表;等待时,只取回这一批需要处理的项。Linux 的 epoll 就提供了这样的组织方式。

创建实例,然后登记连接

登记一次,等待多轮

epoll_create1 与 epoll_ctl

int epfd = epoll_create1(EPOLL_CLOEXEC);
for (int fd : {fdA, fdB}) {
    epoll_event interest{};
    interest.events = EPOLLIN;
    interest.data.fd = fd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &interest);
}

这里只展示接口关系;创建和登记失败都返回 -1,实际程序必须检查。

epfd 是新建 epoll 实例的 fd。假如它是 11,角色就很清楚了:7、9 用于收发网络字节,11 用来管理和等待这一组关注项。创建 epoll 不会创建网络连接,也不会启动一个线程。

EPOLL_CLOEXEC 让这个 fd 在成功执行 exec 时自动关闭;它与稍后讨论的 LT/ET 无关。见 epoll_create1(2)。

把 B 的登记单独拿出来,就是 epoll_ctl(11, EPOLL_CTL_ADD, 9, &interest):

内容作用
11在哪个 epoll 实例中操作
EPOLL_CTL_ADD新增关注项
9真正被监视的 socket fd
interest.events = EPOLLIN关注它的可读状态
interest.data.fd = 9附带一个标识,返回事件时原样交还

最后两项尤其容易混淆:第三个参数指定监视谁,data 则帮助应用在结果中认出它。内核保存登记内容,不要求局部变量 interest 一直活着;但如果 data 保存的是指针,指向对象的寿命仍由应用负责。

登记也不会自动设置 O_NONBLOCK。我们前面对 A、B 的非阻塞设置仍然需要。

等待时,只提供结果数组

这次不必再交入 A、B

epoll_wait 去哪里找关注列表?

epoll_event ready[16];
int count = epoll_wait(epfd, ready, 16, 1000);

关注列表已保存在 epfd 对应的内核实例中。

ready 是输出数组;16 是本批容量;1000 是等待毫秒数。只有前 count 项属于成功返回的本批结果。

仍然只有 B 收到八个字节,那么 count == 1:

本批结果值
ready[0].data.fd9,即登记时附带的信息
ready[0].events包含 EPOLLIN
ready[1] 到 ready[15]不属于本批结果,不应读取

这与 poll 的数组很不一样。poll 在原数组第二行写 B 的结果;epoll_wait 只交付就绪项,B 就放在本批第一项。结果顺序不代表 fd 数值顺序,也不保证与登记顺序相同。

因此,后面的读取片段是:

if (count > 0) {
    for (int i = 0; i < count; ++i) {
        if ((ready[i].events & EPOLLIN) != 0) {
            int fd = ready[i].data.fd;
            char buffer[1024];
            ssize_t n = recv(fd, buffer, sizeof buffer, 0);
            // 检查读取结果;这里只展开正常可读分支。
        }
    }
}

最后仍然由当前线程执行 recv(9, ...)。内核没有替我们调用业务回调,也没有把响应正文放进 ready。

返回 0 表示超时,-1 表示失败;超时参数 0 表示立即检查,-1 表示不设置等待时限。容量 16 不限制实例只能关注 16 条连接;更多就绪项可以分批取回。一个结果项也可能包含多个事件位。见 epoll_wait(2)。

下一轮还用不用 ADD?

停一下:没有返回 A,是否意味着不再关注 A?

不是。内核中的关注列表仍是 A、B;本轮结果只有 B。关注列表与就绪结果已经是两份不同的信息。

没有变化就继续 epoll_wait,不需要每轮重新 ADD。

需要改变关注内容时,才调用 epoll_ctl:

操作改变什么
EPOLL_CTL_ADD新增关注项
EPOLL_CTL_MOD用新事件设置和关联信息替换原有设置
EPOLL_CTL_DEL从该实例中移除关注项

例如,原来只关心读,后来有数据没发完,需要同时等可写,就用 MOD 提交 EPOLLIN | EPOLLOUT。MOD 不是自动追加一位,如果仍关心读,就必须继续包含 EPOLLIN。DEL 只是取消关注,不等于 close(fd) 关闭连接。约定见 epoll_ctl(2)。

三种接口,到底改变了什么?

同一个问题selectpollepoll
关注谁放在哪里?每轮交入的集合每轮交入的数组预先登记的内核实例
只有 B 就绪?集合只保留 BB 的 revents 非零本批结果只含 B
下一轮如何继续?重建集合与超时重用未变的输入字段继续等待,变化时才更新

三者都没有替代 recv。它们改变的是等待如何组织、结果如何找到。

epoll 内部是不是仍在不停扫描全部连接?

以 Linux v6.12 为例,登记关注项时,epoll 会把内核中的等待机制接到目标对象上;相关 I/O 活动可以触发通知,把关注项加入就绪链表,并唤醒等待线程。取回事件时还会检查状态。登记时已经就绪的对象也能被发现,不要求再来一次数据。

可对照 fs/eventpoll.c 中的 ep_insert、ep_poll_callback、ep_send_events。这里的 callback 是内核内部通知函数,和 RPC 业务回调不是一回事。

如果关注项有 N 个、本轮返回 K 个,poll 的接口仍要求提交和检查 N 项;epoll 复用关注集合,应用主要遍历返回的 K 项。大量连接、少量活跃时,这能减少重复工作。但维护关注项、通知、锁竞争和实际读写都有成本,不能背成“epoll 的所有操作都是 O(1)”。它也不会消除普通 recv 的数据复制。

我们已经能找到 B,接下来再改变一个条件:B 有八个字节,但这次只读三个。下一轮还能找到它吗?

LT 与 ET:读了一半,还会不会提醒?

只看一个受控情形:B 收到 abcdefgh,程序已取回这次可读事件,只读走 abc。此后没有新数据、没有其他线程读取,也没有修改关注项。

通知取走了,数据还没取完

下一次 epoll_wait 会怎样?

char part[3];
ssize_t n = recv(fdB, part, sizeof part, 0);
// 本例假定 n == 3,内核中还剩 defgh。
模式下一轮是否继续报告这份剩余数据?
LT,水平触发会继续报告尚未消失的可读状态
ET,边缘触发不能指望它为这份剩余数据再提醒一次

取回通知,不等于读空缓冲区。

LT 为什么会再提醒?

LT 是 level-triggered,也是 epoll 的默认模式。可以把它理解为反复询问:“当前可读这个条件还成立吗?”defgh 没读走,条件就仍成立。select、poll 的这种可读检查也具有水平触发的行为。

所以 LT 下,一轮只读一部分,下一轮仍有机会继续。不过,若不断收到可读通知却一直不读,等待也会不断返回,线程就可能空转。

ET 为什么可能等不到下一次?

ET 是 edge-triggered。登记时在事件设置中加上 EPOLLET,例如 EPOLLIN | EPOLLET。它不会仅因同一份未读数据还留在那里,就在每一轮等待中反复提醒。

回到例子:应用以为“还有数据时会再叫我”,于是回到等待;服务端以为“响应已经发完”,也在等下一条请求。结果五个字节留在内核里,两边都没有继续推进。

这里不应把 ET 背成“每个网络包通知一次”,也不应背成“只在空变非空时通知,此后新数据绝不会通知”。通知可能合并,新 I/O 活动也可能触发通知。可靠的编程规则是:不要把已经知道还有的工作,寄托在不保证出现的下一次通知上。 这个半读示例与规则可对照 epoll(7)。

怎样确认当前已经读不动了?

对非阻塞 socket,继续读,直到 EAGAIN 或 EWOULDBLOCK。这次返回是一个明确边界:当前暂时没有更多字节可取,可以去处理别的工作。

下面给出读取处理函数的结构。OnBytes、OnReadEof、OnReadError 都是应用自己的函数:分别保存取得的字节、处理输入结束、处理错误。假定它们不会在读取循环中途销毁连接;fd 已设为非阻塞。

void HandleReadable(int fd) {
    char buffer[4096];
    for (;;) {
        ssize_t n = recv(fd, buffer, sizeof buffer, 0);
        if (n > 0) {
            OnBytes(buffer, n);
            continue;
        }
        if (n == 0) {
            OnReadEof();
            return;
        }
        if (errno == EINTR) continue;
        if (errno == EAGAIN || errno == EWOULDBLOCK) return;
        OnReadError(errno);
        return;
    }
}

这次代码更长,因为它不再只处理“顺利读到一些字节”的路径。EINTR 表示调用被信号中断,这里重新尝试;EOF 和其他错误则交给连接处理逻辑,不能当作暂时没数据。

如果误用了阻塞 socket,会怎样?前几次 recv 顺利读走数据,最后一次却可能睡在已经读空的 B 上。整个线程又无法照看 A,回到了文章开头的问题。

到这里再看框架中的 HandleReadable(fd),它已经不神秘:只是把刚才这一段普通应用代码封装成函数。epoll_wait 返回后,由事件循环调用它;内核不会替应用执行这个函数。

必须无限地读到 EAGAIN 吗?一个连接会不会独占线程?

持续活跃的连接确实可能占用太久。框架可以限制单轮读取字节数、消息数或处理时间,再轮到其他连接。

关键是预算耗尽时怎样处理剩余工作:LT 可以继续依靠仍然成立的就绪条件;ET 如果还没读到 EAGAIN,就要在应用中记录“这里还需要继续读”,安排后续处理,不能直接忘掉它并进入无限期等待。EAGAIN 是判断暂时无法推进的依据,不是要求某个连接永远独占线程。

EPOLLONESHOT 是不是 ET 的另一种叫法?

不是。EPOLLONESHOT 在交付一次事件后禁用这个关注项,需要用 EPOLL_CTL_MOD 重新启用,称为 rearm。ET 决定通知方式;ONESHOT 决定一次交付后是否暂停关注。两者可以组合,但都不会自动管理 C++ 对象寿命或解决全部线程安全问题。

字节读完了,响应就完整了吗?

前面的 abcdefgh 只帮助我们观察字节是否被读走。现在回到文件查询,给字节赋予业务含义。

为了看清消息边界,暂用教学协议:文件大小响应是 SIZE 4096\n,以换行结束。这不是 gRPC 的实际编码。

一个等待结束了,另一个还没结束

内核里没字节,应用里却有半条消息

本次 recv 的结果应用累计的内容能解释成一条响应吗?
取得 SIZE 40SIZE 40不能,还没有换行
返回 EAGAIN仍是 SIZE 40不能,保留到下一轮
后来取得 96\nSIZE 4096\n可以,解析出大小 4096

EAGAIN 结束的是当前读取尝试,不是 RPC。

TCP 提供有序字节流,不保留应用每次发送的消息边界。对端一次 send,本端可能分多次 recv 才取完;两条消息也可能在一次读取中到达。不能用“这次收到了几个字节”代替协议解析。见 tcp(7)。

因此,OnBytes 必须把字节放进一个随连接保存、跨多轮读取存在的应用缓冲区。局部数组 buffer 只是这次读取的临时落点,不够保存半条消息。

下面是解析过程的伪代码,TryTakeLine 成功时会从缓冲区取走一整行:

input.append(newBytes);
while (TryTakeLine(input, line)) {
    HandleResponse(line);
}

为什么是 while,而不只是 if?如果一次取得 96\nSIZE 8192\n,它既补完了上一条,又带来下一条完整消息。只处理一条,剩余的完整消息就可能留在应用内存里;内核已经读空,未必还有下一次可读通知来推动它。

所以需要分别检查两处进度:内核缓冲区有没有继续可读的字节,应用缓冲区有没有继续可解析的消息。 实际协议还要限制消息长度、缓冲区大小,并处理格式错误;采用“长度字段 + 正文”时,道理相同。

socket B 收到部分响应字节后,epoll_wait 返回可读通知;应用线程调用 recv 把字节读入应用缓冲区,再积累和解析完整响应。
蓝色是通知与控制,绿色是字节流动。就绪通知、读取字节和拼出消息分别推进不同的状态。

发送与关闭,也得放回这个模型

接收方向已经清楚了:能推进就处理,暂时不能推进就保留进度。发送方向同样如此。

可写,不等于全部发完

准备发送 10 KB,只写入了 3 KB

剩下的 7 KB 放在哪里?

非阻塞 send 可能只接受部分数据:

  • 返回正数:本次被本机发送路径接受的字节数。
  • 暂时无空间时返回 -1,并设置 EAGAIN 或 EWOULDBLOCK。
  • 其他错误:进入连接错误处理。

未发送部分留在应用发送缓冲区,记录已发送位置,下次继续。

可写通常表示本机发送缓冲区还有空间。它不表示对端已经收到,更不表示对端业务处理完成。即使一次 send 成功接受全部字节,也不能据此完成一个需要应答的 RPC。见 send(2)。

在 LT 模式下,一个常见策略是:先尝试发送;如果还有剩余,就关注 EPOLLOUT;收到可写事件后继续发送;发送缓冲区清空后取消可写关注。

为什么要取消?很多连接在空闲时也可写。如果没有待发数据却一直关注可写,epoll_wait 可能不断返回,线程每次醒来都无事可做。原来“CPU 很忙”不一定是正在忙业务。

ET 下还要注意:应用后来加入待发数据,并不一定使内核的可写状态发生新的变化。应主动尝试推进发送,不能只把数据放进队列,指望必然出现一个新边缘。

如果生产数据的速度长期超过发送速度,应用缓冲区会不断增长。需要限制队列、减慢上游或拒绝部分工作,这就是背压(backpressure)。把操作改成非阻塞,并不会消除容量限制。

没数据,还是没有以后的数据?

EAGAIN 与 EOF 不能混为一谈

同样没读到字节,下一步却不同

结果含义后续动作
-1,EAGAIN这次暂时读不到保留连接,等待以后推进
0,EOF输入结束,已无剩余字节结束接收方向,按协议处理连接

EOF 本身也能使等待接口报告可读,因为 recv 可以立即返回 0。

对端可以只关闭发送方向;这叫半关闭,不代表本端一定不能继续发送。具体何时关闭整个连接,需要结合协议状态判断。

POLLHUP / EPOLLHUP 表示挂断,但内核中可能还有未读字节。EPOLLRDHUP 可用于观察流式连接对端结束发送的情况。收到这些事件时不能简单地丢掉所有剩余数据;仍需依据实际读取结果处理。POLLERR / EPOLLERR 表示错误,POLLNVAL 则表示监视的 fd 无效。它们可能与其他事件同时出现,不能把全部处理写成互斥的“只会有一个标志”。

这也解释了前面为什么反复标明“只展开正常可读分支”:真实事件循环必须处理 EOF 和错误、移除不再需要的关注。否则,同一个已经结束的 fd 也可能让循环不断立即返回。

连接还没建立时,可读与可写表示什么?

服务端的监听 socket 可读,通常意味着可以尝试 accept 取出新连接。新连接有自己的 fd,还要另行登记读写关注。Linux 的 accept 不自动把监听 socket 的 O_NONBLOCK 继承给新 socket,应显式设置,或用 accept4 指定;ET 下通常接受到暂时没有新连接为止。见 accept(2)。

客户端非阻塞 connect 可以返回 EINPROGRESS。之后收到可写或错误通知,要用 getsockopt(SOL_SOCKET, SO_ERROR, ...) 读取连接结果,可写本身不能证明连接成功。见 connect(2)。

因此,同一个事件需要结合连接阶段解释:监听、正在连接、已连接,并不是同一件事。

把这些操作接成事件循环

目前我们一直只看一轮等待。把“等待 → 处理本批事件 → 再等待”反复执行,就得到事件循环(event loop)。

系统通知,应用分发

循环仍然是普通程序代码

下面是结构伪代码,不是可直接编译的框架:

while 尚未停止:
    算出距离最近定时任务还有多久
    如果已有可运行任务,将等待超时设为 0
    等待 I/O 事件,最多等到上述时限
    逐个推进本批事件对应的连接
    执行待办任务
    处理已经到期的定时任务

读到一半的消息、没发完的数据,都保存在连接对象里。

“事件循环会调用回调”现在可以翻译成普通函数调用:程序从结果里找到 B 的连接对象,调用它登记的读取处理函数;处理函数执行 recv,保存字节,再尝试解析。内核负责就绪通知,应用负责调用自己的代码。

为什么还要管定时任务?RPC 有截止时间。即使 socket 一直没有事件,也必须及时判断超时,不能把事件线程永远留在无限期等待里。

为什么还要管待办任务?业务线程可能提交一项新工作,而事件线程此刻正睡在 epoll_wait 中。仅仅修改内存队列,不会自动让这个等待返回。

Linux 框架常把一个 eventfd 也登记进 epoll。提交方先把任务放入应用队列,再按框架约定写这个 fd;它变为可读,事件循环便有机会醒来处理队列。fd 携带的是唤醒通知,任务本身仍在应用内存里。见 eventfd(2)。

那一百个异步 RPC,存在哪里?

等待中的调用,不必各占一个线程

把“稍后继续”保存为状态

每个调用可以保存:

  • 请求标识,以及对应的响应对象。
  • 截止时间、当前结果或错误。
  • 完成后要执行的逻辑。

多个调用共享连接,连接再由少量 I/O 线程照看。

调用数、连接数、线程数,是三个不同的数。

响应字节到达后,框架先取得完整协议消息,再根据请求标识找到调用,最后安排完成通知。比如 gRPC 的 HTTP/2 传输使用连接内的 stream ID 关联调用;一条连接可以承载多个 stream,不能把一个 fd 当成一次 RPC。协议见 gRPC over HTTP/2。

超时、取消、连接错误也可能结束调用。框架需要协调这些路径,避免同一个单次请求重复交付最终结果。调用状态也不能在发起函数返回时就销毁,而要存活到相关异步处理结束。

业务回调依然是客户端代码。服务端处理自己的请求并发送响应;它不会跨机器执行客户端保存的 lambda。回调具体在哪个线程执行,取决于框架:可能直接在事件线程上,也可能投递到其他执行器。

如果直接在事件线程里做长时间计算、等待锁或执行阻塞操作,其他连接都会被拖延。I/O 多路复用让等待能够共享线程,不会使业务计算自动并行。

从头走完 B 的一次响应

现在可以把前面的机制接成一条执行路径。A 始终没回答,B 分两段送来教学协议中的文件大小:

发生什么当前线程怎样推进尚未完成的状态在哪里
A、B 都没数据在等待接口中睡眠关注列表、查询状态
B 到达 SIZE 40获得 CPU 后,等待返回 B 的事件字节仍在内核中
调用 recv读出字节,追加到输入缓冲区应用保存半条响应
继续读得到 EAGAIN结束本轮读取,照看其他工作半条响应和查询继续保留
B 到达 96\n再次读取,拼出完整消息现在可以解析文件大小
确认对应调用完成执行或调度客户端完成逻辑调用可以结束,连接可能继续复用

这里假定每个连接上的查询可以唯一确定;真实的多请求 RPC 还需要前面说的请求标识。教学文本协议只用于解释消息边界。

四个“完成”,不要跳着理解

等待返回,只说明有结果可检查;读取成功,只说明得到了字节;解析成功,才得到了协议消息;满足调用的完成条件,才能交付这次 RPC 的结果。

同步 RPC 的内部也可以使用这套事件循环:业务线程等待调用完成,I/O 线程照常推进连接。“同步还是异步”需要说明观察的是哪一层。

在真实框架里认出这些动作

沿着 Muduo 的一次读取走

现在不必从头读一个网络库。只找“谁等待、谁分发、谁读取、谁保存半条消息”,就能把接口知识对应到框架结构。以下使用 Muduo 固定版本 f1fc77e:

位置对应刚才哪一步
EventLoop::loop反复取得活跃连接,处理事件与待办任务
EPollPoller::poll调用 epoll_wait,整理返回项
Channel::handleEventWithGuard检查事件位,调用相应处理函数
TcpConnection::handleRead读取到连接的输入缓冲区,调用接收回调
Buffer::readFd通过 readv 实际取出字节

Channel 可以先理解为某个 fd 的关注事件和处理函数的集合。EPollPoller::poll 虽然叫 poll,内部调用的却是 epoll_wait,不能仅凭名字判断系统接口。

这份代码的普通读写关注没有设置 EPOLLET,采用 LT。因而 handleRead 做一次缓冲区读取就返回,不代表它漏掉了 ET 的排空要求。先确认模式,才能判断读取策略。

messageCallback_ 也需要看语义:它在读到字节后被调用,不自动保证字节构成完整消息。协议解析仍然需要应用缓冲区。发送方向的 handleWrite 会在输出缓冲区清空后取消可写关注;跨线程投递则可看 queueInLoop 与 wakeup。

把示例变成网络库,还要处理哪些边界?
  • fd 与对象寿命。 本批事件中的一个连接可能在处理其他事件时被关闭,fd 数字也可能被复用。需要注销关注、标记状态、延迟销毁或校验代次,不能让旧事件误指向新连接。data.ptr 不会自动保活对象。
  • 描述符副本。 有 dup 等共享打开对象的 fd 时,一个 close 不一定移除全部 epoll 关系。见 epoll(7) 的 Questions and answers。
  • 等待被中断。 若总等待有截止时间,EINTR 后应计算剩余时长;每次重试都给完整超时,可能不断延长总等待。
  • 发送到已关闭连接。 还可能触发 SIGPIPE。Linux 可使用 MSG_NOSIGNAL,同时正常处理 EPIPE 等发送错误。
  • 处理预算。 读取、解析、回调与待办队列都不能无限占用事件线程;限制预算以后,还要保留继续推进的安排。

这些都是通知、进度与对象寿命的后续问题,不是再换一个等待接口就会自动消失的问题。

其他名字,放在哪个位置?

现在可以回答“这些通常是一组吗”:select、poll、epoll 常被放在一起比较,因为都提供就绪等待。但它们并不是所有 I/O 机制的完整名单。

名字与本文模型的关系
pselect、ppoll、epoll_pwait在相应等待接口上,加入等待期间原子切换信号掩码的能力
kqueue / keventBSD、macOS 的事件通知接口,可管理多种事件来源
io_uringLinux 的提交与完成接口,既支持具体 I/O 操作,也能提交轮询请求
IOCPWindows 中取得重叠 I/O 等操作完成结果的机制
gRPC CompletionQueue更上层的操作完成通知,不是 socket 就绪集合

最有用的区分是:“这个 fd 值得尝试读取”和“我提交的那次读取已经有结果”不是同一种通知。 后者可能直接带来字节数或错误,但仍然不必然等于整个 RPC 已完成。具体入口见 kqueue(2)、io_uring(7)、Windows I/O Completion Ports 和 gRPC C++ Async API。

普通磁盘文件还要单独看:select / poll 通常立即报告可读写,Linux epoll 通常不能登记普通文件。这不证明实际磁盘访问不会等待,也不能直接把 socket 的就绪模型套到磁盘读取上。

用同一个场景检查理解

回到全文最小的场景:A 没数据,B 收到 abcdefgh,本次只读三个字节。读到这里,应当能预测接下来会发生什么,而不只是认出接口名字。

最后留下这三个判断

当前究竟在等什么?

  • select、poll、epoll:等一组对象的就绪情况。
  • recv:尝试取出字节,依据返回值继续或停下。
  • 协议与 RPC:保存跨多轮的进度,判断消息与调用是否完成。

还剩什么工作?它保存在哪里?谁会让它继续?

这三个问题,同样适用于发送、定时任务与异步回调。

select 返回 1,为什么不能直接 recv(1, …)?

1 是本例的可读项数,不是 fd。要从被改写的集合中用 FD_ISSET 找到 B,也就是 9。poll、epoll_wait 的返回计数同样不能直接当 fd。

poll 返回 1,为什么只看 fds[0] 会漏掉 B?

它报告有一项的 revents 非零,却不压缩原数组。B 仍在 fds[1]。相反,epoll_wait 的本批结果只含就绪项,才遍历前 count 项。

ET 没有再通知,为什么 recv 仍可能读到 defgh?

因为通知与数据是不同的状态。上次取走通知后,只读掉 abc;剩余字节仍在内核里。不能把“没有下一次通知”理解成“没有可读数据”。

没有网络请求,事件线程却忙个不停,先检查什么?

先看是否把等待超时永久设为 0,是否没有待发数据却一直关注 LT 可写,是否 EOF 或错误之后仍保留会立即返回的关注项。然后检查应用待办队列是否不断生成工作。CPU 高本身不足以证明 epoll 的实现有问题。

对照已经写好的实验

完整示例 io-readiness-demo.cpp 使用 socketpair 创建两对本地流式 socket,代表 A、B。它不需要服务器、端口或额外线程,固定执行“写八个字节 → 读三个 → 读空 → 对端结束发送”。

每次观察都把等待超时设为 0,目的是取得该时刻的状态,不是展示一个不断空转的生产事件循环。先看 select / poll 的预期轨迹:

initial: none
after send 8: B
recv B: 3 bytes [abc]
after read 3: B
recv B: 5 bytes [defgh]
recv B: EAGAIN/EWOULDBLOCK
after drain: none
after peer shutdown write: B
recv B: EOF

after read 3 仍有 B,是因为数据没读完;after drain 没有 B,是因为此刻没有更多字节,连接还开着;对端结束发送后又有 B,是因为 EOF 也可读。它们是三个不同的状态。

Linux 上切换到 ET,重点看 after read 3:在这个只有本线程操作、没有新写入或关注项修改的受控序列中,预期没有新的 B 通知,但紧接着主动读取仍能拿到 defgh。LT 则继续报告 B。这里给出的是按接口语义推导的对照,不是 Linux 性能或运行测量。

需要核对时,怎样运行?

下载源码后,在所在目录使用支持 C++17 的编译器:

c++ -std=c++17 -O2 -Wall -Wextra -pedantic \
    io-readiness-demo.cpp -o io-readiness-demo
./io-readiness-demo select
./io-readiness-demo poll

Linux 上还可以运行:

./io-readiness-demo lt
./io-readiness-demo et

macOS 没有 sys/epoll.h,LT/ET 模式需要 Linux 环境。实验只检查就绪与读取的关系,不用于比较几个接口的吞吐量。

至此,我们可以回到最初那一百个查询:不必为每次调用安排一个只负责等待的线程;可以保存调用和连接的进度,由少量线程在事件发生时继续推进。下一篇再沿着这条执行路径,讨论 RPC 的超时、重试与幂等:如果始终等不到成功响应,调用应当怎样结束?