返回文章列表

用 Rust 从零实现迷你 tokio:Reactor 和 Executor 怎么配合

432 字·4 分钟阅读
Rust从零造轮子异步编程

上一篇的 block_on 能跑 Future,但它没法等 IO。因为"等 IO"这件事,需要一个能监听文件描述符的组件——Reactor。

Executor 和 Reactor 的分工很清楚:

  • Executor:决定"哪个 Future 该被 poll"
  • Reactor:决定"什么时候该 poll 它们"

这篇把两者接起来。产物是一个能真正异步读 TCP 连接的迷你运行时,大概 200 行。


先看问题的形状

TcpStream::read 是阻塞的,一个线程只能伺候一个连接。要支持一万个连接,不能开一万个线程。

异步的路子是:把 socket 设成非阻塞,注册到 epoll,用一个线程轮询所有 fd。

        ┌──────────────┐
        │  Executor    │  轮询任务队列
        └──────┬───────┘
               │ poll
        ┌──────v───────┐
        │  Future      │  poll 返回 Pending 时
        └──────┬───────┘  把 waker 交给 Reactor
               │ register
        ┌──────v───────┐
        │  Reactor     │  等 epoll,事件就绪时
        └──────┬───────┘  调用 waker.wake()
               │ wake
               └─────────> 任务重新入队

Reactor 的核心:fd → Waker 的映射

Reactor 要维护一张表:哪个 fd 就绪时,该唤醒哪个 Waker。

use std::collections::HashMap;
use std::os::fd::RawFd;
use std::sync::{Arc, Mutex};
use std::task::Waker;
 
pub struct Reactor {
    epoll: std::os::fd::OwnedFd,
    // fd -> 等待它的 waker
    waiters: Mutex<HashMap<RawFd, Waker>>,
}

这里用 Linux 的 epoll 举例(macOS 对应 kqueue,mio 这个库帮你抹平了平台差异)。

创建 epoll 实例:

use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
 
impl Reactor {
    pub fn new() -> std::io::Result<Self> {
        // epoll_create1
        let fd = unsafe { libc::epoll_create1(libc::EPOLL_CLOEXEC) };
        if fd < 0 {
            return Err(std::io::Error::last_os_error());
        }
        Ok(Self {
            epoll: unsafe { OwnedFd::from_raw_fd(fd) },
            waiters: Mutex::new(HashMap::new()),
        })
    }
 
    pub fn register(&self, fd: RawFd, waker: Waker, readable: bool) -> std::io::Result<()> {
        let mut event = libc::epoll_event {
            events: if readable { libc::EPOLLIN as u32 } else { libc::EPOLLOUT as u32 },
            u64: fd as u64,
        };
 
        let op = {
            let waiters = self.waiters.lock().unwrap();
            if waiters.contains_key(&fd) { libc::EPOLL_CTL_MOD } else { libc::EPOLL_CTL_ADD }
        };
 
        let ret = unsafe {
            libc::epoll_ctl(self.epoll.as_raw_fd(), op, fd, &mut event)
        };
        if ret < 0 {
            return Err(std::io::Error::last_os_error());
        }
 
        self.waiters.lock().unwrap().insert(fd, waker);
        Ok(())
    }
}

epoll_ctl 有两个操作:ADD 是第一次注册,MOD 是修改关注的事件。不区分的话,第二次注册同一个 fd 会返回 EEXIST。

Reactor 主循环:等事件,唤醒 Waker

    pub fn run_once(&self, timeout_ms: i32) {
        let mut events = [libc::epoll_event { events: 0, u64: 0 }; 1024];
 
        let n = unsafe {
            libc::epoll_wait(
                self.epoll.as_raw_fd(),
                events.as_mut_ptr(),
                events.len() as i32,
                timeout_ms,
            )
        };
 
        if n <= 0 {
            return; // 超时或被打断
        }
 
        let ready: Vec<RawFd> = events[..n as usize].iter().map(|e| e.u64 as RawFd).collect();
 
        for fd in ready {
            // 取走 waker 并唤醒
            if let Some(waker) = self.waiters.lock().unwrap().remove(&fd) {
                waker.wake();
            }
        }
    }

关键点:唤醒之后要把 waker 从表里删掉。 否则下一次事件会重复唤醒同一个已经完成的 Future,轻则浪费 poll,重则触发 "polled after completion" panic。

把它包成 Future

现在写一个 AsyncRead 风格的 Future。流程是:

  1. 先尝试直接读(可能立刻有数据)
  2. 读不到(WouldBlock)就把 waker 注册到 reactor
  3. 返回 Pending
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
 
pub struct ReadFuture<'a> {
    fd: RawFd,
    buf: &'a mut [u8],
}
 
impl<'a> Future for ReadFuture<'a> {
    type Output = std::io::Result<usize>;
 
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();
 
