异步 I/O 的两种范式:Readiness 与 Completion

发布: 2026-10-27   上次更新: 2026-10-28   分类: 系统设计 计算机网络 编程语言   标签: architecture network linux performance rust golang zig

文章目录

构建高性能网络服务和系统运行时,离不开异步 I/O(Asynchronous I/O)。

在操作系统与主流编程语言中,异步 I/O 主要分为两条技术路线:

底层的 I/O 机制往往决定了上层编程语言的异步抽象设计:为什么 Go 能够以纯同步的代码写出高并发?为什么 Rust 的 Future 与 epoll 天然契合,却在面对 io_uring 时遇到缓冲区所有权借用冲突?为什么 Zig 会选择直接基于完成模型设计标准库?为什么 Windows 体系最早催生了现代的 async/await 语法?

本文在 Antigravity CLI (agy) 协助下完成,从操作系统内核、语言运行时抽象与实际工程案例三个层面,梳理这两类模型的实现原理与选型权衡。


核心范式与心智模型

在非阻塞 I/O 的交互中,应用层与操作系统内核之间的数据传递可以抽象为两个核心动作:

  1. 等待数据就绪(网卡收到网络报文、磁盘完成物理寻道);
  2. 搬运数据(在用户空间与内核空间之间拷贝内存字节)。

两大范式的根本分歧,在于第二步“搬运数据”的时机与执行主体。下方的时序图展示了二者在系统调用、阻塞点与数据流向上的差异:

  sequenceDiagram
    autonumber
    actor App as 应用程序 (User Space)
    participant Kernel as 操作系统内核 (Kernel)
    participant HW as 网卡 / 磁盘 (Hardware)

    Note over App,HW: 【范式 1】Readiness-based(就绪型通知 / Reactor 模式)
    App->>Kernel: 1. 注册关注状态 (epoll_ctl: 监听 fd 是否可读)
    HW-->>Kernel: 数据到达硬件,存入内核 Socket 缓冲区
    Kernel-->>App: 2. 通知就绪 (epoll_wait: fd 可读,但数据仍在内核中)
    App->>App: 此时才临时分配或借用 Buffer
    App->>Kernel: 3. 发起同步系统调用 read(fd, buf)
    Kernel->>App: 4. 内核将数据从内核空间拷贝至用户 Buffer

    Note over App,HW: 【范式 2】Completion-based(完成型通知 / Proactor 模式)
    App->>Kernel: 1. 提交具体操作并交出 Buffer 内存: read(fd, buf)
    Note over App: 应用立即返回,无需阻塞,继续处理其他业务
    HW-->>Kernel: 数据到达硬件
    Kernel->>App: 2. 内核 / DMA 直接将数据写入用户已提交的 Buffer
    Kernel-->>App: 3. 投递完成通知 (CQE / IOCP 包: 操作已完成)
    App->>App: 收到通知时,Buffer 中已是就绪数据,直接就地消费

生命周期对照

交互阶段Readiness-based (就绪型 / Reactor)Completion-based (完成型 / Proactor)
1. 初始注册 / 提交应用告诉内核:“我对这个 fd 的就绪状态感兴趣”
• 不预先提供内存 Buffer
应用告诉内核:“帮我把这个 fd 的数据读入这段内存”
• 必须提前交出 Buffer 内存指针
2. 硬件数据到达数据到达网卡后,暂存在内核空间的 Socket 缓冲区内核或 DMA 直接将硬件数据写入用户 Buffer
3. 事件通知内容内核通知应用:“数据已经就绪,你自己来读”内核通知应用:“操作已经完成,直接消费数据”
4. 实际数据拷贝应用临时分配 Buffer,再次调用 read() 同步等待内核把数据拷贝过来零二次系统调用,收到通知时数据已在应用内存中

Readiness-based

Readiness-based(基于就绪通知)模型通常对应架构设计中的 Reactor 模式。其核心心智模型为:

“内核通知应用:数据已经就绪,你自己来读;或者缓冲区空了,你自己来写。”

应用程序向内核表达的是对状态变更的兴趣(Interest)。内核在 Socket 接收缓冲区有数据可读时,仅仅发回一个信号通知“准备好了”。此时数据依然停留在内核空间的 Socket 缓冲区中,必须由应用程序主动发起后续的系统调用(如 read()、recv())将数据从内核空间拷贝至用户态内存。

