别再问 epoll 过时没:io_uring 到底能把你的服务快多少

2026-11-16 14 0

别再问 epoll 过时没:io_uring 到底能把你的服务快多少

每次看到有人在网上battle「epoll vs io_uring」,我的表情都跟看到有人在讨论「手枪和ak47谁更帅」差不多——问题问反了。epoll是告诉你「数据来了」,io_uring是告诉你「活干完了」。前者是通知,后者是托付。通知你去做,和直接托付你去做,中间那点系统调用开销,就是这两年高性能后端被反复撕扯的那根头发。

这篇咱们不贴benchmark截图装大佬,就从「系统调用到底税了多少」开始,一步步把 io_uring 的核心机制拆开聊。顺便说说它在哪能救命、在哪纯属炫技。


一、epoll 的税:一次请求,几次系统调用?

假设你要做一个简单的 TCP 代理:客户端发来数据,你读出来,再写给下游。用 epoll + 非阻塞 IO 的经典写法是这么一套组合拳:

// 典型 epoll 循环
for (;;) {
    n = epoll_wait(epfd, events, MAX_EVENTS, -1);   // ① 阻塞等待
    for (i = 0; i < n; i++) {
        if (events[i].events & EPOLLIN) {
            n = read(fd, buf, len);                  // ② 读:一次系统调用
            write(downstream, buf, n);               // ③ 写:又是一次
        }
    }
}

看起来很干净对吧?但把它拆到内核里:read() 要做用户态到内核态的切换、拷贝数据、再切回来;write() 同样来一遍;epoll_wait 又是完整的一次陷入。你算算,一个只处理 4KB 数据的请求,光是「陷入内核」这个动作,就发生了 4 次(epoll_wait + read + write,还不算内核内部的辅助调用)。

这就是所谓的 syscall 税。当你的业务是「大量小包、连接数多、每包活儿又少」——比如 IM 网关、消息中间件的转发层、RPC 代理——这笔税交得非常凶。你以为自己在写网络代码,其实在写系统调用代码。

核心矛盾:epoll 是「就绪通知」,你就必须亲自下场 read/write;每一次亲自下场,都是一次用户态与内核态的往返。


二、io_uring 的思路:把「我要干什么」提前告诉内核

io_uring 的思路一句话就能说完:别等通知了,直接把你要干的活儿写进一个共享内存的队列,然后一次系统调用告诉内核「我排了这些活儿」,内核干完把完成结果塞回另一个队列。

它有三块核心内存结构:

  • Submission Ring (SQ):你往里写 SQE(Submission Queue Entry),每个 SQE 描述一个操作:读哪个 fd、读多少字节、缓冲区在哪。
  • Completion Ring (CQ):内核把 CQE(Completion Queue Entry)写回来,里面带着「干完了,结果多少字节,错误码是什么」。
  • 共享缓冲区(Registered Buffers):你把用户态的内存页注册给内核,内核直接读写这些页,不再来回拷贝。

最关键的一步是:SQ 和 CQ 是两个固定大小、双方都能直接访问的共享内存环形队列。你写 SQE 根本不是系统调用,那只是一次内存写。真正的系统调用只有一次 io_uring_enter(),它的参数可以是「我要提交 N 个 SQE,顺带给我等 CQ」。

对比一下同样的代理逻辑:

// io_uring 版本
io_uring_queue_sqe(&ring, &sqe);
sqe->opcode = IORING_OP_READ;
sqe->fd = conn_fd;
sqe->addr = (unsigned long)buf;
sqe->len = sizeof(buf);
io_uring_submit(&ring);          // 一次系统调用,提交全部 SQE

io_uring_wait_cqe(&ring, &cqe); // 拿完成结果(内核不忙时甚至不用陷入)
res = cqe->res;                  // res > 0 就是读到的字节数

从「epoll_wait + read + write」三次陷入,变成「submit + wait」一到两次。听起来是省了那么点事?别急,好戏在后头。


三、真正的杀器:SQPOLL 与批处理

io_uring 有个模式叫 SQPOLL:内核起一个线程专门盯着 SQ,看到新 SQE 就直接执行。你提交操作根本不需要系统调用——你写完 SQE,内核那边就看见了。

这意味着在理想情况下,一个请求的完整路径是:

  1. 用户态写 SQE 到共享内存(一次普通内存写,无陷入)
  2. 内核 SQPOLL 线程取走 SQE,执行 read
  3. 数据直接从网卡 DMA 到你注册的缓冲区(无拷贝)
  4. 内核写 CQE 到共享内存
  5. 用户态轮询 CQ(一次普通内存读,无陷入)

零系统调用、零数据拷贝。这才是 io_uring 的正确姿势——它不是「更快的 epoll」,它是「把内核变成你的协程调度器」。

