/* MD / 富文本中的 .toc(含博客园搬家等嵌套结构);.toc-box 在侧栏,不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p(:empty 仍占 20px),一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后,紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}
🔥 星光编译者 · 个人主页
📚 学习专栏: 《C/C++ 成长笔记》 · 《Linux 实践手册》 · 《数据结构与算法》
🌄 向云端飞扬,编译属于自己的代码星河。
☕ 写在开篇
你好,这里是 星光编译者。
这里记录我在 C/C++、Linux、数据结构与算法 学习中遇到的真实问题、亲手验证过的代码,以及那些容易被忽略的实现细节。
比起简单罗列结论,我更愿意从问题出发,把一个知识点的来由讲清楚,把“为什么会这样”和“应该怎样解决”说明白,让每一次踩坑都沉淀成可以复用的经验。
如果这篇记录能帮你少绕一点路,或让某个模糊的地方忽然变得清晰,那么这次分享便有了意义。愿我们在一次次阅读、编译与调试中稳步向前,慢慢搭起属于自己的技术世界。
epoll 的三个接口看懂后,最容易产生的错觉是:把 EPOLLET 加到事件掩码里,再把 recv 放进循环,就完成了 ET 服务器。
真正动手后,问题往往出现在更细的地方:读到 EAGAIN 应该继续还是退出?一次 send 没写完,剩下的数据怎么办?监听 socket 同时来了十个连接,只 accept 一次够不够?客户端已经不再发送,服务端是不是可以立刻关闭?
这些问题有一条共同主线:通知只负责提示机会,应用必须保存尚未完成的工作,并在适当时机继续。 ET 模式尤其要求我们把这件事想清楚。
这一篇会先推导读写规则,再给出一份单文件 C++17 回显服务器。它支持 LT 和 ET 两种模式,共用同一套非阻塞状态管理,便于对照实验。
示例约定:Linux、单线程、IPv4 回环地址、字节原样回显。最多 256 个客户端,每连接待发送内容上限 1 MiB。达到容量上限时采用关闭策略;这些是教学程序的策略,不是 epoll 的接口上限。
文章目录
一、LT 与 ET:关键在于能否依赖重复提醒
1.1 从“只读一半”开始推导
假设某条流式连接已经积累 2048 字节,事件循环收到读通知,却只读取 1024 字节,然后回去等待。此时接收缓冲还剩 1024 字节。
在 LT 模式下,未读数据继续满足可读条件,后续等待仍有机会把这个连接交回来。在 ET 模式下,程序不能仅因这些旧数据仍然存在,就依赖下一次等待再次提醒自己。Linux epoll 的 LT/ET 说明

如果应用必须收齐整个请求才响应,而客户端又必须收到响应才继续发送,就可能形成相互等待:服务器等下一次通知,客户端等服务器响应。双方没有崩溃,连接也没断,却再也没有推进。
1.2 ET 不是“每条连接一辈子只通知一次”
后续新数据和状态变化可能继续产生通知;多个变化也可能合并成一批结果。不要把 ET 理解成严格的一次性计数器,更不要把每条通知对应成一次 send 或一个 TCP 报文段。
对编程最有用的规则是:已经知道可以推进的非阻塞操作,应持续推进到当前做不下去,或者把未完成工作明确留在自己的调度队列里。 不能先把工作忘掉,再希望内核重复提醒。
1.3 “读到 EAGAIN”不等于“读到完整消息”
ET 管的是就绪通知,TCP 管的是有序字节流,应用协议才规定消息边界。请求可能只到了一半,就已经暂时无数据;也可能一次读取拿到两条完整请求和第三条的一部分。
因此读到 EAGAIN 只表示当前读取路径暂时无法继续。它不会告诉你业务消息是否完整,也不能拿来充当请求结束标记。本文用纯回显避开分帧规则:收到什么字节,就按原顺序排队回送什么字节。
若以后改成字典查询、HTTP 或长度前缀协议,应另加输入缓冲与解析器,而不是把“这一轮读到的字符串”直接当成完整请求。
二、非阻塞:让“当前做不下去”有一个出口
2.1 为什么循环读取不能配阻塞 fd
假设缓冲里正好有一块数据,第一次 recv 成功取走。然后循环执行第二次 recv,此时客户端尚未发送新内容。如果 fd 是阻塞的,整个线程就停在这条连接上。
非阻塞 fd 在同样情况下返回 -1,并把 errno 设为 EAGAIN 或 EWOULDBLOCK。事件循环得到一个清楚的停点,可以去处理其他连接,而不是赌客户端马上会继续发送。Linux recv 手册
EPOLLET 本身不会自动设置 O_NONBLOCK。把阻塞 fd 登记成 ET,接口未必拒绝你,但这不意味着这种组合适合单线程循环收发。
2.2 保留原标志,再增加 O_NONBLOCK
已有 fd 可以这样设置:
int flags = fcntl(fd, F_GETFL, 0);
if (flags == –1) {
// 处理失败,不能继续使用错误值。
}
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == –1) {
// 处理失败,不能假装现在已经非阻塞。
}
这段展示的是处理顺序;完整调用还需要 <fcntl.h>,错误分支必须实际返回或抛出异常。先读后改,是为了保留原来的文件状态标志。
在 Linux 上,本文直接使用 socket(…, SOCK_NONBLOCK | SOCK_CLOEXEC, …) 创建监听端,再通过 accept4(…, SOCK_NONBLOCK | SOCK_CLOEXEC) 获取非阻塞客户端。这样每个新 fd 的模式在获得时就明确了。
2.3 监听 fd 与客户端 fd 分别设置
不要认为监听 socket 非阻塞,accept 得到的客户端就一定自动继承该状态。Linux 的普通 accept 不继承 O_NONBLOCK;使用 accept4 明确指定可以避免遗漏。Linux accept 手册
两个设置分别影响不同的等待:监听端控制没有待接收连接时 accept 是否阻塞;客户端控制没有输入或输出空间时 recv/send 是否阻塞。设置了其中一个,不能替另一个作保证。
三、读取循环:数据、EOF、EINTR 与 EAGAIN
3.1 每个返回值都对应一种动作

| n > 0 | 取得 n 字节 | 按实际长度追加输出,继续读取 |
| n == 0 | 接收方向读到 EOF | 标记读结束,保留待发送数据 |
| n == -1 且 EINTR | 本次操作被信号打断 | 重试本次操作 |
| n == -1 且 EAGAIN/EWOULDBLOCK | 当前没有更多可读数据 | 退出读取函数,交回控制权 |
| 其他错误 | 无法按当前方式继续 | 回收连接 |
最常见的错误是对 EAGAIN 使用 continue。数据没有凭空到来,下一次调用很可能继续得到相同结果。单线程会不断尝试同一个 fd,既耗 CPU,又耽误其他连接。
所以在本文中,EINTR 才进入重试;EAGAIN 进入让出。两者都通过 -1 返回,但含义完全不同。
3.2 按字节长度保存,不依赖字符串终止符
c.out.append(buf.data(), static_cast<size_t>(n));
这行代码保留了本次读取到的全部字节,包括中间的 \\0。如果写成 c.out += buf.data(),就把网络数据当成以零字符结尾的 C 字符串;可能提前截断,也可能越过实际有效范围继续读取。
同样,没有必要为了“放一个结束符”把有效接收长度永远减一。字节回显只需要明确的地址和长度,文本解析时才根据协议决定怎样解释这些内容。
3.3 不拿短读当作消息结束
本程序统一以 EAGAIN、EOF 或错误作为读取循环的退出条件。一次读取少于缓冲容量,并不是一条业务请求已经完整的证明。
对特定流式设备,有时可以利用短读判断当前状态,但那仍然属于 I/O 层信息,不能替代消息边界。初学时让退出规则保持一致,更容易审查各种分支是否遗漏。
3.4 读得越快,也可能积压得越快
一个客户端不断发送,却不接收回显,应用侧输出缓冲就可能持续增长。只把 socket 设成非阻塞,并不能限制这块内存。
本文把每连接待发送内容限制为 1 MiB。准备追加的新数据超过剩余容量时,关闭该连接。这个策略既可能拒绝慢读客户端,也可能拒绝一次过大的突发输入,因此它是明确的负载约束,不是无损流控。
生产服务可以采用高低水位、暂停读关注、全局内存预算、超时和业务拒绝响应等更精细的办法。这里先保证代码行为可解释:容量不足时有确定结果,不能悄悄丢掉几个字节后假装回显成功。
四、发送循环:保留进度,按需订阅 EPOLLOUT
4.1 可写不保证一次写完
假设输出缓冲中有 100 KiB,send 本次只接受了 20 KiB。剩下的 80 KiB 仍属于应用待完成的工作。返回正数只说明这一部分被接受,不能把整个输出缓冲立即清空。
本文用两个字段记录进度:out 保存排队的字节,sent 表示已经提交给 socket 的前缀长度。下一次发送从 out.data() + sent 开始,长度是 out.size() – sent。

这也解释了为什么连接状态不能只存在于处理函数的局部变量里。函数返回后,剩余响应必须继续存在;否则下一次可写通知来了,也不知道还有什么要发。
4.2 新输出先尝试发送,受阻后再等待
本文采用下面的规则:产生输出后立即调用 flush;能够继续就持续发送;遇到 EAGAIN 就保留进度,确保关注 EPOLLOUT,再返回事件循环;排空输出后移除写关注。Linux send 手册
这里有一个 ET 下特别重要的细节:即使本轮没有携带 EPOLLOUT,读取产生新响应后也会尝试发送。因为此前 socket 可能一直可写,只是应用当时没有内容可发;不能把未来一定出现一个新的可写边缘当作启动发送的条件。

4.3 为什么不永久关注 EPOLLOUT
许多连接在正常空闲时仍有发送空间。如果 LT 模式下长期关注可写,即使没有响应要发送,也可能反复返回事件,形成无意义的工作。
ET 模式也不意味着永久关注就可以忽略状态管理。无论选哪种模式,应用都应该知道“为什么现在需要写通知”。本文把答案限制为一个条件:存在未发送完成的数据。
完整代码计算出 wanted 掩码后,只有与当前保存的 mask 不同时才调用 MOD。这不是接口正确性的必要条件,但可以避免每次处理完事件都进行相同的更新。
4.4 成功发送与对方收到并不是同一句话
send 成功说明本地接受了相应字节,不证明远端应用已经读取或完成业务处理。需要确认交易、持久化或请求执行结果时,必须由应用协议提供对应响应。
如果对端已关闭,发送还可能失败并产生 SIGPIPE。本文使用 MSG_NOSIGNAL 抑制这次发送导致的该信号,同时仍然检查返回值。它不是把失败变成功,只是让程序可以在错误分支里自行决定怎样清理连接。
五、监听 socket 也要正确处理 ET
5.1 一次通知可能对应多个待接收连接
监听 socket 读就绪后,队列里可能已经有多条连接等待 accept。如果采用 ET,只接收一条就回去等待,剩下的连接可能滞留,不能依赖新的通知替你补做旧工作。
因此 accept_all 会一直调用非阻塞 accept4,直到 EAGAIN/EWOULDBLOCK。与读取循环相似,这不是忙等,而是把当前已有工作处理完后立刻退出。

5.2 得到 fd 只是连接进入应用的第一步
每个新客户端还要有自己的连接记录、唯一标识和初始事件掩码。若资源申请或登记失败,已经取得的 fd 也必须被释放。
示例使用 RAII 的 Fd 类型。临时对象若没转移进连接表,离开作用域就关闭;成功进入连接表后,连接表中的对象成为唯一所有者。连接回收时删除记录,就会触发关闭。
达到 256 个客户端时,程序会立即关闭随后接受到的新连接,继续处理当前已保留的客户端。这里的数量限制由代码策略定义,与 epoll_wait 每批 64 个结果没有关系。
5.3 不同 accept 错误采用不同处理
EINTR 与一些针对待接收连接的瞬时网络错误可以继续尝试;EAGAIN 表示本轮已经没有待接收项,应返回;文件描述符或内存耗尽等错误,不能无条件高速重试。
本示例对无法继续工作的监听错误明确退出,由 RAII 清理资源。长期在线服务通常会增加退避、保留 fd、告警和恢复策略。不要把这份教学实现描述成已经覆盖全部运维故障的生产服务器。
六、连接状态:半关闭、错误与对象生命周期
6.1 读结束后,可能还有输出
请求方发送完内容后执行 shutdown(SHUT_WR),可以继续接收回显。服务器读取完尾部字节,再得到 recv == 0,此时把 eof 设为 true。
后续不再关注新输入,但仍保留尚未发送的数据。只有输出也排空,正常半关闭路径才真正回收连接。

这条规则让“输入结束”和“连接对象销毁”不再被错误地合并成一个动作。实际协议也可以约定更复杂的结束过程,但需要把相应状态写清楚。
6.2 事件位只是提示,最终还看操作结果
EPOLLRDHUP 适合提示流式连接对端关闭或关闭发送方向;EPOLLHUP 表示挂断;EPOLLERR 表示错误状态。错误和挂断可以被自动报告,不必显式订阅,半关闭提示则在本例中主动关注。Linux epoll_ctl 事件定义
HUP 到来时仍可能存在尚未读取的内容,所以不能看到该位就无条件跳过读取。本文在没有 EPOLLERR 的情况下先尝试取走剩余输入,并尝试发送;对完全挂断则结束,不继续保留等待。
EPOLLERR 路径会读取 SO_ERROR 用于诊断,然后关闭连接。这是一种明确的失败策略,不承诺故障连接上的待发送内容一定能够送达。
6.3 fd 可能复用,连接身份应当稳定
假设旧客户端 fd 为 12,关闭后一个新客户端又分到 12。若异步任务或缓存事件只保存整数 12,很容易把两个时期的连接误认为同一个对象。
本文把递增 uint64_t ID 放进 epoll_event.data.u64,连接表按 ID 查找。0 专门代表监听 socket,普通客户端从 1 开始。旧 ID 已不存在时,直接忽略对应结果;代码也对计数回绕作了显式拒绝。

这并不自动解决一切并发问题。示例的前提仍然是单线程独占这些 fd,没有其他线程绕过连接表自行关闭资源,也没有外部异步回调持有连接引用。以后加入工作线程时,还要重新设计任务、连接对象和事件之间的生命周期。
6.4 回收后必须立即停止使用引用
handle 里先取得 Connection& c。一旦调用 drop(id),连接表元素被删除,c 就不能继续使用。所以每条关闭分支后面都立即 return。
这是审查事件代码时非常实用的一条线索:从每个 close、erase 或销毁连接的位置向后看,确认没有继续访问旧引用,也没有继续处理同一事件里的另一个位。
七、完整实现:可切换 LT/ET 的回显服务器
7.1 先读这张结构表,再看代码
| Fd | 独占描述符,禁止复制,允许转移 |
| Connection | 保存 fd、输出内容、发送偏移、EOF 和关注掩码 |
| accept_all | 接收当前待接收连接,建立应用状态并登记 |
| read_all | 持续读取到 EAGAIN、EOF、上限或错误 |
| flush | 持续发送到排空、EAGAIN 或错误 |
| handle | 处理事件并更新下一轮关注条件 |
| run | 等待一批事件,只分发返回的有效项 |
默认绑定 127.0.0.1,所以测试客户端也在同一 Linux 环境运行。程序不负责公网接入、TLS、应用协议鉴权或跨机器配置。
7.2 单文件代码
保存为 epoll_echo.cpp,也可以直接使用文章包中 code/epoll_echo.cpp。
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#include <array>
#include <cerrno>
#include <charconv>
#include <cstdint>
#include <cstdio>
#include <iostream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <system_error>
#include <unordered_map>
#include <utility>
[[noreturn]] static void fail(const char* what) {
throw std::system_error(errno, std::generic_category(), what);
}
class Fd {
int fd_ = –1;
public:
explicit Fd(int fd = –1) : fd_(fd) {}
~Fd() { if (fd_ >= 0) close(fd_); }
Fd(const Fd&) = delete;
Fd& operator=(const Fd&) = delete;
Fd(Fd&& other) noexcept : fd_(std::exchange(other.fd_, –1)) {}
int get() const { return fd_; }
};
struct Connection {
Fd fd;
std::string out;
size_t sent = 0;
bool eof = false;
uint32_t mask = 0;
explicit Connection(Fd socket) : fd(std::move(socket)) {}
};
class Server {
static constexpr size_t MAX_CLIENTS = 256;
static constexpr size_t MAX_PENDING = 1024 * 1024;
Fd ep_;
Fd listener_;
bool et_;
uint64_t next_id_ = 1; // 0 专用于监听 socket。
std::unordered_map<uint64_t, Connection> clients_;
uint32_t mode() const { return et_ ? static_cast<uint32_t>(EPOLLET) : 0U; }
void ctl(int op, int fd, uint32_t mask, uint64_t id) {
epoll_event ev{};
ev.events = mask;
ev.data.u64 = id;
if (epoll_ctl(ep_.get(), op, fd, &ev) < 0) fail("epoll_ctl");
}
void drop(uint64_t id) {
auto it = clients_.find(id);
if (it == clients_.end()) return;
// 单线程独占 fd;DEL 成功并不等于 close。
if (epoll_ctl(ep_.get(), EPOLL_CTL_DEL, it->second.fd.get(), nullptr) < 0)
std::perror("epoll_ctl DEL");
clients_.erase(it); // Fd 析构,执行 close。
}
static bool retry_accept(int e) {
return e == EINTR || e == ECONNABORTED || e == ENETDOWN ||
e == EPROTO || e == ENOPROTOOPT || e == EHOSTDOWN ||
e == ENONET || e == EHOSTUNREACH || e == EOPNOTSUPP ||
e == ENETUNREACH;
}
void accept_all() {
for (;;) {
Fd socket(accept4(listener_.get(), nullptr, nullptr,
SOCK_NONBLOCK | SOCK_CLOEXEC));
if (socket.get() < 0) {
const int e = errno;
if (e == EAGAIN || e == EWOULDBLOCK) return;
if (retry_accept(e)) continue;
// 资源耗尽等故障在此示例中明确退出,避免空转。
fail("accept4");
}
if (clients_.size() >= MAX_CLIENTS) continue; // RAII 关闭新 fd。
if (next_id_ == 0) throw std::runtime_error("connection id exhausted");
const uint64_t id = next_id_++;
auto [it, inserted] = clients_.try_emplace(id, std::move(socket));
if (!inserted) throw std::runtime_error("duplicate connection id");
Connection& c = it->second;
c.mask = EPOLLIN | EPOLLRDHUP | mode();
ctl(EPOLL_CTL_ADD, c.fd.get(), c.mask, id);
}
}
bool read_all(Connection& c) {
// 去掉已发送前缀,使 out 只保留尚未发送的内容。
if (c.sent != 0) {
c.out.erase(0, c.sent);
c.sent = 0;
}
std::array<char, 16384> buf{};
for (;;) {
const ssize_t n = recv(c.fd.get(), buf.data(), buf.size(), 0);
if (n > 0) {
const size_t count = static_cast<size_t>(n);
if (count > MAX_PENDING – c.out.size()) {
std::cerr << "pending limit: closing slow/burst client\\n";
return false;
}
c.out.append(buf.data(), count); // 保留二进制零字节。
continue;
}
if (n == 0) { c.eof = true; return true; }
if (errno == EINTR) continue;
if (errno == EAGAIN || errno == EWOULDBLOCK) return true;
return false;
}
}
bool flush(Connection& c) {
while (c.sent < c.out.size()) {
const ssize_t n = send(c.fd.get(), c.out.data() + c.sent,
c.out.size() – c.sent, MSG_NOSIGNAL);
if (n > 0) { c.sent += static_cast<size_t>(n); continue; }
if (n < 0 && errno == EINTR) continue;
if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return true;
return false; // 包括有待发数据时异常的 0 返回。
}
c.out.clear();
c.sent = 0;
return true;
}
void handle(uint64_t id, uint32_t events) {
auto it = clients_.find(id);
if (it == clients_.end()) return; // 忽略已经失效的结果。
Connection& c = it->second;
if (events & EPOLLERR) {
int error = 0;
socklen_t len = sizeof(error);
if (getsockopt(c.fd.get(), SOL_SOCKET, SO_ERROR, &error, &len) < 0)
std::perror("SO_ERROR");
else
std::cerr << "socket error=" << error << '\\n';
drop(id);
return;
}
if (!c.eof && (events & (EPOLLIN | EPOLLRDHUP | EPOLLHUP))) {
if (!read_all(c)) { drop(id); return; }
}
// 新产生输出时立刻尝试发送,不等待一个未必新出现的可写边缘。
if (!flush(c)) { drop(id); return; }
if (c.eof && c.out.empty()) { drop(id); return; }
if (events & EPOLLHUP) { drop(id); return; } // 完全挂断不继续滞留。
uint32_t wanted = mode();
if (!c.eof) wanted |= EPOLLIN | EPOLLRDHUP;
if (!c.out.empty()) wanted |= EPOLLOUT;
if (wanted != c.mask) {
ctl(EPOLL_CTL_MOD, c.fd.get(), wanted, id);
c.mask = wanted;
}
}
public:
Server(uint16_t port, bool et)
: ep_(epoll_create1(EPOLL_CLOEXEC)),
listener_(socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0)),
et_(et) {
if (ep_.get() < 0 || listener_.get() < 0)
throw std::runtime_error("epoll/socket creation failed");
int yes = 1;
if (setsockopt(listener_.get(), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
fail("SO_REUSEADDR");
sockaddr_in addr{};
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
if (bind(listener_.get(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0)
fail("bind");
if (listen(listener_.get(), 128) < 0) fail("listen");
ctl(EPOLL_CTL_ADD, listener_.get(), EPOLLIN | mode(), 0);
}
void run() {
std::array<epoll_event, 64> ready{};
for (;;) {
const int n = epoll_wait(ep_.get(), ready.data(),
static_cast<int>(ready.size()), –1);
if (n < 0) {
if (errno == EINTR) continue;
fail("epoll_wait");
}
for (int i = 0; i < n; ++i) {
const auto& ev = ready[static_cast<size_t>(i)];
if (ev.data.u64 == 0) {
if (ev.events & (EPOLLERR | EPOLLHUP))
throw std::runtime_error("listener error/hangup");
if (ev.events & EPOLLIN) accept_all();
} else {
handle(ev.data.u64, ev.events);
}
}
}
}
};
int main(int argc, char** argv) try {
if (argc != 3) throw std::runtime_error("usage: epoll_echo PORT lt|et");
const std::string_view port_text(argv[1]), mode(argv[2]);
unsigned port = 0;
const auto [end, ec] = std::from_chars(port_text.data(),
port_text.data() + port_text.size(), port);
if (ec != std::errc{} || end != port_text.data() + port_text.size() ||
port == 0 || port > 65535 || (mode != "lt" && mode != "et"))
throw std::runtime_error("PORT must be 1..65535; mode must be lt or et");
Server server(static_cast<uint16_t>(port), mode == "et");
std::cout << "listen 127.0.0.1:" << port << " mode=" << mode << std::endl;
server.run();
} catch (const std::exception& e) {
std::cerr << e.what() << '\\n';
return 1;
}
7.3 顺着一条连接读代码
客户端进入 accept_all 后得到 ID 和初始的读关注。读事件到来,read_all 把实际字节追加到 out;flush 立即尝试排空。若发送受阻,sent 保留进度,下一轮掩码中包含 EPOLLOUT。
下一次收到写事件时,即使没有新输入,handle 仍会调用 flush。发送完后,out 清空、sent 归零,再通过 MOD 撤掉写关注。
若同时收到读结束,eof 保持为 true。程序不会重新开读关注,也不会因为第一次发送没发完就丢弃响应。只有剩余输出发完,才进入正常回收路径。
7.4 为什么 LT 和 ET 可以共用实现
两种模式都允许非阻塞读取、维护输出缓冲和循环接收连接。本文选择主动推进到暂时无法继续,因此同样的状态管理对两种模式都成立。
差异集中在注册掩码中的 EPOLLET。这不意味着“任何 LT 程序加一个标志就能变成正确 ET 程序”,而是因为这份程序从一开始就满足了 ET 对未完成工作的处理要求。
八、编译与验证:让边界条件真正发生
8.1 编译并启动
在 Linux 下进入文章包目录:
g++ -std=c++17 -O2 -Wall -Wextra -Wpedantic -Werror \\
code/epoll_echo.cpp -o /tmp/epoll_echo
/tmp/epoll_echo 9090 et
看到 listen 127.0.0.1:9090 mode=et 后,在另一个终端运行客户端。需要比较 LT 时,停止当前程序,再执行 /tmp/epoll_echo 9090 lt。
端口参数必须完整地解析为 1~65535 范围内的整数。9090abc、-1、0、超范围值以及未知模式都会被拒绝,避免表面上启动成功、实际绑定的端口却不是用户指定值。
8.2 最小客户端:二进制与半关闭一起验证
import socket
payload = b"hello\\x00epoll\\n" * 1000
with socket.create_connection(("127.0.0.1", 9090), timeout=3) as s:
s.sendall(payload)
s.shutdown(socket.SHUT_WR)
chunks = []
while True:
block = s.recv(65536)
if not block:
break
chunks.append(block)
reply = b"".join(chunks)
assert reply == payload, (len(reply), len(payload))
print("PASS:", len(reply), "bytes")
这里没有假定一次 recv 可以收齐响应,而是读到 EOF 后按整体内容比较。中间特意加入零字节,能够发现按 C 字符串拼接造成的截断问题。
客户端半关闭后还能收到完整响应,也验证了服务端没有在输入 EOF 时过早销毁待发送内容。这个小程序的负载远小于教学服务器的缓冲上限。
8.3 自动验证应该覆盖什么

文章包提供 code/verify_echo.py,传入编译后的服务器路径即可自动启动两种模式并验证:
python3 code/verify_echo.py /tmp/epoll_echo
验证包含二进制回显、分段发送、同连接连续交互、半关闭、多个空闲连接旁的活跃请求、并发连接、反复重连、突发数据与慢读客户端。检查标准是收发字节一致和服务仍能处理其他连接,而不是日志里出现一句“收到消息”。
对于非常大的突发发送,需要区分两种测试目标:验证正常业务字节完整性时,应遵守服务器容量约定;验证上限策略时,则可以故意触发关闭,不能把“拒绝超限客户端”误判成正常回显丢包。
8.4 本次验证与适用范围
本篇完整程序已在 Ubuntu 24.04 / WSL2 中使用 GCC 13.3.0,以 -Wall -Wextra -Wpedantic -Werror 编译通过。LT、ET 各通过 11 组服务场景,另通过 8 组非法参数检查;场景包括 32 条活跃连接与 40 条空闲连接并存、100 次重连、256 客户端容量限制、输出上限关闭后继续服务,以及 fd 数回到基线。
补充验证中,仅对被测服务器缩小 SO_SNDBUF,通过观测真实系统调用结果,确认两种模式都实际发生了部分发送、发送 EAGAIN 和接收 EAGAIN。在这些条件下,同一组客户端检查仍然通过。这个观测器只用于本次验证,正常编译运行不依赖它。
这里仍然没有宣称完成高并发压测。一次本机功能检查不能证明在上万连接、丢包、长期运行或复杂业务下达到某个性能指标。想比较 LT 和 ET,也需要在相同业务与负载下单独测量,不能从模式名称直接得出快慢。
九、ET、ONESHOT、惊群与公平性
9.1 ET 与 ONESHOT 是两种不同约束
ET 影响就绪通知方式;EPOLLONESHOT 则在一次事件交付后禁用该监控项的后续通知,直到应用重新使能。需要继续监听时,通常通过 EPOLL_CTL_MOD 重新设置完整掩码,而不是对仍已登记的 fd 再次 ADD。
ONESHOT 常用于协调“同一连接当前由谁处理”,但它不是互斥锁,也不会自动保护连接对象的所有访问。工作任务完成、连接已经关闭、旧任务迟到这些情况,仍需应用自己安排。

本文是单线程事件循环,没有用 ONESHOT。先让每条连接的读写状态正确,再讨论多线程调度,会比一开始叠加所有标志更容易验证。
9.2 惊群问题先明确“谁在等谁”
惊群通常指一个事件使多个等待者被唤醒,但实际工作只需要少数处理者完成。分析 epoll 时,要区分多个线程等同一实例,与多个实例关注同一个监听 fd;它们不是一个完全相同的场景。
Linux 提供 EPOLLEXCLUSIVE 用于特定的独占唤醒注册场景,但有使用限制,也不能把它概括成“加上就保证永远只唤醒一个”。普通单线程示例无需为了这个名词增加无关复杂度。
如果以后设计多进程或多线程接入,先画出监听 fd、epoll 实例和等待线程之间的实际关系,再选择唤醒和负载分配策略。
9.3 一直读到 EAGAIN,会不会饿死其他连接
可能。若某条连接持续产生数据,每次取走一些后又有新数据到来,一个不设预算的读取循环就可能占据线程很久。不断接收新连接的循环同样有公平性问题。
本文保留完整 drain 的教学写法,并用连接数和输出上限限制一部分资源消耗,但没有实现严格的每连接时间片。上限控制与公平调度不是同一件事,不能互相替代。
更成熟的实现可以设置每次处理的字节数或时间预算。LT 下,剩余可读条件有利于后续继续调度;ET 下,如果尚未读到 EAGAIN 就主动停止,需要把这个 fd 记入应用自己的就绪队列,下轮主动继续处理,而不是完全交给新的内核通知。
9.4 暂停读取也要考虑恢复后的旧数据
如果采用高低水位策略,输出积压过多时暂停读关注,降到低水位后再恢复,ET 下尤其需要明确恢复动作。应用应重新检查并推进读取,或安排确定的续处理路径,不能假设“重新允许读之后,总有新数据再来触发”。
这个问题与公平调度其实是同一条原则:只要主动停止时尚有已知工作,应用就需要保存它。ET 省掉了一部分重复通知,也把对未完成工作的管理责任交给了程序。
十、排错清单与动手自测
10.1 从现象回查状态
| ET 下小请求正常,大请求卡住 | 是否只 recv 一次就回去等 |
| CPU 持续很高,却没有新数据 | 是否对 EAGAIN 原地 continue |
| 接入高峰时一部分连接一直等待 | 监听端 ET 是否循环 accept 到 EAGAIN |
| 回显偶尔少一截 | 是否忽略部分发送、覆盖未发送后缀 |
| 内容遇到零字节就截断 | 是否按 C 字符串追加而未传长度 |
| 空闲连接让事件循环不断返回 | 是否永久关注 EPOLLOUT,或忽略 EOF |
| 客户端半关闭后响应消失 | 是否在 recv == 0 时立刻丢掉输出 |
| 偶尔操作错连接 | 是否把可复用的 fd 当永久身份 |
| ONESHOT 后再也没有事件 | 是否忘记通过 MOD 重新使能 |
| 开了 ET 却仍被一条连接拖住 | 是否仍有阻塞 I/O 或无限业务处理 |
日志也应围绕这些状态写:操作返回值、立即保存的 errno、连接 ID、未发送字节数、关注掩码。避免在失败后先执行其他系统调用,再读取已经可能变化的 errno。
10.2 七道自测题
问题一:recv 返回 -1,是否一定要关闭连接?
不一定。先看 errno;EINTR 可以重试,EAGAIN/EWOULDBLOCK 表示当前暂时无法推进。
问题二:读到 EAGAIN 后一直重试,能否更快等到新数据?
这种写法会占用事件循环。应保留状态并退出当前读取,让集中等待负责下一次机会。
问题三:send 返回 300,原计划发 1000 字节,怎样处理?
记录已经推进的 300 字节,从剩余 700 字节继续;若受阻,保留剩余内容直到以后可写。
问题四:ET 监听端收到一次通知,是否只接受一个连接?
不应这样假设。要持续非阻塞接收,直到当前没有更多连接可取,或进入明确的调度策略。
问题五:EPOLLRDHUP 来了,能不能先不读直接 close?
若协议还需要处理尾部输入或发送响应,就不能直接丢弃。读取到 EOF 与输出排空应分别记录。
问题六:注册 ONESHOT 后处理完毕,重新 ADD 可以吗?
该项通常仍在关注集合中,应使用 MOD 重新使能,并恢复需要的完整掩码。
问题七:ET 一定比 LT 更快吗?
不能保证。通知次数、系统调用、工作量分配与业务负载共同决定结果,应通过可比较的实验判断。
10.3 真正需要留下的几个习惯
非阻塞操作按实际返回值推进;暂时不能做就让出;尚未完成的输出跨轮次保存;输入结束与连接销毁分开;更新关注条件时反映当前状态;销毁对象后立即停止使用它。
掌握这些习惯后,epoll 不再是一组需要硬记的宏,而是一个能配合连接状态稳定推进工作的等待机制。接下来学习 Reactor,就可以把注意力转向如何组织处理器、任务和执行上下文,而不必重新修补每一次读写。
🌄 向云端飞扬,编译属于自己的代码星河。 建议先用同一份测试分别运行 LT 和 ET,再主动放慢客户端读取速度。只有亲眼看到“写不下了,但别的连接仍然能继续”,事件驱动的意义才会变得具体。
网硕互联帮助中心



评论前必须登录!
注册