很多人第一次写异步都会遇到同一个困惑:明明写了 async fn,也写了 .await,可程序什么都没打印。再一查,有人说「要加 #[tokio::main]」,于是把 tokio 装上,代码能跑了,但为什么能跑、async 到底做了什么,还是不清楚。
这一篇不用 tokio。只用标准库,手写一个二十行的执行器,把 async/await 下面的三样东西拆出来:Future 是一台可以被反复推进的状态机,Poll 是「这次推进完了没有」的返回值,Waker 是「有进展了叫我」的回调。理解了这三样,再看任何异步运行时都不会觉得是魔法。
async 函数返回的是 Future,不是结果
async fn add(a, b) -> i32 的返回类型不是 i32,而是一个实现了 Future<Output = i32> 的匿名类型。调用它不会执行函数体,只是构造出这个状态机。状态机里保存了所有跨 await 存活的局部变量,以及「现在执行到哪一步」。只有被 poll 推进时,函数体才真正往前走。
实测创建了一个 future 但不 poll,直接 drop:
created => future 已创建,但没被 poll
函数体里的代码一行都没执行。所以「写了 async 却没反应」不是 bug,是语义:Future 是惰性的,和迭代器一样,没人推它就不动。.await 只是在另一个 async 上下文里「推一下,没完成就把当前任务挂起」,它本身也不是执行器。
Future 的核心只有一个方法:
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
返回 Poll::Ready(v) 表示完成,Poll::Pending 表示「现在还不行,等有进展再 poll 我」。执行器的工作就是反复调用 poll,直到 Ready。听起来像忙轮询,但关键是 Context 里的 Waker:future 在返回 Pending 之前,必须把 waker 存下来,等条件满足时调用 wake,执行器收到通知才再 poll。没有 waker,执行器只能盲等或忙轮询。
async fn 和 async { ... } 块生成的是同一种东西:一个实现了 Future 的匿名类型。区别在捕获方式:async fn 的参数按普通函数规则借用或移动,async 块会按需捕获外部变量,move 块则把用到的变量全部移进去。这解释了为什么 spawn 时经常要写 async move:任务可能比当前栈帧活得久,不能借用局部变量,只能把所有权搬进去。
Waker:谁负责把你叫醒
Waker 是一个「回调句柄」,内部通常是 Arc 加虚表。future 拿到它之后可以克隆、保存、跨线程传递,条件满足时调用 wake()。执行器收到 wake,把对应任务重新排队。不同的运行时用不同的实现:tokio 的 waker 会把任务塞回调度队列,我们手写的执行器用 thread::unpark 唤醒阻塞的线程。
新手实现 Future 时最常犯的错误是「直接返回 Pending,但没保存 waker」。这样执行器永远收不到通知,任务就永久挂起,表现为「程序不结束也不报错」。第二个错误是「每次 poll 都 clone 一个新 waker 给新线程,旧线程也醒来」,导致重复唤醒和资源浪费。正确做法是:只在第一次 poll 时注册等待,后续 poll 检查条件是否满足。
还有一个细节:wake 可能被调用多次,也可能在 poll 返回之前就被调用。执行器必须能处理「重复唤醒」,通常用原子标志去重。这不是理论问题,网络数据到达和定时器同时触发时经常发生。
waker 有两个调用形式:wake() 消耗自身,wake_by_ref() 借用。前者少一次克隆,适合「只唤醒一次」的场景;后者适合「手里还要留着 waker 继续等下一次」。在 poll 里如果只是想让执行器立刻再试一次,用 wake_by_ref 就够了。克隆 waker 也不是免费的,它背后通常有一次原子计数增加;高频路径上别在每次 poll 都克隆一个新的丢给线程。
手写一个最小执行器
先定义 waker:把当前线程的句柄存进去,wake 时 unpark。
struct ThreadWaker { thread: thread::Thread }
impl Wake for ThreadWaker {
fn wake(self: Arc<Self>) { self.thread.unpark(); }
}
fn block_on<F: Future>(fut: F) -> F::Output {
let mut fut = Box::pin(fut);
let waker = Waker::from(Arc::new(ThreadWaker { thread: thread::current() }));
let mut cx = Context::from_waker(&waker);
loop {
match fut.as_mut().poll(&mut cx) {
Poll::Ready(v) => return v,
Poll::Pending => thread::park(),
}
}
}
这段就是 block_on 的全部。它把 future 钉在堆上(Box::pin),拿到 waker,循环 poll;Pending 就 park 睡过去,等 waker 调用 unpark 再醒。它不是生产级执行器——只有一个任务、没有调度、没有定时器、没有 IO 注册——但它把机制完整跑通了。实测一个「第一次 Pending、第二次 Ready」的 future:
block_on => 5
这个执行器还有两个明显的能力缺口。第一,它一次只能跑一个 future,要同时跑多个任务,得再加一个任务队列,让 waker 知道该唤醒哪个任务。第二,它没有「就绪队列」——如果 future 在返回 Pending 之前就调用了 wake,unpark 会被记录,下一次 park 会立刻返回;但如果 wake 发生在这之后,线程可能已经睡了,只能靠 unpark 把它叫醒。生产级执行器把这两件事拆成「任务状态机 + 调度队列 + 事件通知」,复杂度主要来自这里。
定时器:异步的等待从哪来
标准库没有异步 sleep。要等一段时间,必须有人负责「时间到了叫我」。最小实现是开一个线程,睡够时间后调用 waker:
struct Sleep { dur: Duration, start: Option<Instant>, spawned: bool }
impl Future for Sleep {
type Output = ();
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
let start = *self.start.get_or_insert_with(Instant::now);
if start.elapsed() >= self.dur { return Poll::Ready(()); }
if !self.spawned {
self.spawned = true;
let waker = cx.waker().clone();
let remain = self.dur - start.elapsed();
thread::spawn(move || { thread::sleep(remain); waker.wake(); });
}
Poll::Pending
}
}
实测睡 200 毫秒:
sleep => 211.8407ms
多出来的十几毫秒是线程创建、调度和唤醒的开销。生产级运行时会用「一个定时器线程 + 最小堆」管理成千上万个定时器,而不是每个 future 开一个线程;但原理相同:到期时 wake 对应任务。这个例子也说明异步等待并不神奇,它只是把「睡」交给了别人。
定时器的精度也值得说一句。很多操作系统的线程睡眠精度在十几毫秒量级,thread::sleep(5ms) 实际可能睡 15 毫秒;上面的 211 毫秒里就有这部分误差。真实运行时通常把最近的到期时间作为下一次等待的上限,再用循环处理「醒早了」的情况,不会指望一次睡眠精确命中。写代码时不要把定时器当成硬实时保证,网络超时、重试间隔都要留余量。
thread::park 可能在没有 unpark 的情况下自己醒来(虚假唤醒),所以执行器必须在循环里重新 poll,而不是「醒一次就认为完成了」。这也是所有等待逻辑都要写在循环里的原因。poll 里不能阻塞
poll 的契约是「尽快返回」。它应该只做「检查有没有进展」和「注册等待」,不能在里面做耗时操作。一旦 poll 阻塞,整个执行器线程就被占住,其他任务全部停摆。很多人把 thread::sleep、同步文件读写、同步数据库查询写进 async 块,以为 await 会让它「异步」,实际它只是阻塞得更隐蔽。
实测在单线程执行器里顺序 await 两个 future:第一个 thread::sleep(200ms),第二个只是打印。第二个本来可以立刻完成,却被拖到第一个之后:
first => 200.117ms (阻塞后)
second => 200.1951ms (本该先完成)
这就是「异步代码里混入阻塞调用」的真实后果:不是变慢一点,而是整条任务队列被卡住。更要命的是,这类问题在单请求测试里看不出来,一到并发就雪崩。
正确的处理是把阻塞工作交给专门的线程池,future 只负责等待结果;或者干脆用同步接口,把它放在独立的线程里,不要混进异步执行器。判断标准很简单:这个操作会不会让线程睡超过一毫秒?会,就不该出现在 poll 里。
并发是交替推进,不是同时运行
两个 future 各自等待 100 毫秒。如果顺序 await,总时间约 200 毫秒;如果用 join 同时推进,总时间约 100 毫秒。手写一个交替 poll 的循环,实测:
a ready => 100.5438ms
b ready => 100.605ms
两个 future 在同一个线程上交替被 poll,等待时间重叠,所以总耗时接近 100 毫秒。注意它们没有「同时运行」——同一时刻只有一个在推进,只是等待区间重叠了。这就是并发(concurrency)和并行(parallelism)的区别:并发是「同时处理多个任务」,并行是「同一时刻真的在多核上执行」。异步 I/O 给的是并发,CPU 密集计算需要的是并行,后者应该用线程或进程,而不是 async。
标准库没有 join! 宏,也没有 select!。要组合多个 future,可以手写一个 Join 结构体,在 poll 里逐个推进;也可以引入 futures 库。手写的价值在于理解「组合器本身也是一个 Future」:它不执行子 future,只是决定先 poll 谁、全部完成后返回什么。
并发执行器还有一个公平性问题。如果某个 future 每次 poll 都立刻返回 Ready,而且执行器一直优先 poll 它,其他任务就永远轮不到,这叫饥饿。手写的交替循环里,最坏情况是一个任务在 poll 里死循环,整个线程直接卡死;生产级运行时会用「每次 poll 的预算」限制单个任务连续占用的时间,用完就强制让出。写异步代码时也要自觉:长循环里加 yield_now().await,给别的任务留出执行机会。
Pin:为什么 future 要钉住
async 生成的状态机可能自引用:某个局部变量被借用,之后又跨 await 存活,状态机内部就存了一个指向自己另一部分的指针。如果这个状态机被移动,指针就悬空了。Rust 用 Pin 表达「这个值不能再被移动」,Box::pin 把 future 放到堆上,之后只能通过 Pin<&mut T> 访问。
大多数 async 代码不需要手写 Pin,因为 .await 和运行时已经处理好了。只有自己实现 Future 时才要面对它。经验规则:如果 poll 里需要 &mut self 且结构体可能自引用,就用 Pin;如果类型实现了 Unpin(大多数普通类型都是),可以 Pin::new 安全地拿到 &mut。不要为了「看起来对」到处加 unsafe { Pin::new_unchecked(...) },那是在绕过编译器帮你检查的保证。
还有一个现实约束:手写 Future 时如果结构体里有自引用,不能随便用 &mut self 的字段拆分,得用 pin_project 这类工具做「投影」,否则编译器无法证明移动安全。这也是为什么大多数人宁愿用 async 块,也不手写状态机:语法糖替你把 Pin 投影、字段布局、生命周期都处理好了。理解机制是为了排查问题,不是为了日常手写。
递归的 async fn 也会撞上同一个问题。异步函数的状态机大小在编译期必须确定,递归调用会让大小无限展开,编译器会报「recursion in an async fn requires boxing」,并提示你加 Box::pin 或改成返回 Box<dyn Future>。这不是 Rust 故意刁难,而是状态机必须有固定大小。遇到这个报错,先想「递归深度是否可控」,深度大就把递归改成循环,别只是加个 Box 把栈溢出换成堆溢出。
还有一层是 Send。把 future spawn 到多线程执行器上,要求 future 是 Send。如果 async 块里持有了 Rc、RefCell 的借用,或者跨 await 持有了非 Send 的 guard,编译器会拒绝。这时不要急着加 unsafe impl Send,先想清楚「这个值跨线程是否真的安全」。多数情况下,把锁的 guard 缩短到 await 之前,问题就消失了。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
写了 async fn,什么都没执行 | Future 是惰性的,没有被 poll | 确认是否 .await,或者被 block_on/运行时接管 |
程序卡在 await 永不返回 | future 返回 Pending 却没保存/调用 waker | 检查 poll 是否注册了 waker,条件满足时是否 wake |
| 单线程执行器里一个任务卡住全部 | poll 里做了阻塞调用或长计算 | 把阻塞工作移到线程池,future 只等结果 |
| 两个 future 顺序 await 总耗时翻倍 | 没有并发组合,等待区间没有重叠 | 用 join 或手写交替 poll |
cannot borrow ... as mutable 出现在 async 块 | 跨 await 持有借用,与后续使用冲突 | 缩短借用到 await 之前,或 clone 出需要的值 |
future 无法 spawn,报不是 Send | 跨 await 持有 Rc/RefCell/非 Send guard | 换 Arc/Mutex,或缩短持有范围 |
| 定时器偶尔提前/重复触发 | 虚假唤醒、重复 wake、时间计算有误 | 用 Instant 记录起点,循环检查条件并去重 |
| CPU 占用 100%,任务却不推进 | 执行器忙轮询,没有真正 park/等待 | 确认 waker 能唤醒,Pending 时让出线程 |
边界与代价
第一层是「异步不等于快」。它优化的是等待,不是计算。一个 CPU 密集的任务放进 async,仍然占着线程,而且会让同一执行器上的其他任务排队。判断标准是「任务的时间花在等 IO 还是算数据」,前者适合异步,后者适合并行。
第二层是「运行时是必需的外部件」。标准库只提供 Future 和 Poll,不提供执行器、定时器、IO 注册、任务调度。这意味着任何真实异步程序都要引入运行时(tokio、async-std、smol 等),并接受它的生态与语义。手写执行器只适合学习和小工具,生产环境还要处理唤醒丢失、任务取消、IO 就绪、定时器精度等一堆问题。
第三层是「调试更难」。异步代码的调用栈是扁平的,错误信息里的位置经常指向 .await 而不是真正的挂起点;任务之间的顺序不确定,日志交错。要在关键状态转换处打日志,给任务起名字,必要时用运行时的 trace 功能。同步代码里一个断点能看清楚的东西,异步里可能要追好几层。
第四层是「取消语义」。future 被 drop 就等于取消,但取消点只在 await 处;一个没有 await 的长循环不会响应取消。写异步代码时要考虑「这个任务被取消时,已经做的副作用怎么收尾」,这比同步代码里的线程停止更微妙。下一篇讲 tokio 时会具体展开。
把每个 await 都当成一个可能失败、可能被取消、可能永远不返回的边界,很多设计问题会提前暴露。异步代码的可靠性不取决于写得多顺,而取决于你有没有认真处理这些边界。
第五层是「IO 从哪来」。我们手写的 Sleep 用线程睡,这在真实服务里不可扩展——一万个定时器就是一万个线程。生产级运行时会把定时器集中到一个最小堆,把 socket 注册到操作系统的就绪通知机制(Linux 的 epoll、Windows 的 IOCP),事件到达时唤醒对应任务。Rust 标准库没有这层抽象,所以「异步 IO」这件事必须依赖运行时。理解这一点,就不会问「为什么标准库不能直接 await 一个 TcpStream」了。
还有一点要避免绝对化:异步适合「等待占比高」的任务,不等于所有 IO 都适合异步。访问本地 SSD 上的小文件,很多时候同步读比异步调度还快;只有在连接数很多、等待时间远大于计算时间时,异步的调度优势才明显。判断依据是压测和实际并发量,不是「异步一定更先进」。同步代码简单、可读、调试容易,这些优点不该被一句「要上异步」抹掉。
小结
把这一篇收成四句:async fn 返回的是惰性 Future,不 poll 就不执行;poll 返回 Pending 前必须保存 waker,否则永远醒不过来;poll 里不能阻塞,阻塞会卡住整个执行器;并发的本质是等待区间重叠,不是多个任务同时占 CPU。
手写执行器让我们看清了机制,但真实项目不会自己写调度器。下一篇进入 tokio:它怎么组织任务、spawn 要求什么、取消到底发生在哪一刻、为什么一个 thread::sleep 能把整个服务拖慢。到时候再回头看这篇的 block_on,会发现 tokio 只是把这二十行做成了工业级。
当天可以自己验证的练习:
- 把
block_on改成忙轮询(Pending时不 park,直接继续),用 200 毫秒定时器观察 CPU 占用。 - 写一个 future,第一次
Pending但不保存 waker,确认block_on永久卡住。 - 给
Sleep加一个「重复 wake」的路径,确认执行器仍能正确完成而不是 panic。 - 手写一个
Join,同时推进两个 100 毫秒定时器,对比顺序 await 的总耗时。 - 在 async 块里跨
await持有一个std::sync::MutexGuard,把 future 放进tokio::spawn,记录编译器的报错原文。
这些练习不需要 tokio 也能做完前四条。做完之后再学任何运行时,你关注的就是「它怎么调度、怎么注册 IO、怎么处理取消」,而不是「为什么我的代码不跑」。