Mio 与操作系统唤醒源机制的深度集成

在基于事件驱动（Event-Driven）的异步运行时（如 Tokio、Mio）中，Worker 线程在没有待处理的网络 I/O 事件时，会调用操作系统的阻塞系统调用（Linux epoll_wait / macOS kevent）陷入深度休眠，以彻底释放 CPU 算力与电力。

然而，在异步世界中，有大量事件并不是由外部网络网卡硬件触发的，而是来自宿主机内部的其他软件线程：

• 其他线程向当前 Worker 的异步通道中发送了一条新消息（mpsc::send）；
• 用户调用了 runtime.spawn() 从外部线程注入了一个新的异步任务；
• 服务端收到系统关机信号（SIGTERM / SIGINT），需要立即通知所有处于休眠中的 Worker 线程优雅退出。

当 Worker 线程正死死阻塞在内核态的 epoll_wait 中时，外部线程如何跨越操作系统内核边界，在微秒内瞬间“叫醒（Wakeup）”正在沉睡的事件循环？

深入剖析 Linux eventfd、Unix 匿名管道（Pipe）与 Windows 唤醒源在 Mio 中的深度集成，是理解异步事件循环唤醒机制的核心钥匙。

+--------------------------------------------------------------------------+
|                       外部线程跨内核唤醒 Worker 事件循环全景                    |
+--------------------------------------------------------------------------+
| [外部并发线程 (Thread B)]                                                 |
| 1. 调用 waker.wake() 触发异步任务唤醒                                      |
| 2. 向共享的操作系统唤醒源文件描述符写入 8 字节整数: libc::write(eventfd, &1) |
|    -> 这一步仅需纳秒级内核写入，Thread B 立即从容返回! 🚀                 |
+--------------------------------------------------------------------------+
                                    | 内核态原子递增计数并触发就绪事件
                                    v
| [Linux 内核 epoll 实例 (Kernel Eventpoll)]                                |
| 3. 内核检测到 eventfd 可读，瞬间将对应 epitem 挂入就绪队列 rdllist        |
| 4. 唤醒正在 epoll_wait 中休眠的 Worker 线程 (Thread A)!                   |
+--------------------------------------------------------------------------+
                                    | 唤醒返回用户态
                                    v
| [Worker 线程 (Thread A)]:                                                 |
| 5. 从 epoll_wait 返回，排空 eventfd 计数，立即执行新就绪的异步任务队列!   |
+--------------------------------------------------------------------------+

1. 传统唤醒方案：跨线程匿名管道（Self-Pipe Trick）

在早期的 Unix 网络编程中，通用的唤醒手段是著名的 Self-Pipe Trick（自管道技巧）：

• 创建一对传统的匿名管道 pipe(fds)；
• 将读端 fds[0] 注册进 epoll 监听可读事件；
• 当需要唤醒事件循环时，外部线程向写端 fds[1] 写入 1 个字节的数据；
• 内核通知 fds[0] 可读，唤醒正在休眠的事件驱动主循环。

自管道的物理开销缺陷：

• 管道在内核中需要维护完整的环形缓冲区与 inode 结构体；
• 每次读写都需要占用 2 个独立的文件描述符；
• 在极端高并发唤醒冲击下，管道的内核锁争用与缓冲区管理开销较为沉重。

2. 现代 Linux 极速唤醒源：eventfd

Linux 2.6.27 引入了专为线程间事件通知定制的轻量级系统调用——eventfd：

use std::os::unix::io::{AsRawFd, RawFd};

pub struct LinuxWaker {
    fd: RawFd,
}

impl LinuxWaker {
    pub fn new() -> Result<Self, std::io::Error> {
        // 核心原语：创建非阻塞、带 CLOSE_ON_EXEC 的 eventfd
        let fd = unsafe {
            libc::eventfd(0, libc::EFD_NONBLOCK | libc::EFD_CLOEXEC)
        };
        if fd < 0 {
            Err(std::io::Error::last_os_error())
        } else {
            Ok(Self { fd })
        }
    }

    /// 外部线程调用的极速唤醒接口
    pub fn wake(&self) -> std::io::Result<()> {
        let val: u64 = 1;
        // 核心：单次写入 8 字节无符号整数，瞬间触发内核可读就绪！
        let res = unsafe {
            libc::write(
                self.fd,
                &val as *const u64 as *const libc::c_void,
                std::mem::size_of::<u64>(),
            )
        };
        if res < 0 {
            Err(std::io::Error::last_os_error())
        } else {
            Ok(())
        }
    }

    /// Worker 线程被唤醒后的排空重置
    pub fn drain(&self) {
        let mut buf: u64 = 0;
        // 读取并清零内核内部计数器
        unsafe {
            libc::read(
                self.fd,
                &mut buf as *mut u64 as *mut libc::c_void,
                std::mem::size_of::<u64>(),
            );
        }
    }
}

eventfd 的硬核优势：

1. 仅占用 1 个文件描述符：相比管道减少了一半的内核资源消耗；
2. 极速内核计数器：内核在内部仅仅维护一个简单的 64 位整型计数器，write 仅执行原子累加，read 仅执行重置，单次唤醒耗时被压缩到了几十纳秒的硬件极限！

3. Mio 的跨平台 Waker 抽象

在 mio::Waker 的跨平台实现中：

• Linux 平台：默认优先使用极其高效的 eventfd；
• macOS / FreeBSD：利用 kqueue 原生的 EVFILT_USER 用户自定义事件，完全不消耗任何文件描述符即可实现毫秒级内核唤醒；
• Windows：利用 IOCP 的 PostQueuedCompletionStatus 向完成端口投递自定义完成包。

通过将操作系统的原生唤醒源与异步任务调度器无缝桥接，Mio 实现了异步协程在休眠与苏醒之间的极速流转，构成了现代高响应异步事件中枢的坚固底座。