在 Rust 的生产级异步系统中,"async fn" 那行看似简单的语法糖,背后隐藏着编译器最复杂的解糖过程之一。本文将从 LLVM IR 层面,完整还原一个 async fn 如何被解糖为状态机、Generator trait 如何驱动状态迁移、Pin 类型如何保证自引用结构体的内存安全,以及 tokio 运行时如何调度和驱动这些状态机。


一、async fn 的本质:它不是一个函数

当你写下 async fn foo() -> T { ... } 时,编译器做的第一件事是否定你对"函数"的一切认知——async fn 不生成函数体,它生成一个实现了 Future trait 的匿名结构体。这个结构体就是状态机。

让我们从一个最小可复现代码出发:


async fn compute(x: u32) -> u32 {
    let a = read_db().await;
    let b = transform(a).await;
    x + b
}

解糖后的等价展开:


fn compute(x: u32) -> impl Future<Output = u32> {
    struct __ComputeStateMachine {
        x: u32,
        state: u8,
        // 等待点之间需要存活的临时变量
        a: Option<u32>,
        b: Option<u32>,
        // 嵌套的 Future 实例
        __await_0: read_db::Awaiter,
        __await_1: transform::Awaiter,
    }
    
    // ... 状态机实现
}

这不是比喻——rustc 的实际输出与此高度一致。在 MIR (Mid-level IR) 层面,编译器会识别所有 .await 点,将它们标记为状态边界,然后将每个 await 点之间的代码片段变成状态机的一个分支。


二、await 点如何成为状态边界

rustc 将 .await 脱糖为 IntoFuture::into_future().poll( cx ) 的模式匹配:


// 手写等价
match future.poll(ctx) {
    Poll::Ready(v) => v,
    Poll::Pending => return Poll::Pending,
}

在状态机中,每个 await 对应一个状态编号。让我用一个包含两个 await 的例子演示完整状态机布局:


async fn pipeline(input: Input) -> Result<Output, Error> {
    let parsed = parse(input).await?;          // await #0
    let validated = validate(parsed).await?;   // await #1  
    let result = render(validated).await?;      // await #2
    Ok(result)
}

编译器的解糖结果(MIR 简化版):


enum __PipelineState {
    __Start,
    __Await0 { parsed_fut: ParseFut, input: Input },
    __Await1 { validated_fut: ValidateFut, validated: Parsed },
    __Await2 { result_fut: RenderFut, validated: Validated },
    __Done,
}

关键观察:

  1. 存活变量跨 await 提升为状态机字段。 parsed 从 #0 活到 #1,所以它成为状态机的成员变量
  2. 嵌套的 Future 按需初始化。 parsed_fut 在 #0 状态构造,在 #0→#1 迁移时已被消费掉,所以不需要存入下一状态
  3. ? 运算符生成额外分支。 Err(e) 路径直接跳转到 __Done 状态,携带错误值返回

三、Generator trait:状态机的核心驱动协议

Rust 的状态机机制建立在 Generator trait 之上,这是 nightly 的 std::ops::Generator(稳定的 Future 本质上是它的特化版本):


#[unstable(feature = "generator_trait")]
pub trait Generator<R = ()> {
    type Yield;
    type Return;
    
    fn resume(mut self: Pin<&mut Self>, arg: R) -> GeneratorState<Self::Yield, Self::Return>;
}

Future trait 是 Generator 的特化:


pub trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

映射关系:Generator::Yield → Poll::Pending,Generator::Return → Poll::Ready(T),resume() → poll()。

Generator 的 resume 返回值是一个枚举:


enum GeneratorState<Y, R> {
    Yielded(Y),   // 对应 Poll::Pending
    Complete(R),  // 对应 Poll::Ready(T)
}

理解这一层,你就理解了为什么 async 函数不能用 fn 返回而必须返回 impl Future——因为编译器借用了 Generator 的状态机模型来生成状态机结构体。


四、Pin 类型:自引用结构体的安全契约

状态机的哪一部分需要 Pin?答案是:跨 await 存活的 Future 可能包含指向状态机其他字段的指针。

考虑这个代码:


async fn self_referential_task() {
    let data = [0u8; 4096];
    let slice = &data[100..200]; // 指向本地变量
    
    some_io().await; // 此处可能移动状态机!
    
    println!("{}", slice); // 如果上面移动了,悬垂指针!
}

状态机内存布局:


