select、poll 与 epoll:一个线程怎样照看多个连接
在 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 取数据的操作:
到达本机的数据先由内核处理,暂存在 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 使用默认的阻塞模式。
不能。线程进入第一行 recv 后,等的是 A。B 有数据,并不能让 A 的读取成功;线程还没有机会执行下一次 recv。
这里的“阻塞”是当前线程暂时不能继续执行。等待期间它通常睡眠,让出 CPU,而不是不断检查 A。问题不是 CPU 无法做别的事,而是这个线程无法去处理已经有进展的 B。
给每条连接配一个线程可以解决顺序等待,但连接增加时,线程栈、调度和状态协调也会增加。我们想再问一步:能否让一个线程照看这两条连接?
先解决“不准卡在 A 上”
O_NONBLOCK 改变的是操作暂时无法推进时的行为。标志的设置方式见 F_GETFL / F_SETFL。
这样就可以先试 A,再试 B:A 没数据立即返回,B 有数据就读取。不过,如果两个连接都没数据呢?
试 A → EAGAIN
试 B → EAGAIN
试 A → EAGAIN
试 B → EAGAIN
……程序倒是不会睡死在 A 上了,却可能把 CPU 用来反复确认“什么也没发生”。每轮加一次 sleep 又会让刚到达的数据等到下一轮才被发现。
现在问题变得具体了:能否在两边都没事时睡眠,任意一边有事时继续?
把等待条件交给操作系统
这就是本文要讨论的 I/O 多路复用:用一次等待关注多个 I/O 对象,让同一个线程交替推进它们。select、poll、epoll 是提供这种能力的接口,不是必须依次调用的三个步骤。
它们返回的是就绪状态(readiness):对应的 I/O 操作现在有机会不经等待就给出结果。可读通常意味着有字节可取,也可能意味着读取能立即得到 EOF。它不表示一条 RPC 响应已经完整,更不保证数据为当前线程独占。
先只看正常数据到达。下面的时间是教学示意:
| 时刻 | A | B | 当前线程 |
|---|---|---|---|
| 开始等待 | 无数据 | 无数据 | 睡眠,等待这一组连接 |
| 约 0.2 秒后 | 无数据 | 收到字节 | 内核使等待线程具备继续运行的条件 |
| 线程获得 CPU | 无数据 | 字节仍在内核中 | 等待函数返回,程序检查 B 的事件 |
调用 recv(fdB, …) | 无数据 | 字节被取走 | 处理读取结果 |
“唤醒”不等于立刻执行。线程先变成可运行状态,调度器再决定何时让它运行。这里也没有为每个 fd 新建一个等待线程。
因此,非阻塞 socket 与可以阻塞的等待函数正好配合:读写某一条连接时不把线程困住;所有连接都暂时无法推进时,集中等待,避免空转。
select:交入关注集合,取回就绪集合
现在用真实接口表达刚才的要求。继续用 fdA = 7、fdB = 9;从这里起,两条连接都已设为非阻塞,只有当前线程读取它们。
前四行在准备什么?
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 才是不设置等待时限。
返回时,集合发生了什么?
reads 同时是输入和输出:调用前表示“我关心谁”,返回后表示“这次谁就绪”。A 被清掉的只是集合中的标记,连接没有被关闭,fdA 也仍是 7。
这里仅提交了可读集合。若 A、B 都可读,count 为 2,集合保留两者;超时返回 0,集合为空;失败返回 -1,此时查看 errno,不要继续把集合当作本轮就绪结果。定义见 select(2)。
有了 {9},程序如何读到 B?
代入具体数值:循环先检查 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 一条记录,分别保存关心什么和发生了什么。
让 B 再次收到同样的八个字节,A 仍然没动静。成功返回后,整张数组是这样:
| 下标 | fd | events | revents |
|---|---|---|---|
0 | 7 | POLLIN | 0 |
1 | 9 | POLLIN | POLLIN |
count == 1 表示一项的 revents 非零。B 仍在下标 1,并没有被搬到下标 0。 因此,不能因为 count 为 1 就只查看数组第一项。
返回 0 是超时,-1 是调用失败。超时参数为 0 表示立即检查,为 -1 表示不设置等待时限。poll 的这些单位和返回约定见 poll(2)。
这里的 & 是按位与。事件字段是位掩码,一个整数的不同二进制位表示不同条件;| 可以组合标志,& 检查是否包含某个标志。例如,POLLIN | POLLHUP 不等于单独的 POLLIN,但仍包含可读这一位。关闭和错误分支稍后补齐。
与 select 不同,调用没有把输入的 events 清掉。连接和关注条件不变时,下一轮可以直接重用 fds;内核重新填写 revents。A 上轮没就绪,不会因此被忘掉。
数组也避开了 fd_set 的固定编号范围,但仍受系统资源限制。还有一件事没有改变:每次等待都要提交整张表,返回后再从整张表中找结果。
如果关注一万个连接,大多数时候只有几个活跃,而且关注列表很少变化,还能怎样改?
epoll:把“关注谁”保存下来
我们可以把刚才的接口拆成两类操作:连接发生变化时,更新关注列表;等待时,只取回这一批需要处理的项。Linux 的 epoll 就提供了这样的组织方式。
创建实例,然后登记连接
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 的非阻塞设置仍然需要。
等待时,只提供结果数组
仍然只有 B 收到八个字节,那么 count == 1:
| 本批结果 | 值 |
|---|---|
ready[0].data.fd | 9,即登记时附带的信息 |
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)。
三种接口,到底改变了什么?
| 同一个问题 | select | poll | epoll |
|---|---|---|---|
| 关注谁放在哪里? | 每轮交入的集合 | 每轮交入的数组 | 预先登记的内核实例 |
| 只有 B 就绪? | 集合只保留 B | B 的 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。此后没有新数据、没有其他线程读取,也没有修改关注项。
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 的实际编码。
TCP 提供有序字节流,不保留应用每次发送的消息边界。对端一次 send,本端可能分多次 recv 才取完;两条消息也可能在一次读取中到达。不能用“这次收到了几个字节”代替协议解析。见 tcp(7)。
因此,OnBytes 必须把字节放进一个随连接保存、跨多轮读取存在的应用缓冲区。局部数组 buffer 只是这次读取的临时落点,不够保存半条消息。
下面是解析过程的伪代码,TryTakeLine 成功时会从缓冲区取走一整行:
input.append(newBytes);
while (TryTakeLine(input, line)) {
HandleResponse(line);
}
为什么是 while,而不只是 if?如果一次取得 96\nSIZE 8192\n,它既补完了上一条,又带来下一条完整消息。只处理一条,剩余的完整消息就可能留在应用内存里;内核已经读空,未必还有下一次可读通知来推动它。
所以需要分别检查两处进度:内核缓冲区有没有继续可读的字节,应用缓冲区有没有继续可解析的消息。 实际协议还要限制消息长度、缓冲区大小,并处理格式错误;采用“长度字段 + 正文”时,道理相同。
发送与关闭,也得放回这个模型
接收方向已经清楚了:能推进就处理,暂时不能推进就保留进度。发送方向同样如此。
可写,不等于全部发完
可写通常表示本机发送缓冲区还有空间。它不表示对端已经收到,更不表示对端业务处理完成。即使一次 send 成功接受全部字节,也不能据此完成一个需要应答的 RPC。见 send(2)。
在 LT 模式下,一个常见策略是:先尝试发送;如果还有剩余,就关注 EPOLLOUT;收到可写事件后继续发送;发送缓冲区清空后取消可写关注。
为什么要取消?很多连接在空闲时也可写。如果没有待发数据却一直关注可写,epoll_wait 可能不断返回,线程每次醒来都无事可做。原来“CPU 很忙”不一定是正在忙业务。
ET 下还要注意:应用后来加入待发数据,并不一定使内核的可写状态发生新的变化。应主动尝试推进发送,不能只把数据放进队列,指望必然出现一个新边缘。
如果生产数据的速度长期超过发送速度,应用缓冲区会不断增长。需要限制队列、减慢上游或拒绝部分工作,这就是背压(backpressure)。把操作改成非阻塞,并不会消除容量限制。
没数据,还是没有以后的数据?
对端可以只关闭发送方向;这叫半关闭,不代表本端一定不能继续发送。具体何时关闭整个连接,需要结合协议状态判断。
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)。
“事件循环会调用回调”现在可以翻译成普通函数调用:程序从结果里找到 B 的连接对象,调用它登记的读取处理函数;处理函数执行 recv,保存字节,再尝试解析。内核负责就绪通知,应用负责调用自己的代码。
为什么还要管定时任务?RPC 有截止时间。即使 socket 一直没有事件,也必须及时判断超时,不能把事件线程永远留在无限期等待里。
为什么还要管待办任务?业务线程可能提交一项新工作,而事件线程此刻正睡在 epoll_wait 中。仅仅修改内存队列,不会自动让这个等待返回。
Linux 框架常把一个 eventfd 也登记进 epoll。提交方先把任务放入应用队列,再按框架约定写这个 fd;它变为可读,事件循环便有机会醒来处理队列。fd 携带的是唤醒通知,任务本身仍在应用内存里。见 eventfd(2)。
那一百个异步 RPC,存在哪里?
响应字节到达后,框架先取得完整协议消息,再根据请求标识找到调用,最后安排完成通知。比如 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 / kevent | BSD、macOS 的事件通知接口,可管理多种事件来源 |
io_uring | Linux 的提交与完成接口,既支持具体 I/O 操作,也能提交轮询请求 |
| IOCP | Windows 中取得重叠 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 返回 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: EOFafter 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 pollLinux 上还可以运行:
./io-readiness-demo lt
./io-readiness-demo etmacOS 没有 sys/epoll.h,LT/ET 模式需要 Linux 环境。实验只检查就绪与读取的关系,不用于比较几个接口的吞吐量。
至此,我们可以回到最初那一百个查询:不必为每次调用安排一个只负责等待的线程;可以保存调用和连接的进度,由少量线程在事件发生时继续推进。下一篇再沿着这条执行路径,讨论 RPC 的超时、重试与幂等:如果始终等不到成功响应,调用应当怎样结束?