用 Rust 从零实现迷你 tokio:Reactor 和 Executor 怎么配合
上一篇的
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。流程是:
- 先尝试直接读(可能立刻有数据)
- 读不到(
WouldBlock)就把 waker 注册到 reactor - 返回
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 的握手,异步就不再是黑盒。