Dan Kegel 在 1999 年的论文 The C10K problem 中论述了传统多线程阻塞模型的局限,基于就绪通知的多路复用从此成为支撑高并发网络连接的常见解法。

机制优劣:


Completion-based

Completion-based(基于完成通知)模型通常对应架构设计中的 Proactor 模式。其核心心智模型为:

“应用程序告诉内核:这是我的缓冲区地址,帮我读取 4KB 数据;读完之后通知我。”

应用程序向内核提交的是具体的执行指令(Operation),并将用户空间的缓冲区指针借出给内核。内核在后台负责处理,并在硬件/网卡/磁盘数据就绪时,直接由内核(或通过 DMA 硬件)把数据写入应用程序预先指定的缓冲区。当数据全部传输或写入完毕后,内核通过完成队列将“完成结果(状态码、实际字节数)”告知应用程序。

这一设计在 Linux 内核维护者 Jens Axboe 撰写的 Efficient IO with io_uring (2019) 中得到了系统阐述,为 Linux 引入了原生的高性能完成型 I/O 机制。

机制优劣:


语言异步机制与 OS 模型

操作系统内核提供底层的系统调用与事件接口(如 epoll_wait、io_uring_enter、GetQueuedCompletionStatus)。编程语言则需要设计相应的语法与并发运行时,将底层的就绪或完成事件转化为具体的编码模型。

理解不同语言的异步机制,可以从推进模型(控制流由谁驱动)与栈模型(挂起时现场存放在哪里)两个正交维度切入:

维度一:推进模型(谁驱动进度)

维度二:栈模型(现场存放在哪)

 1[ Stackless Call Chain & Event Loop Execution Flow ]
 2
 3  Phase 1: Downward Invocation        Phase 2: Unwind & Yield to Loop     Phase 3: Event Loop Resumes Task
 4=================================   ===================================   ================================
 5[ Event Loop / Task Executor ]      [ Event Loop / Task Executor ]        [ Event Loop / Task Executor ]
 6              |                                   ^                                     |
 7       (1) poll/invoke                     (6) returns `Pending`                 (7) I/O ready! Re-poll
 8              v                                   |                                     v
 9      process_request()                   process_request()                     process_request()
10              |                                   ^                                     |
11       (2) awaits                          (5) returns `Pending`                 (8) resumes at await
12              v                                   |                                     v
13       parse_config()                      parse_config()                        parse_config()
14              |                                   ^                                     |
15       (3) awaits                          (4) returns `Pending`                 (9) gets data & parses
16              v                                   |                                     v
17       read_remote()                       read_remote()                            [ Completed ]
18              |                                   |
19              +--- Not ready: registers OS I/O ---+
20                   Thread stack completely freed;
21                   Event Loop runs other tasks.

从上述流程中可以看出:为了把第 (4) 步底层的 Pending 信号原路 return 返回给顶层的 Event Loop,调用链中间的 parse_config 哪怕只是一个简单的解析函数,也必须被迫声明为 async 并配合 await。如果中间任何一层是普通同步函数,它就无法透传未完成状态,整个退栈链条就会被切断。

而在有栈协程(如 Go / Zig Fiber)中,中间的 parse_config 只是一个普通的纯同步函数,哪怕它是第三方库提供的封闭黑盒代码,也完全不影响最底层直接挂起切走整个物理栈。

 1[ Pattern 1: Stackful Coroutine (Go / Zig Fiber) ]
 2Each coroutine owns an independent stack block in memory.
 3When suspended, only CPU registers are switched; the original stack frames remain intact.
 4
 5     Coroutine A Stack (Suspended / Frozen)               Coroutine B Stack (Running)
 6High +------------------------------------------+    +------------------------------------------+
 7     | Frame 1: process_request()               |    | Frame 1: handle_request()                |
 8     +------------------------------------------+    +------------------------------------------+
 9     | Frame 2: parse_config() [Sync Function]  |    | Frame 2: calculate()                     |
