Rust 异步编程简单入门

再次祭出陈天教师的 Rust 学习路径图，记住当初初学 Rust 的时分异步编程就看了个大概，直接略过了底层原理的探求，尤其是自引用和Pin之类的概念适当枯燥难明，理解看起来着实费力。假如你的工作大部分是 CRUD，写一些和数据库打交道的 HTTP API，底层原理的东西确实用处不大，但假如你想让自己的技能树略微丰厚一些，能做一些他人做不了的工作，能面临不同的场景设计出来更高效的系统，那就需要系统的仔细的学习 Rust 异步的设计思路和精华。先用一个简略比方进入 Rust 异步编程的世界。

Rust 异步编程 async/.await

async/.await是 Rust 内置的言语特性，能够让咱们用同步的办法去编写异步的代码。

下面咱们来经过比方学习async/.await关键字该如何运用，在开始之前，需要先引入futures包。修改Cargo.toml文件并增加以下内容:

[dependencies]
futures = "0.3"

运用 async 创立一个异步 Future

简略地说，async 关键字能够用于创立如下类型的 Future：

• 界说函数：async fn
• 界说 block：async {}

比方async函数：

async fn hello_world() {
    ...
}

async关键字，将函数的原型修改为回来一个Future trait object。然后将履行的成果包装在一个新的future中回来，大致适当于：

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

注：async代码块会完结一个匿名的Future trait object，包裹一个Generator。也便是一个完结了Future的Generator。Generator实际上是一个状况机，合作.await当每次async代码块中任何回来Poll::Pending则即调用generator yeild，让出履行权，一旦恢复履行，generator resume持续履行剩余流程，当所有代码履行完，也便是状况机进入Complete，回来Poll::Ready，代表Future履行完毕。

经过async符号的语法块会被转换成完结了Future特征的状况机。与同步调用堵塞当时线程不同，当Future履行并遇到堵塞时，它会让出当时线程的操控权，等候其他Future的履行成果。

Future需要在一个履行器(executor)上运转，比方block_on 便是一个能够堵塞当时线程的履行器

// block_on 会堵塞当时线程直到指定的 Future 履行完结，这种堵塞当时线程以等候使命完结的办法较为简略、粗犷，
// 好在其它运转时的履行器(executor)会提供更加杂乱的行为，例如 join 将多个 future 调度到同一个线程上履行。
use futures::executor::block_on;
async fn hello_world() {
    println!("hello, world!");
}
fn main() {
    let future = hello_world(); // 回来一个Future, 因而不会打印任何输出
    block_on(future); // 履行 Future 并等候其运转完结，此刻 "hello, world!"会被打印输出
}

运用 await 等候另一个异步 Future 调用的完结

在上述代码的main函数中，咱们运用block_on这个履行器等候Future的完结，让代码看上去十分像是同步代码，可是假如你要在一个async fn函数中去调用另一个async fn并等候其完结后再履行后续的代码，该如何做？例如:

use futures::executor::block_on;
async fn hello_world() {
    // 在异步函数中直接调用另一个异步函数，是否会有问题？
    hello_cat();
    println!("hello, world!");
}
async fn hello_cat() {
    println!("hello, kitty!");
}
fn main() {
    let future = hello_world();
    block_on(future);
}

这儿，咱们在hello_world异步函数中先调用了另一个异步函数hello_cat，然后再输出hello, world!，看看运转成果：

warning: unused implementer of `futures::Future` that must be used
 --> src/main.rs:6:5
  |
6 |     hello_cat();
  |     ^^^^^^^^^^^^
= note: futures do nothing unless you `.await` or poll them
...
hello, world!

不出所料，main函数中的future咱们经过block_on函数进行了运转，可是这儿的hello_cat回来的Future却没有任何人去履行它，不过好在编译器友善的给出了提示：futures do nothing unless you `.await` or poll them，两种解决办法：运用.await语法或许对Future进行轮询(poll)。

后者较为杂乱，暂且不表，先来运用.await试试:

use futures::executor::block_on;
async fn hello_world() {
    hello_cat().await;
    println!("hello, world!");
}
async fn hello_cat() {
    println!("hello, kitty!");
}
fn main() {
    let future = hello_world();
    block_on(future);
}

为hello_cat()增加上.await后，成果立刻大为不同:

hello, kitty!
hello, world!

输出的次序跟代码界说的次序完全符合，因而，咱们在上面代码中运用同步的代码次序完结了异步的履行作用，十分简略、高效，并且很好理解，未来也肯定不会有回调地狱的发生。

实际上每一个.await自身就像一个履行器，在循环中查询Future的状况。假如回来Pending，则yield，否则退出循环，完毕当时Future。

代码逻辑大致如下：

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

总归，在async fn函数中运用.await能够等候另一个异步调用的完结。可是与block_on不同，.await并不会堵塞当时的线程，而是异步的等候Future A的完结，在等候的过程中，该线程还能够持续履行其它的Future B，最终完结了并发处理的作用。

一个比方