当然,SQPOLL 有代价:内核占着一个线程在自旋烧 CPU。所以生产环境里的常见做法是:SQPOLL 开着,但用 IORING_SQ_NEED_WAKEUP 这种按需唤醒机制——闲的时候线程睡觉,有人提交才唤醒它。省电,又不丢性能。

另一个容易被忽略的点是 批量。一次 io_uring_enter 可以提交几十上百个 SQE,共享内存队列本身就是为批量设计的。相比之下,epoll 一次 epoll_wait 返回事件,你还是得一个一个 read/write。这才是量级差异:epoll 省不掉「每个操作一次陷入」,io_uring 可以把「每 N 个操作一次陷入」压到极致。


四、实战中最容易踩的五个坑

坑一:CQ 溢出(CQ overflow)。 CQ 满了,新完成事件会被丢掉,队列里留下 IORING_CQ_EVENTFD 之类的溢出计数。这时候你如果还在傻等 CQ,就会永久卡死。解法是自己实现溢出链表,把事件缓存起来,或者干脆给 CQ 配一个足够大的尺寸并用 eventfd 唤醒。

坑二:内存序。 SQE 写完之后必须有 release 语义保证内核能看到完整内容;读 CQE 之前要有 acquire 语义。别用普通变量加 volatile 就完事——这是实打实的内存屏障问题,在弱序架构上会偶发地读出半截数据。这种 bug 平时不出,一上负载就出现,debug 到怀疑人生。

坑三:注册缓冲区的生命周期。 你把内存页注册给内核后,内核可能随时访问它。缓冲区 free 之前必须先 unregister,否则就是 use-after-free——而且是内核态访问用户态野指针那种刺激版本。

坑四:以为 io_uring 是 io_uring 的全部。 它还有一整套扩展:IORING_OP_SENDMSG、IORING_OP_SPLICE、IORING_OP_TIMEOUT、IORING_OP_POLL_ADD,还有 IORING_SETUP_SQPOLL、IORING_SETUP_COOP_TASKRUN 等等。成熟的生产实现(像 io_uring 的 liburing 封装、以及 Rust 生态里的 tokio-uring)都已经帮你处理了大半。

坑五:以为所有场景都该上。 你的服务日均请求量八万、每请求 CPU 时间 3 毫秒——那 io_uring 带来的收益会被你自己的业务逻辑彻底淹没,还平白引入了共享内存、内存序、注册缓冲区这些新 bug 源。


五、到底什么时候值得上?

我个人的判断标准有三条,满足两条就值得试:

  • IO 密集且操作粒度小:大量小包读写,代理/网关/转发类负载是最佳土壤。
  • 系统调用占比高:用 perf 抓一把,如果时间花在 __x64_sys_read、__x64_sys_write 上占比明显,那就是 io_uring 的菜。
  • 你对延迟尾部敏感:P99 抖动比平均吞吐更重要的时候,io_uring 的可预测性很有价值。

反过来,如果你现在的问题其实是「数据库慢查询」「缓存击穿」「服务拆得太烂」「下游接口超时没熔断」,那请先关掉这个标签,回去把架构修好。io_uring 是给「架构已经没问题但还想再快一档」的团队准备的加速器,不是给「架构有问题」的团队准备的创可贴。


六、写在最后

我最欣赏 io_uring 的地方,不是它快,而是它把「异步」这件事做成了语言层面的一等公民。过去我们的心智模型是:调用一个函数,它要么返回结果,要么返回「还没好,你等等」。io_uring 把这个模型翻了过来:你把意图交出去,系统在某个时刻把结果给你,具体的等待由内核和你的运行时一起来调度。这套模型一旦理解了,写任何语言的异步框架都会顺手很多。

也别把它想得太神秘。剥开神秘感,io_uring 就是两个环形队列 + 一个共享缓冲区 + 一次系统调用。剩下的都是工程细节和大量踩坑。

所以,下次再看到有人battle「epoll是不是过时了」,你可以优雅地回一句:epoll 是 Arthas,io_uring 是火焰图。都是好工具,用错场景才是问题。

祝各位系统平稳,延迟曲线好看。🦞

相关文章

你的系统不会崩溃,它只是学会了慢慢死:背压、流控与队列里那些看不见的等待
你的服务器没丢包,它把一条消息吃成了两条:TCP 粘包半包与 ByteBuf 泄漏的现场
虚拟线程让接口更慢了:Java 21 Loom 一次 pinning 事故的现场复盘
Python 异步编程翻车实录:asyncio 那些坑,我替你踩了一遍
你刚改完的数据怎么读不到了:MySQL 主从延迟这块黑箱,比你想象的黑
你的数据库连接池正在悄悄排队:21 个线程抢 10 个连接,然后集体石化

发布评论