10     +------------------------------------------+    +------------------------------------------+ <- CPU Regs (RSP/RIP)
11Low  | Frame 3: read_remote() [Blocked on I/O]  |                          ^
12     +------------------------------------------+                          |
13                          |                                                |
14                          +-------- Userspace Assembly Switches RSP/RIP ---+
15                          (Stack memory remains intact; local variables stay valid)
16
17
18[ Pattern 2: Stackless Coroutine (Rust / C# / JS) ]
19Tasks share a single thread stack. When suspended, stack frames must pop and return,
20while state and local variables are packed into a heap-allocated state machine object.
21
22           Shared Thread Stack (Must be freed)                   Heap Memory
23High +------------------------------------------+    +------------------------------------------+
24     | (Thread stack is emptied and yielded)    |    | Coroutine A State Machine Object         |
25     |                                          |    | ---------------------------------------- |
26     | Reused by Event Loop / other tasks       |    | • state: 1 (Waiting for network I/O)     |
27Low  |                                          |    | • locals: buf, socket, etc.              |
28     +------------------------------------------+    +------------------------------------------+
29                          |                                                ^
30                          | On suspend: stack frames pop via `return`      |
31                          +------------------------------------------------+
32                          (All callers must be `async` to propagate the return)

将推进模型与栈模型组合,主流语言的异步机制分布如下:

栈模型 \ 推进模型Pull 模型(拉取 / 轮询驱动)Push 模型(推送 / 事件驱动)
无栈协程(Stackless 状态机)
• 无独立栈,由编译器切分状态机
• 具有“函数染色”(需要 async/await)
Rust
• Future::poll 契约
• 零开销抽象,按需轮询
C# / JavaScript / Python
• Task / Promise
• 事件回调推进状态机
有栈协程(Stackful 纤程/绿程)
• 拥有独立分配的调用栈
• 可在任意深层函数中出让,无函数染色
(工业界极少采用)Go (netpoller + Goroutine)
Zig (std.Io + 原生 Fiber)

无栈 + Pull:Rust

Rust 追求零额外运行时开销,其异步体系核心是 Pull-based(轮询驱动) 的无栈状态机,在契合 Readiness 与适配 Completion 之间体现了典型权衡:

1pub trait Future {
2    type Output;
3    // 外部主动轮询:返回 Ready(T) 表示完成,返回 Pending 表示需等待下一次唤醒
4    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
5}

契合 Readiness (epoll)

在以 Tokio 为代表的经典生态中,底层依托 Mio (Metal I/O) 封装各平台的 epoll/kqueue:

1// 典型的 Tokio 异步网络读取
2async fn process(socket: &mut TcpStream) -> Result<()> {
3    let mut buf = [0u8; 1024];
4    // 1. 调用 read:底层签名通过借用传入 &mut buf
5    let n = socket.read(&mut buf).await?;
6    println!("read {} bytes", n);
7    Ok(())
8}

为什么两者天然契合?

适配 Completion (io_uring)

当 Rust 尝试接入 io_uring 时,借用模型与完成通知模型产生了冲突:

 1// 借用语义与 io_uring 的冲突示例
 2tokio::select! {
 3    _ = socket.read(&mut buf) => { /* 正常读取 */ }
 4    _ = timeout(Duration::from_secs(1)) => {
 5        // 超时分支触发!socket.read 的 Future 被 Drop 取消
 6        // 此时局部变量 buf 随栈帧销毁被释放
 7    }
 8}
 9// 内存安全隐患:内核 io_uring 依然持有旧 buf 的指针,当数据返回时,
10// 向已释放内存写入数据,触发典型的 Use-After-Free 崩溃

运行时的解决方案:所有权转移(Ownership-Passing): 专为 io_uring 打造的 Rust 纯异步运行时(如字节跳动的 monoio 以及 DataDog 的 glommio),放弃了传统的 &mut [u8] 借用接口,改为了所有权转移接口:

1// monoio 的异步读取签名:将 Buffer 所有权连同请求一起移交给内核
2async fn read<B: IoBufMut>(&self, buf: B) -> (Result<usize>, B);
3
4// 使用方式:提交时移交所有权,完成后连同结果一起归还所有权
5let (res, buf) = socket.read(buf).await;

无栈 + Push:C# 与 JavaScript

现代主流语言广泛使用的 async/await 语法,最早源于 C# 5.0。这一语法设计与 Windows 底层的 IOCP(完成端口,纯正 Completion 模型) 密切相关,其底层是典型的无栈状态机:

1public async Task ProcessSocketAsync(Socket socket) {
2    byte[] buffer = new byte[1024];
3    // 发起异步完成操作,直接与 Windows IOCP 绑定
4    int bytesRead = await socket.ReceiveAsync(new Memory<byte>(buffer), SocketFlags.None);
5    Console.WriteLine($"Read {bytesRead} bytes");
6}

由于任务没有独立栈,C# 编译器将该方法改写为一个实现了 IAsyncStateMachine 的状态机结构体(State Machine Struct):

 1// 编译器自动生成的降级状态机伪代码
 2public struct ProcessSocketStateMachine : IAsyncStateMachine {
 3    public int state; // 状态分支跟踪器:-1 (初始), 0 (等待中), ...
 4    public Socket socket;
 5    public byte[] buffer;
 6    private SocketAwaiter awaiter;
 7
 8    public void MoveNext() {
 9        switch (this.state) {
10            case -1: // 初始状态:提交 IOCP 异步操作
11                this.awaiter = this.socket.ReceiveAsync(this.buffer).GetAwaiter();
12                if (!this.awaiter.IsCompleted) {
13                    this.state = 0; // 转移至挂起状态
14                    // 将 MoveNext 作为回调挂载到 IOCP 完成事件上:
15                    this.awaiter.UnsafeOnCompleted(this.MoveNext);
16                    return; // 立即出让调用栈,方法返回
17                }
18                goto case 0;
19
20            case 0: // 完成状态:IOCP Worker 线程唤醒直接回到此处
21                int bytesRead = this.awaiter.GetResult();
22                Console.WriteLine($"Read {bytesRead} bytes");
23                return;
24        }
25    }
26}

架构本质:无栈状态机天生与 Completion-based 通知同构——底层 IOCP 收到完成包后,直接作为 Push 事件驱动调用一次状态机的 MoveNext(),推进到下一个状态节点。


有栈 + Push:Go

Go 在网络并发上的优势,依赖其运行时内部的 netpoller 调度器:通过有栈协程(Goroutine)在底层封装传统的 Readiness 模型,对上层提供同步风格的代码体验:

1func handleConnection(conn net.Conn) {
2    buf := make([]byte, 1024)
3    // 表面上看起来像直接阻塞线程的系统调用
4    n, err := conn.Read(buf)
5    if err != nil {
6        return
7    }
8    fmt.Printf("Received: %d bytes\n", n)
9}

在 Go 运行时内部(参考 runtime/netpoll.go 与 internal/poll/fd_poll_runtime.go),底层套接字被全部设为非阻塞模式(O_NONBLOCK):

 1// Go 运行时内部拦截的读取逻辑简化伪代码
 2func (fd *FD) Read(p []byte) (int, error) {
 3    for {
 4        // 1. 先尝试非阻塞读取一次
 5        n, err := syscall.Read(fd.Sysfd, p)
 6        if err != syscall.EAGAIN {
 7            return n, err
 8        }
 9
10        // 2. 遇到 EAGAIN,说明内核缓冲区未就绪
11        // 将当前 Goroutine(G)与 fd 绑定注册到 epoll 监听列表
12        // 然后调用 gopark() 将当前 G 挂起,出让 CPU 给其他 G,线程 M 继续运转
13        runtime_pollWait(fd.pd.runtimeCtx, 'r')
14
15        // 3. Sysmon 线程或调度器通过 epoll_wait 检测到就绪后,调用 goready() 唤醒当前 G
16        // G 在断点处被唤醒,循环重新尝试 syscall.Read
17    }
18}

架构本质:Go 在底层是对 Readiness-based(epoll)的高层封装。由于 Goroutine 拥有独立栈空间,可以在深层函数调用中随时让出 CPU,从而将异步事件的就绪状态机完全吸收在了 Runtime 内部。


有栈 + Push:Zig

Zig 摒弃了早期语言级 async/await 带来的函数染色,在标准库 std.Io 中采用原生轻量纤程(Fiber)直接对齐 Completion 范式。在编码形式上同样保持平坦的同步调用:

1const std = @import("std");
2
3pub fn processStream(io: std.Io, stream: std.Io.net.Stream) !void {
4    var buf: [1024]u8 = undefined;
5    // 表面平坦同步调用,无需 async/await 关键字修饰
6    const read_bytes = try stream.read(io, &buf);
7    std.debug.print("Read {d} bytes\n", .{read_bytes});
8}

与 Go 用协程包裹 epoll 不同,Zig 的 std.Io 在 Linux 平台直接将 Completion-based 的 io_uring 作为底层驱动:

 1// Zig 运行时底层流转示意
 2// 1. 构造完成操作描述符(Operation),直接向 io_uring 提交 SQE
 3var op = std.Io.Operation{
 4    .net_read = .{ .socket = stream.socket, .buffer = &buf },
 5};
 6
 7// 2. 提交操作后,如果内核未完成:
 8// 运行时保存当前 CPU 寄存器上下文,挂起当前 Fiber 并切换到任务队列中的下一个任务:
 9fiber.suspend(io);
10
11// 3. 后台驱动检测到 io_uring CQE 完成事件后,直接将结果填入 buffer,并唤醒该 Fiber 恢复执行:
12return op.result;

Go 与 Zig 的底层分野

Go 与 Zig 虽然都表现为同步调用风格且依赖有栈让出,但在底层与 OS 模型的对齐方式上有明显差异:

 1[ Go (epoll + Goroutine) ]                 [ Zig (io_uring + Fiber) ]
 2
 3      Application Code                          Application Code
 4             |                                         |
 5     conn.Read(buf)                            stream.read(io, &buf)
 6             |                                         |
 7    (1) syscall.Read()                       (1) Push SQE to Ring Buffer
 8             v                                         v
 9   Returns EAGAIN (Wait)                    Kernel DMA writes to &buf
10             |                                         |
11    (2) gopark() & epoll_ctl                 (2) fiber.suspend()
12             |                                         |
13       [ Wait epoll ]                            [ Wait CQE ]
14             |                                         |
15    (3) epoll_wait ready                     (3) CQE completed event
16             v                                         v
17    (4) goready() & wake G                   (4) Resume Fiber
18             |                                         |
19    (5) syscall.Read() AGAIN                           v
20        Data copied to buf                     Data ALREADY in &buf!
21             v                                         v
22        [ Done ]                                  [ Done ]
23   (Two syscalls + retry loop)              (Zero redundant read syscall)

1. 系统调用与重试开销

2. 全 I/O 统一性

3. 运行时开销与控制权

4. 内存所有权与取消安全

对比维度Go (netpoller + Goroutine)Zig (std.Io + Fiber)
底层 OS 模型Readiness-based (epoll)Completion-based (io_uring)
完成一次 I/O 路径试读 EAGAIN → 挂起 → 就绪唤醒 → 二次系统调用读取提交 SQE → 挂起 → 唤醒时数据已就地就绪
磁盘文件 I/O 表现epoll 不支持,退化为阻塞 OS 物理线程原生统一,网络与磁盘共享统一事件环
运行时重量较重(GMP 调度器 + 动态栈扩容 + GC + sysmon)精简(汇编切换寄存器,无 GC)
Buffer 所有权安全天然安全,内核就绪后才由应用拉取需显式生命周期管理,避免内核在途写悬空指针

全景对比

语言与机制推进模型栈模型对应底层 OS 机制优缺点总结
Rust (Future)Pull (轮询)无栈 (状态机)Readiness (epoll)优势:零内存开销、强类型安全;
劣势:与 io_uring 借用模型天然冲突,需所有权转移
C# / JS (async/await)Push (完成)无栈 (状态机)Completion (IOCP) / 事件循环优势:符合直觉的状态流转;
劣势:存在函数染色,状态机跨帧分配带来 GC / 堆内存压力
Go (netpoller)Push (事件)有栈 (Goroutine)Readiness (epoll)优势:极佳的同步代码体验;
劣势:运行时体积大,无法直接利用 Proactor 硬件零拷贝
Zig (std.Io)Push (完成)有栈 (Fiber)Completion (io_uring)优势:无函数染色,原生对齐新一代内核 Proactor;
劣势:跨平台统一调度器设计复杂度高

经典工业实践

epoll:Nginx 与 Redis

Nginx 与 Redis 是基于 Readiness-based 架构的代表性系统。根据 Nginx 官方技术剖析 Inside NGINX: How We Designed for Performance & Scale:

典型 Reactor 事件循环:

 1// 典型的 Reactor 事件驱动主循环 (epoll)
 2int epoll_fd = epoll_create1(0);
 3struct epoll_event ev, events[MAX_EVENTS];
 4
 5ev.events = EPOLLIN | EPOLLET; // 可读 + 边沿触发
 6ev.data.fd = listen_sock;
 7epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock, &ev);
 8
 9while (running) {
10    // 1. 等待就绪通知 (陷入内核)
11    int n = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
12
13    for (int i = 0; i < n; i++) {
14        int fd = events[i].data.fd;
15        if (events[i].events & EPOLLIN) {
16            // 2. 状态已就绪,应用层自己分配内存并主动发起 read
17            while (1) {
18                ssize_t count = read(fd, buf, sizeof(buf));
19                if (count == -1) {
20                    if (errno == EAGAIN || errno == EWOULDBLOCK) break; // 数据已全部读完
21                    handle_error(fd);
22                    break;
23                }
24                process_data(fd, buf, count);
25            }
26        }
27    }
28}

io_uring:现代存储与网络系统

根据知名实战教程 Lord of the io_uring 的剖析,io_uring 的核心突破在于其双无锁环形队列设计:

  flowchart LR
    subgraph UserSpace ["用户空间 (User Space)"]
        App["应用程序"]
        AppBuffer["用户分配的 Memory Buffer"]
    end

    subgraph RingBuffers ["共享无锁环形队列 (mmap)"]
        SQ["提交队列 (Submission Queue)"]
        CQ["完成队列 (Completion Queue)"]
    end

    subgraph KernelSpace ["Linux 内核空间 (Kernel)"]
        KernelWorker["内核 I/O 驱动 / DMA"]
        DiskNet["磁盘 / 物理网卡"]
    end

    App -- "1. 写入 SQE (包含 op, fd, Buffer 指针)" --> SQ
    SQ -. "2. 内核无系统调用消费" .-> KernelWorker
    KernelWorker -- "3. DMA 直接落入用户 Buffer" --> AppBuffer
    DiskNet <--> KernelWorker
    KernelWorker -- "4. 写入 CQE 完成事件" --> CQ
    CQ -. "5. 用户态直接检查完成" .-> App

工业落地案例

1. ScyllaDB 分布式 NoSQL 数据库 ScyllaDB 底层依托 C++ 协程框架 Seastar(Thread-per-core 架构),较早将 io_uring 落地于生产环境:

2. Meta Meta 是 io_uring 的诞生地(作者兼内核维护者 Jens Axboe 当时正是 Facebook 内核团队资深工程师):


IOCP:Windows 企业级网络架构

Windows NT 自 1993 年便将 I/O Completion Ports (IOCP) 作为其核心异步设计,并在 IIS(Web 服务器) 与 Microsoft SQL Server 中广泛应用。Mark Russinovich 在 Inside I/O Completion Ports 中对其机制进行了详细说明:

  1. 重叠 I/O(Overlapped I/O):调用 WSARecv 时传入用户缓冲区指针,函数立刻返回 WSA_IO_PENDING;
  2. 内核线程池限流(Concurrency Throttle):创建 IOCP 实例时指定最大并发线程数(通常等于 CPU 物理核心数)。内核严格保证处于运行态的 Worker 线程数不超过该限制,从内核层面杜绝了多线程激增与惊群效应(Thundering Herd)。

典型 IOCP 处理循环:

 1// 典型的 IOCP Completion 模式
 2HANDLE iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, num_cores);
 3CreateIoCompletionPort((HANDLE)socket, iocp, (ULONG_PTR)ctx, 0);
 4
 5WSABUF wsabuf = { .len = 4096, .buf = app_buffer };
 6DWORD bytes_recvd = 0, flags = 0;
 7WSAOVERLAPPED overlapped = { 0 };
 8
 9// 异步提交:要求内核直接读取并填充 app_buffer