┌───────────────────────────────────────────────────┐
│ __SelfRefStateMachine                             │
│ ┌──────────────┐  ┌──────────────────────────┐   │
│ │ data: [u8;   │  │ slice: *const u8          │   │
│ │       4096]  │──│ (指向 data[100] 的指针)   │   │
│ └──────────────┘  └──────────────────────────┘   │
│ state: u8                                         │
│ __await_0: SomeIo::Awaiter                        │
└───────────────────────────────────────────────────┘

如果在 .await 返回 Poll::Pending 后,状态机被 tokio 从任务队列中取出、又被放回另一个内存地址,slice 指针就失效了。

Pin 的解决方案是编译期禁止移动。Pin

是一个包装类型,其契约是:

一旦 Pin 指向了一个值,该值在内存中的位置将永远不会改变,直到被 drop。

Pin 的实现逻辑(简化):


pub struct Pin<P>(P); // P 通常是 &mut T 或 Box<T>

impl<P: DerefMut> Pin<P> {
    pub unsafe fn new_unchecked(pointer: P) -> Self {
        Pin(pointer)
    }
    
    // 没有 pub fn get_mut() 或 &mut T!
    // 只能通过 project() 安全地投影到字段
}

关键点:Pin不提供 &mut T 访问器。如果它提供了,你就可以 unsafe 地 mem::swap 或 replace 内部值,破坏 Pin 契约。只有通过 Unpin trait 的"后门"才能绕过——而编译器会自动为不含自引用的类型实现 Unpin。

状态机中包含引用的 Future 不实现 Unpin,因此 Pin 的类型系统保证生效。


五、tokio 运行时:状态机的真实消费者

理解了解糖机制,我们来看 tokio 运行时如何消费状态机。

5.1 任务模型

tokio 中每个 async fn 调用生成一个 Task:


struct Task {
    future: Pin<Box<dyn Future<Output = ()>>>,
    // 调度状态
    scheduler: *const Scheduler,
    // waker 机制
    raw_waker: RawWaker,
}

关键:future 被 Pin<Box<_>> 包裹——这正是 Pin 在运行时的主要用途。Box 提供堆分配固定地址,Pin 禁止移动。

5.2 poll 到就绪的执行流程


tokio runtime thread
       │
       ▼
┌─────────────┐     ┌──────────────┐
│ task queue  │────▶│ poll(future, │
│ (调度队列)   │     │      cx)     │
└─────────────┘     └──────┬───────┘
                          │
              ┌───────────┴───────────┐
              ▼                       ▼
      Poll::Ready(())           Poll::Pending
              │                       │
              ▼                       ▼
        task 丢弃           注册 waker 后挂起
                                    │
                           ┌────────┴────────┐
                           │ IO 事件/定时器   │
                           │    唤醒         │
                           └────────┬────────┘
                                    ▼
                             重新入队 poll

5.3 Waker 与状态机唤醒的精确路径

当 async fn 内部调用 tokio::io::AsyncReadExt::read() 时,底层发生了什么?


// tokio 内部: TcpStream::poll_read
fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) 
    -> Poll<io::Result<()>> 
{
    // 注册当前 fd 到 epoll/IOCP
    self.io.register(cx.waker())  // 绑定 waker
    
    match self.io.try_read(buf) {
        Ok(n) => Poll::Ready(Ok(n)),
        Err(e) if e.kind() == WouldBlock => Poll::Pending, // 等待唤醒
        Err(e) => Poll::Ready(Err(e)),
    }
}

当 IO 事件到达:

  1. epoll_wait 返回就绪 fd
  2. 内核态 → 用户态事件分发
  3. 从 fd 找到绑定的 Waker
  4. 调用 waker.wake() → 设置任务状态为 Runnable
  5. 任务被重新推入调度队列
  6. 线程 poll 状态机 → 状态从 __Await0 迁移到 __Await1

六、调试状态机:深入 LLVM IR

想看编译器生成的真实状态机?用 cargo rustc -- --emit=llvm-ir:


; 对应 async fn compute(x: u32) -> u32
%"_compute::.__ComputeStateMachine" = type {
    i8,           ; state tag
    i32,          ; x
    i32,          ; a — 跨 await 存活
    i32,          ; b — 跨 await 存活
    %"read_db::__Awaiter",  ; 嵌套 Future #0
    %"transform::__Awaiter" ; 嵌套 Future #1
}