考虑一个欢欣鼓舞的比方，假如不用.await，咱们可能会有如下完结：

use futures::executor::block_on;
struct Song {
    author: String,
    name: String,
}
async fn learn_song() -> Song {
    Song {
        author: "周杰伦".to_string(),
        name: String::from("《菊花台》"),
    }
}
async fn sing_song(song: Song) {
    println!(
        "给我们献上一首{}的{} ~ {}",
        song.author, song.name, "菊花残，满地伤~ ~"
    );
}
async fn dance() {
    println!("唱到情深处，身体不由自主的动了起来~ ~");
}
fn main() {
    let song = block_on(learn_song()); // 第一次堵塞
    block_on(sing_song(song)); // 第二次堵塞
    block_on(dance()); // 第三次堵塞
}

以上代码运转成果无疑是正确的，但需要经过接连三次堵塞去等候三个使命的完结，一次只能做一件事，实际上咱们完全能够欢欣鼓舞。

use futures::executor::block_on;
struct Song {
    author: String,
    name: String,
}
async fn learn_song() -> Song {
    Song {
        author: "周杰伦".to_string(),
        name: String::from("《菊花台》"),
    }
}
async fn sing_song(song: Song) {
    println!(
        "给我们献上一首{}的{} ~ {}",
        song.author, song.name, "菊花残，满地伤~ ~"
    );
}
async fn dance() {
    println!("唱到情深处，身体不由自主的动了起来~ ~");
}
async fn learn_and_sing() {
    // 这儿运用 .await 来等候学歌的完结，可是并不会堵塞当时线程
    let song = learn_song().await;
    // 歌唱必须要在学歌之后，也便是sing_song Future 必须等候learn_song Future 完结
    sing_song(song).await;
}
async fn async_main() {
    let f1 = learn_and_sing(); // 学歌然后歌唱的 Future
    let f2 = dance(); // 跳舞的 Future
    // join!宏 能够并发的处理和等候多个 Future
    // 若 learn_and_sing Future 被堵塞，那 dance Future 能够拿过线程的所有权持续履行。若 dance 也变成堵塞状况，那 learn_and_sing 又能够再次拿回线程所有权，持续履行。
    // 若两个都被堵塞，那么 async main 会变成堵塞状况，然后让出线程所有权，并将其交给 main 函数中的 block_on 履行器
    futures::join!(f1, f2);
}
fn main() {
    block_on(async_main());
}

上面代码中，学歌和歌唱具有显着的先后次序，可是这两者都能够跟跳舞一同存在，也便是你能够在跳舞的时分学歌，也能够在跳舞的时分歌唱。假如上面代码不运用.await，而是运用block_on(learn_song())， 那在学歌时，当时线程就会堵塞，不再能够做其它任何事，包括跳舞。

因而.await对于完结异步编程至关重要，它允许咱们在同一个线程内并发的运转多个使命，而不是一个一个先后完结。

至此，对 Rust 的async/.await异步编程有了一个明晰的初步形象，后续再深度学习这背后的原理：Future和使命在底层如何被履行。

注：实际上async/.await经过一个状况机来操控代码的流程，合作履行器Executor完结协程的切换，编写异步代码不需要手动写Future及其poll办法，特别是异步逻辑的状况机也是由async自动生成，大大简化程序员的工作。

总结

async/.await是 Rust 的内置工具，用于编写看起来像同步代码的异步函数，async将一个代码区块，转换为完结称为Futuretrait 的状况机，Future需要在一个 executor 上运转。而在同步办法中，调用堵塞函数将堵塞整个线程，Future 将 yield 对线程的操控权，允许其他Future运转。在async fn函数中运用.await能够等候另一个异步调用的完结。可是与block_on不同，.await并不会堵塞当时的线程，而是异步的等候Future A的完结，在等候的过程中，该线程还能够持续履行其它的Future B，最终完结了并发处理的作用。

• Future 代表一个可在未来某个时分获取回来值的 task，在 Rust 中是惰性的，只有在被轮询(poll)时才会运转
• async 用于创立一个Future，比方创立一个异步函数或许异步代码块
• await 自身就像一个履行器，在循环中查询Future的状况，等候另一个 Future 的完结
• executor 是Future的管理和履行器， 比方 block_on 是一个能够堵塞当时线程的履行器
• async 在 Rust 中运用零开销的，无需分配任何堆内存、也无需任何动态分发来运用async
• async/await是 Rust 言语层面支持等关键字，可是并没有内置异步调用所必需的运转时，需要引入第三方运转时完结，例如tokio ， async-std，smol 等

总归，async/await是 Rust 的异步编程模型，是产生和运转并发使命的手法，async 来方便地生成 Future，await 来触发 Future 的调度和履行。

参阅

• course.rs/advance/asy…
• liubin.org/blog/2021/0…
• blog.pan93.com/what-is-rus…
• zhuanlan.zhihu.com/p/611587154
• tutzip.com/tut/rust-as…
• cfsamson.github.io/books-futur…