10WSARecv(socket, &wsabuf, 1, &bytes_recvd, &flags, &overlapped, NULL);
11
12// Worker 线程等待“完成”通知
13DWORD bytes_transferred = 0;
14ULONG_PTR completion_key = 0;
15LPOVERLAPPED lp_overlapped = NULL;
16
17while (GetQueuedCompletionStatus(iocp, &bytes_transferred, &completion_key, &lp_overlapped, INFINITE)) {
18    // 此时数据已经被操作系统完全拷贝到了 app_buffer 中!无需再调 read/recv
19    process_completed_data(completion_key, app_buffer, bytes_transferred);
20}

全维度对比与工程选型

对比矩阵

特性维度Readiness-based (就绪型 / Reactor)Completion-based (完成型 / Proactor)
通知语义“底层已准备好,你自己来读写”“操作已执行完毕,直接消费结果”
典型操作系统Linux epoll, macOS kqueueWindows IOCP, Linux io_uring
典型工业系统Nginx, Redis, Netty, TokioWindows IIS, ScyllaDB, RocksDB, monoio
上层语言天然契合范式Pull 轮询模型 (Rust Future), 绿程拦截 (Go)Push 状态机 (C#/JS async-await), 所有权转移, 原生 Fiber (Zig std.Io)
单次 I/O 系统调用至少 2 次 (epoll_wait + read/write)趋近 0 次 (环形队列批量无锁同步)
内存分配策略按需延迟分配,内存极度集约(适合百万空闲长连接)必须提前借出并 Pinning 内存(生命周期严格)
常规磁盘文件支持差(Linux 下无法做到真异步,需借由线程池模拟)完美(统一网络 Socket、文件系统与设备驱动)
多变协议状态机极高(协议状态机可自由分步消费字节)较弱(需提前规划预分配 Buffer 形状)

选型决策

在实际系统设计与技术选型中,可以参考以下决策路径:

  1. 适合选择 Readiness-based 的场景:

    • 海量空闲长连接网关:如百万级 WebSocket/MQTT 消息推送服务器,Readiness 的惰性内存分配优势显著;
    • 跨平台便携性优先:系统若需要跨 Linux、macOS、BSD、各类 Unix 部署,select/poll/epoll/kqueue 是稳妥的最大公约数;
    • 分步式协议解析客户端:如典型的 HTTP/2、HTTP/3 复杂客户端(如拥有长期演进历史的 libcurl,因跨平台与复杂状态机选择维持 Readiness 架构)。
  2. 适合选择 Completion-based 的场景:

    • 混合了海量常规磁盘文件与高频网络 I/O 的系统:如分布式存储节点、现代化数据库系统、高性能流媒体服务器;
    • 运行在现代 Linux 内核(>= 5.10)且追求单机百万级极致吞吐的高性能后端;
    • Windows 原生平台的高并发企业级应用:必须优先使用 IOCP。

延伸视野:经典模型与内核旁路

除了通用操作系统中的 Readiness 与 Completion,讨论 I/O 还需兼顾经典模型的工业演进、硬件直通以及上层并发架构的组织方式:

1. 经典 5 种 I/O 模型的工业定位 经典的《UNIX 网络编程》(UNP)将操作系统 I/O 划分为五类:阻塞、非阻塞、I/O 多路复用、信号驱动(SIGIO)与异步 I/O。在实际工程中,阻塞模型受困于连接数扩展瓶颈,纯非阻塞轮询空耗 CPU,信号驱动则因队列易溢出与调试繁琐而较少采用。因此,现代通用操作系统的核心技术方案收敛于两条主线:以 epoll/kqueue 为代表的多路复用(Readiness 范式) 与 以 io_uring/IOCP 为代表的异步 I/O(Completion 范式)。

2. 极限场景下的内核旁路(Kernel-Bypass) 在微秒甚至纳秒级超低延迟场景(如高频交易、RDMA 分布式存储)中,即便是 io_uring 也仍有操作系统调度与驱动层开销。此时系统常采用 DPDK(网络) 或 SPDK(存储) 等内核旁路技术:绕过内核与系统调用,由绑定在专属核心上的单线程通过轮询驱动(PMD, Poll Mode Driver)持续扫描硬件队列,消除中断与上下文切换延迟。

3. I/O 交互契约与并发调度架构的正交性 I/O 模型(Readiness vs Completion)定义的是应用程序与操作系统之间的数据搬运契约;而服务架构(Thread-per-core、多线程工作窃取 Work-Stealing 等)定义的是任务与 CPU 核心的组织形态。在实际系统中,两者相互独立并组合使用:

I/O 机制解决的是数据如何就绪与传递,并发模型解决的是线程与算力如何分配。系统选型时需分别评估二者,而非绑定看待。

评论

欢迎读者通过邮件与我交流,也可以在 Mastodon 或 Twitter 上关注我。