; poll 函数 —— Future::poll 的实现
define i32 @_ZN8...4compute...(i8* %self, %"Context"* %ctx) {
entry:
    %state = load i8, i8* %self
    
    ; 状态分支
    switch i8 %state, label %panic [
        i8 0, label %state_0
        i8 1, label %state_1
        i8 2, label %state_2
        i8 3, label %state_done_ready
    ]

state_0:
    ; 初始化 read_db 的 Awaiter,存储到 self.__await_0
    ; 调用 poll
    ; Pending → return Poll::Pending
    ; Ready(v) → 存入 self.a, 跳 state_1
    
state_1:
    ; 初始化 transform 的 Awaiter
    ; Pending → return Poll::Pending
    ; Ready(v) → 存入 self.b, 跳 state_2

state_2:
    ; return Poll::Ready(x + b)
}

优化层面,LLVM 会:

  • 消除未使用的零大小字段(ZST)
  • 合并状态枚举到最小位宽
  • 内联短小的 Future poll 调用

七、生产环境中的陷阱与最佳实践

7.1 状态机大小爆炸

状态机持有所有跨 await 存活的变量。一个简单的优化失误可能导致巨大的状态机:


async fn process_chunk(data: Vec<u8>) -> Vec<u8> {
    let compressed = compress(&data).await;
    data; // ❌ 此处 data 仍在状态机中!
    let encrypted = encrypt(&compressed).await;
    encrypted
}

修复:在不再需要时 drop 变量


async fn process_chunk(data: Vec<u8>) -> Vec<u8> {
    let compressed = compress(&data).await;
    drop(data); // ✅ 显式释放
    let encrypted = encrypt(&compressed).await;
    encrypted
}

查看状态机大小的方法:


fn print_size<T>() {
    println!("{}", std::mem::size_of::<T>());
}

// print_size::<YourAsyncFnReturn>();

7.2 Pin::Unpin 与 Box::pin 的战略取舍

当 Future 满足 Unpin(无自引用约束)时,可以使用非 Pin API。这带来更简单的下游调用:


// 如果 T: Unpin,可以直接使用 &mut T 而非 Pin<&mut T>
async fn no_self_ref() -> u32 { 42 } // Unpin ✅

// 相比之下,async fn with_self_ref() -> ... // !Unpin ❌

最佳实践:使用 tokio::spawn 时要求 Send + 'static,Auto Unpin 规则使得你不需要手动处理 Pin。但自定义 Future 必须手动实现 Unpin 或正确处理 Pin 投影。

7.3 async 函数中的锁与跨 await 持有

标准库的 MutexGuard 跨 await 可能导致死锁,因为运行时是多线程调度的:


// ❌ 危险:持有锁跨越 await
async fn bad() {
    let guard = mutex.lock().await;
    some_io().await; // 如果其他线程也等这把锁 → 潜在死锁
    use_guard(guard);
}

// ✅ 缩小锁的作用域
async fn good() {
    {
        let guard = mutex.lock().await;
        use_guard(guard);
    } // guard drop
    some_io().await;
}

八、对比其他语言

特性 Rust C# Python Go
状态机生成 编译器显式生成结构体 编译器生成类 生成器对象 goroutine + 栈
内存自引用安全 Pin 类型系统保证 GC 处理 GC 处理 始终可移动(栈动态增长)
暂停点 声明式 .await await 关键字 yield / await go runtime 调度
poll 模型 拉取式 (poll) 推送式 (callback) 推送式 抢占式
暂停代价 仅保存存活变量 完整状态机 完整帧 完整 goroutine 栈(初始 2KB)
最大优势 零成本 + 编译期安全 成熟工具链 简洁 极轻量并发

Rust 的独特贡献是:在 GC-free 的前提下,用 Pin 类型在编译期防止状态机自引用失效。这是其他语言要么靠 GC(C#/Python),要么永远不允许(C++ coroutine TS 的 promise_type 没有等价的 Pin)。


九、总结

async fn 的解糖是 rustc 最精妙的代码变换之一。理解这一层的开发者能做到:

  1. 诊断调试:看懂 panic backtrace 中的状态机字段名
  2. 性能优化:主动 drop 不再需要的状态,减小状态机体积
  3. 安全边界:理解 Pin 契约,正确实现自定义 Future
  4. 架构决策:在 async trait / 流式处理中选择正确的 Pin/Unpin 策略

下次你写下 .await 的时候,想想它背后——一个被精心解糖的状态机,在 Pin 的保护下安全地跨越时间边界,等待着 tokio 将它从就绪队列中唤醒,继续运行下一个状态分支。


*关键词:Rust async, 状态机, Future trait, Pin 类型, Generator, 解糖, tokio, MIR, LLVM IR*

*标签:Rust, Async, 编译器, 状态机, 底层机制*

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部