很多人第一次写异步都会遇到同一个困惑:明明写了 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 只是把这二十行做成了工业级。

当天可以自己验证的练习:

  1. 把 block_on 改成忙轮询(Pending 时不 park,直接继续),用 200 毫秒定时器观察 CPU 占用。
  2. 写一个 future,第一次 Pending 但不保存 waker,确认 block_on 永久卡住。
  3. 给 Sleep 加一个「重复 wake」的路径,确认执行器仍能正确完成而不是 panic。
  4. 手写一个 Join,同时推进两个 100 毫秒定时器,对比顺序 await 的总耗时。
  5. 在 async 块里跨 await 持有一个 std::sync::MutexGuard,把 future 放进 tokio::spawn,记录编译器的报错原文。

这些练习不需要 tokio 也能做完前四条。做完之后再学任何运行时,你关注的就是「它怎么调度、怎么注册 IO、怎么处理取消」,而不是「为什么我的代码不跑」。