作者:谢敬伟,江湖人称“刀哥”,20年IT老兵,数据通信网络专家,电信网络架构师,目前任Netwarps开发总监。刀哥在操作系统、网络编程、高并发、高吞吐、高可用性等领域有多年的实践经验,并对网络及编程等方面的新技术有浓厚的兴趣。


2019年底Rust正式支持 async/await语法,完成了Rust协程的最后一块拼图,从而异步代码可以用一种类似于Go的简洁方式来书写。然而对于程序员来讲,还是很有必要理解async/await的实现原理。

async

简单地说,async语法生成一个实现 Future 对象。如下async函数:

async fn foo() -> {
    ...
}

async关键字,将函数的原型修改为返回一个Future trait object。然后将执行的结果包装在一个新的future中返回,大致相当于:

fn foo() -> impl Future<Output = ()> {
    async { ... }
}

更重要的是async 代码块会实现一个匿名的 Future trait object ,包裹一个 Generator。也就是一个实现了 FutureGeneratorGenerator实际上是一个状态机,配合.await当每次async 代码块中任何返回 Poll::Pending则即调用generator yeild,让出执行权,一旦恢复执行,generator resume 继续执行剩余流程。

以下是这个状态机Future的代码:

pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
where
    T: Generator<ResumeTy, Yield = ()>,
{
    struct GenFuture<T: Generator<ResumeTy, Yield = ()>>(T);

    impl<T: Generator<ResumeTy, Yield = ()>> !Unpin for GenFuture<T> {}

    impl<T: Generator<ResumeTy, Yield = ()>> Future for GenFuture<T> {
        type Output = T::Return;
        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
            let gen = unsafe { Pin::map_unchecked_mut(self, |s| &mut s.0) };

            match gen.resume(ResumeTy(NonNull::from(cx).cast::<Context<'static>>())) {
                GeneratorState::Yielded(()) => Poll::Pending,  // 当代码无法继续执行,让出控制权,返回 Pending,等待唤醒
                GeneratorState::Complete(x) => Poll::Ready(x), // 执行完毕
            }
        }
    }
    GenFuture(gen)
}

可以看到这个特别的Future是通过Generator来运行的。每一次gen.resume()会顺序执行async block中代码直到遇到yieldasync block中的.await语句在无法立即完成时会调用yield交出控制权等待下一次resume。而当所有代码执行完,也就是状态机进入Completeasync block返回Poll::Ready,代表Future执行完毕。

await

每一个await本身就像一个执行器,在循环中查询Future的状态。如果返回Pending,则 yield,否则退出循环,结束当前Future

代码逻辑大致如下:

loop {
    match some_future.poll() {
        Pending => yield,
        Ready(x) => break
    }
}

为了更好地理解async/await的原理,我们来看一个简单例子:

async fn foo() {
    do_something_1();
    some_future.await;
    do_something_2();
}

使用async修饰的异步函数foo被改写为一个Generator状态机驱动的Future,其内部有一个some_future.await,中间穿插do_something_x()等其他操作。当执行foo().await时,首先完成do_something_1(),然后执行some_future.await,若some_future返回Pending,这个Pending被转换为yield,因此顶层foo()暂时也返回Pending,待下次唤醒后,foo()调用resume()继续轮询some_future,若some_future返回Ready,表示some_future.await完毕,则foo()开始执行do_something_2()

这里的关键点在于,因为状态机的控制,所以当foo()再次被唤醒时,不会重复执行do_something_1(),而是会从上次yield的的地方继续执行some_future.await,相当于完成了一次任务切换,这也是无栈协程的工作方式。

总结

async/await 通过一个状态机来控制代码的流程,配合Executor完成协程的切换。在此之后,书写异步代码不需要手动写Future及其poll方法,特别是异步逻辑的状态机也是由async自动生成,大大简化程序员的工作。虽然async/await出现的时间不长,目前纯粹使用async/await书写的代码还不是主流,但可以乐观地期待,今后更多的项目会使用这个新语法。

参考
Futures Explained in 200 Lines of Rust


深圳星链网科科技有限公司(Netwarps),专注于互联网安全存储领域技术的研发与应用,是先进的安全存储基础设施提供商,主要产品有去中心化文件系统(DFS)、企业联盟链平台(EAC)、区块链操作系统(BOS)。
微信公众号:Netwarps