        loop {
            let n = unsafe {
                libc::read(this.fd, this.buf.as_mut_ptr() as *mut _, this.buf.len())
            };
 
            if n >= 0 {
                return Poll::Ready(Ok(n as usize));
            }
 
            let err = std::io::Error::last_os_error();
            if err.kind() == std::io::ErrorKind::WouldBlock {
                // 没数据,交给 reactor
                REACTOR.with(|r| {
                    r.register(this.fd, cx.waker().clone(), true).ok();
                });
                return Poll::Pending;
            }
            return Poll::Ready(Err(err));
        }
    }
}

这个结构是所有 IO Future 的模板,值得记下来:

poll {
    尝试非阻塞操作
    成功  -> Ready
    失败(WouldBlock) -> 注册 waker 到 reactor -> Pending
    真错误 -> Ready(Err)
}

WouldBlock 不是错误,它是异步编程的信号灯:现在别读,等我的 Waker 通知你。

Executor + Reactor:主循环

现在把两半接起来。主循环做了三件事:跑完所有就绪任务、处理 reactor 事件、没有任务可跑时就阻塞在 epoll 上。

pub struct Runtime {
    executor: Executor,
    reactor: Arc<Reactor>,
}
 
impl Runtime {
    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
        // 把要 block_on 的 future 包装成任务
        let (waker, wake_rx) = /* 见上一篇的 TaskWaker 实现 */;
 
        loop {
            // 1. 推进所有可以推进的任务
            self.executor.run_ready(&self.reactor);
 
            // 2. 如果有结果就返回
            if let Some(out) = self.executor.try_take_result() {
                return out;
            }
 
            // 3. 没任务可跑,阻塞等 IO;有超时任务就传超时
            let timeout = self.executor.next_deadline_ms().unwrap_or(-1);
            self.reactor.run_once(timeout);
        }
    }
}

这就是 tokio 主循环的骨架。差异在于:

本文版本 tokio
单线程跑全部 多线程 work-stealing
epoll 直调 mio 抽象跨平台
无定时器 时间轮集成在 reactor 里
无任务唤醒队列 无锁注入队列
阻塞线程 park/unpark + 调度器

骨架完全一样,tokio 的复杂度全在扩展件上。

三个真实的坑

1. Waker 被 clone 多次,但 reactor 只存一个。 如果注册时用 cx.waker().clone(),而两张表里存了同一个 fd 的两个 waker,可能只唤醒一个。所以 register 要做幂等:同一个 fd 覆盖而不是追加。

2. EPOLLONESHOT 是更保险的选择。 默认模式是水平触发(level-triggered):只要 socket 还有数据可读,epoll_wait 就会一直返回它。如果 waker 处理慢,会出现"同一批事件被连续报告"。

用 EPOLLONESHOT 或 EPOLLET(边缘触发)能保证一次注册只报告一次:

event.events = libc::EPOLLIN as u32 | libc::EPOLLONESHOT as u32;

ONESHOT 的代价是:每次 poll 后都要重新 register(这时是 MOD)。这正是前面要区分 ADD/MOD 的另一个原因。

3. 别在 reactor 线程里做重活。 run_once 里调用 waker.wake() 只是把任务丢回队列,真正执行在 executor 线程。如果搞混了——比如直接在 reactor 回调里跑业务逻辑——IO 事件处理会被阻塞,所有连接的延迟一起抖动。

跑起来验证

写个 echo 服务验证:

fn main() -> std::io::Result<()> {
    let listener = std::net::TcpListener::bind("127.0.0.1:8080")?;
    listener.set_nonblocking(true)?;
    let rt = Runtime::new()?;
 
    loop {
        match listener.accept() {
            Ok((stream, _)) => {
                let fd = stream.into_raw_fd();
                rt.spawn(async move {
                    let mut buf = [0u8; 1024];
                    loop {
                        let n = ReadFuture { fd, buf: &mut buf }.await?;
                        if n == 0 { break; }
                        // 回写...
                    }
                    Ok::<_, std::io::Error>(())
                });
            }
            Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                rt.run_once(10); // 没有新连接就先处理已有事件
            }
            Err(e) => return Err(e),
        }
    }
}

listener.accept() 在 set_nonblocking(true) 之后也会 WouldBlock,这时正好让 reactor 去跑一圈。

结论

一个能用的异步运行时,本质是两块拼图加一个循环:

Reactor 拿 epoll 等事件,事件就绪时调 Waker;Waker 把任务推回队列;Executor 从队列取任务并 poll;Future 在 poll 里"试一次,不行就注册 waker"。

写到这里你应该明白了:.await 不是"暂停线程",它只是把"注册回调 + 返回"这套逻辑伪装成了同步代码。理解 Reactor 和 Waker 的握手,异步就不再是黑盒。