8. 直接了当的Future

距离我写完《Rust速成课》系列的最后一部已经有一年了。最后一个帖子非常精彩，深入到了 async，futures 和 tokio。所有这些都在一个帖子里。这有点虐待狂的味道，在这一点上我为自己感到骄傲。

从那以后发生了很多事情。重要的是：Future特性已移入标准库本身，并吸收了一些修改。然后，为了更好地结合起来，有了一个新的 async/.await 语法。在Rust中编写异步代码时，我很难高估生活质量的差异有多大。

我最近在 FP Complete 技术网站上写了一篇文章，演示了 Future 和async/.await 在实践中的应用。但是在这里，我想对表面情况进行更彻底的分析。与第7课不同，我将跳过为什么要编写异步代码的动机，并将其分解为更易消化的部分。像第7课一样，我将内联包含练习题方案，而不是单独发布。

在本示例中，我将使用 async-std 库而不是 tokio。我唯一真正的原因是，在 tokio 发布了对新 async/await语法的支持之前，我开始使用async-std。一般来说，我还不准备考虑我更喜欢哪个库。

您应该启动一个 Cargo 项目来配合。试试 cargo new --bin sleepus-interruptus。如果要确保使用相同的编译器版本，请添加一个 rust-toolchain 文件，其中包含字符串1.39.0。运行 cargo run 确保你们都准备好了。

这篇文章是基于 FP 完成 Rust 教学系列的一部分。如果你在博客之外阅读这篇文章，你可以在介绍文章的顶部找到这个系列中所有文章的链接。也可订阅 RSS 频道。

中断睡眠

我想编写一个程序，将打印 Sleepus 消息 10 次，延迟0.5秒。然后打印Interruptus 消息5次，延迟1秒。这是一些相当简单的 Rust 代码：

use std::thread::{sleep};
use std::time::Duration;

fn sleepus() {
    for i in 1..=10 {
        println!("Sleepus {}", i);
        sleep(Duration::from_millis(500));
    }
}

fn interruptus() {
    for i in 1..=5 {
        println!("Interruptus {}", i);
        sleep(Duration::from_millis(1000));
    }
}

fn main() {
    sleepus();
    interruptus();
}

但是，正如我的巧妙命名所暗示的，这不是我的真正目标。该程序同步运行两个操作，首先打印Sleepus，然后打印Interruptus。相反，我们希望以交错的方式打印这两套语句。这样一来，间断实际上就做了一些中断。

练习：使用 std::thread::spawn 函数创建一个操作系统线程，使这些打印的语句交错。

解决这个问题有两种基本方法。第一种方法(也许更明显)是为每个函数生成一个单独的线程，然后等待每个函数完成：

use std::thread::{sleep, spawn};

fn main() {
    let sleepus = spawn(sleepus);
    let interruptus = spawn(interruptus);

    sleepus.join().unwrap();
    interruptus.join().unwrap();
}

注意两件事：

我们调用 spawn 为 spawn(sleepus)，而不是 spawn(sleepus()) 。前者通过函数 spawn 驱动 sleepus 来运行，后者会立即运行 sleappus() 并将其结果传递给 spawn，这不是我们想要的。
我在 main 函数/线程中使用 join() 等待子线程结束。因为我很懒，所以我使用 unwrap 来处理可能发生的任何错误。

另一种方法是创建一个辅助线程，然后调用主线程中的一个函数：

fn main() {
    let sleepus = spawn(sleepus);
    interruptus();

    sleepus.join().unwrap();
}

这样更有效率(产生线程的时间更少，用于保存线程的内存更少) ，并且没有真正的缺点。我建议走这条路。

问题：如果我们没有在第二个 spawn 版本中调用 join 的话，该程序的行为是什么？如果我们不调用第一个 spawn 版本的 join 会怎么样？

但是这根本不是一个异步解决问题的方法！我们有两个线程正在处理的操作系统，它们既同步运行又对睡眠进行阻塞调用。让我们建立一些直觉，来了解如何让我们的两个任务(打印“睡眠”和打印“中断”)在一个线程中更好地协同工作。

async 介绍

我们将从最高层次的抽象开始，逐步深入到理解细节。让我们用异步方式重写我们的应用程序。将以下内容添加到 Cargo.toml：

async-std = { version = "1.2.0", features = ["attributes"] }

现在我们可以重写我们的应用程序如下：

use async_std::task::{sleep, spawn};
use std::time::Duration;

async fn sleepus() {
    for i in 1..=10 {
        println!("Sleepus {}", i);
        sleep(Duration::from_millis(500)).await;
    }
}

async fn interruptus() {
    for i in 1..=5 {
        println!("Interruptus {}", i);
        sleep(Duration::from_millis(1000)).await;
    }
}

#[async_std::main]
async fn main() {
    let sleepus = spawn(sleepus());
    interruptus().await;

    sleepus.await;
}

让我们从头到尾来看看这些变化：

我们从 async_std::task 获取它们，而不是从 std::thread 获取 sleep 和 spawn
现在 sleepus 和 interruptus 前带上了 async
在调用 sleepus 后，我们有一个.await。请注意，这不是 .await() 方法调用，而是新的语法
在 main 函数中有一个新属性 #[async_std::main]
我们现在传入 spawn(sleepus()) 而不是 spawn(sleepus)，而是传入函数本身，然后立即运行该函数并将其结果传递给 spawn
现在，对 interruptus() 的之后调用 .await
我们使用.await 语法来代替 JoinHandle 上的 join()

练习：在您自己的机器上运行此代码，并确保所有代码都按预期编译和运行。然后尝试撤销上面列出的一些更改，看看是什么生成了编译器错误，以及是什么产生了不正确的运行时行为。

这看起来像是一大堆更改。但实际上，我们的代码在结构上与以前的版本几乎相同，这是对 async/.await 语法的真实证明。一切都按照我们希望的方式在表面下工作: 一个单独的操作系统线程进行非阻塞调用。

让我们来分析一下这些修改的实际含义。

async 函数

将 async 添加到函数定义的开头可以做三件事：

它允许你在内部使用 .await 语法，我们稍后会解释它的含义。
它修改了函数的返回类型。 async fn foo ()-> Bar 实际上返回 impl std::Future::Future<Output = Bar> 。
自动将结果值包装在新的Future中。稍后我们会证明这一点更好。

让我们稍微解释一下第二点。在标准库中定义了一个叫做 Future 的特性。它有一个关联的 Output 类型。这个 trait 的意思是：我保证，当我完成的时候，我会给你一个类型 Output 的值。例如，您可以设想一个异步 HTTP 客户端，它看起来像这样：

impl HttpRequest {
    fn perform(self) -> impl Future<Output=HttpResponse> { ... }
}

发出该请求将需要一些非阻塞 I/O。在这些情况发生时，我们不想阻塞调用线程。但是我们确实希望以某种方式获得最终的响应。

稍后我们将更直接地讨论 Future 值。目前，我们将继续使用高级 async/.await 语法。

练习：通过修改其结果类型，将sleepus的签名重写为不使用async关键字。请注意，当您获得正确的类型时，代码将不会编译。注意你得到的错误信息。

async fn sleepus() 的结果类型是隐含的单元值 ()。因此，我们 Future 的 Output 应该是单元的。这意味着我们需要把我们的签名写成：

fn sleepus() -> impl std::future::Future<Output=()>

然而，只有这样的改变，我们才能得到下面的错误消息:

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/main.rs:7:9
  |
4 | fn sleepus() -> impl std::future::Future<Output=()> {
  |    ------- this is not `async`
...
7 |         sleep(Duration::from_millis(500)).await;
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ only allowed inside `async` functions and blocks

error[E0277]: the trait bound `(): std::future::Future` is not satisfied
 --> src/main.rs:4:17
  |
4 | fn sleepus() -> impl std::future::Future<Output=()> {
  |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `()`
  |
  = note: the return type of a function must have a statically known size

第一条消息非常直接：您只能在异步函数或块内使用.await语法。我们还没有看到异步块，但这听起来像是：

async {
    // async noises intensify
}

第二个错误消息是第一个错误消息的结果: async 关键字导致返回类型为 impl Future。如果没有这个关键字，我们的 for 循环计算结果为 () ，这不是 impl Future。

练习：修正编译器错误，在圆角函数中引入异步块。不要在函数签名中添加异步，继续使用 impl Future。

用异步块包装整个函数体解决了这个问题：

fn sleepus() -> impl std::future::Future<Output=()> {
    async {
        for i in 1..=10 {
            println!("Sleepus {}", i);
            sleep(Duration::from_millis(500)).await;
        }
    }
}

.await 1分钟

也许我们不需要所有这些 async/.await 垃圾。如果我们取消对 sleepus中的 .await 用法的调用，该怎么办？也许令人惊讶的是，它编译了，尽管确实给了我们不祥的警告：

warning: unused implementer of `std::future::Future` that must be used
 --> src/main.rs:8:13
  |
8 |             sleep(Duration::from_millis(500));
  |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_must_use)]` on by default
  = note: futures do nothing unless you `.await` or poll them

我们创建了 Future 的值，但并没有使用它。当然，如果你看看我们程序的输出，你就会明白编译器的意思:

Interruptus 1
Sleepus 1
Sleepus 2
Sleepus 3
Sleepus 4
Sleepus 5
Sleepus 6
Sleepus 7
Sleepus 8
Sleepus 9
Sleepus 10
Interruptus 2
Interruptus 3
Interruptus 4
Interruptus 5

我们所有的 Sleepus 消息都会立即打印输出。有趣！问题在于，对 sleep 的调用实际上不再使我们当前的线程进入睡眠状态。相反，它生成一个实现Future的值。当这个承诺最终实现的时候，我们知道延迟已经发生了。但在我们的案例中，我们只是简单地忽略了 Future，因此从来没有真正地延迟过。

为了了解 .await 语法的作用，我们将直接使用 Future 值来实现我们的功能。让我们从去掉 async 块开始。

删除 async 阻塞

如果我们删除 async 块，我们会得到这样的代码：

fn sleepus() -> impl std::future::Future<Output=()> {
    for i in 1..=10 {
        println!("Sleepus {}", i);
        sleep(Duration::from_millis(500));
    }
}

这给出了一个我们之前看到的错误消息：

error[E0277]: the trait bound `(): std::future::Future` is not satisfied
 --> src/main.rs:4:17
  |
4 | fn sleepus() -> impl std::future::Future<Output=()> {
  |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `()`
  |

这是有意义的: for 循环的计算结果为 () ，而 () 未实现 Future。解决这个问题的一种方法是在 for 循环之后添加一个表达式，计算结果为实现 Future 的内容。我们已经知道这样一件事: sleep。

练习：调整sleepus函数，使其编译。

fn sleepus() -> impl std::future::Future<Output=()> {
    for i in 1..=10 {
        println!("Sleepus {}", i);
        sleep(Duration::from_millis(500));
    }
    sleep(Duration::from_millis(0))
}

我们仍然会收到关于for循环中未使用的Future值的警告，但之后没有一个警告：该函数正在返回一个警告。但是不会得到以后的警告: 这个值是从函数返回的。但是，当然，睡0毫秒只是一种冗长的什么都不做的方式。如果有一个更明确地什么都不做的“虚拟” Future，那就好了。幸运的是，确实有。

练习：将 for 循环后的 sleep 调用替换为 ready 调用。

fn sleepus() -> impl std::future::Future<Output=()> {
    for i in 1..=10 {
        println!("Sleepus {}", i);
        sleep(Duration::from_millis(500));
    }
    async_std::future::ready(())
}

实现我们自己的 Future

要进一步去除洋葱皮，让我们更加努力，而不是使用现成的函数。相反，我们将定义我们自己的结构来实现 Future。我打算叫 DoNothing。

use std::future::Future;

struct DoNothing;

fn sleepus() -> impl Future<Output=()> {
    for i in 1..=10 {
        println!("Sleepus {}", i);
        sleep(Duration::from_millis(500));
    }
    DoNothing
}

练习：该代码无法编译。如果不查看下面的内容或询问编译器，您认为它会抱怨什么？

这里的问题是 DoNothing 没有提供 Future 实现。我们将做一些编译器驱动的开发，并让 rustc 告诉我们如何修复我们的程序。我们的第一个错误消息是：

the trait bound `DoNothing: std::future::Future` is not satisfied

因此，让我们添加一个 trait 实现：

impl Future for DoNothing {
}

失败的原因是：

error[E0046]: not all trait items implemented, missing: `Output`, `poll`
 --> src/main.rs:7:1
  |
7 | impl Future for DoNothing {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^ missing `Output`, `poll` in implementation
  |
  = note: `Output` from trait: `type Output;`
  = note: `poll` from trait: `fn(std::pin::Pin<&mut Self>, &mut std::task::Context<'_>) -> std::task::Poll<<Self as std::future::Future>::Output>`

我们还真的不了解 Pin<&mut Self> 或 Context，但我们确实了解Output。并且由于我们之前是从 Ready 调用返回 ()，所以我们在这里做同样的事情。

use std::pin::Pin;
use std::task::{Context, Poll};

impl Future for DoNothing {
    type Output = ();

    fn poll(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Self::Output> {
        unimplemented!()
    }
}

哇，编译！当然，由于 unimplemented!() 调用，它在运行时失败：

thread 'async-std/executor' panicked at 'not yet implemented', src/main.rs:13:9

现在让我们尝试实现 poll。我们需要返回一个类型为 Poll <self::output> 或 Poll <()> 的值。让我们来看看 Poll 的定义：

pub enum Poll<T> {
    Ready(T),
    Pending,
}

使用一些基本的推理，我们可以看到 Ready 意味着“我们的 Future 已经完成，然后是输出” ，而 Pending 意味着“还没有完成”。鉴于我们的NoNothing 想要立即返回 ()，我们可以在这里使用 Ready 。

练习：实现 poll 的工作版本。

fn poll(self: Pin<&mut Self>, _ctx: &mut Context) -> Poll<Self::Output> {
    Poll::Ready(())
}

恭喜，您刚刚实现了您的第一个 Future 结构体！

The third `async` difference

记住上面我们说过让一个函数异步做第三件事：

自动将结果值包装在一个新的 Future 中。稍后我们将更好地证明这一点。

稍后，让我们更好地证明这一点。

让我们将sleepus的定义简化为：

fn sleepus() -> impl Future<Output=()> {
    DoNothing
}

编译和运行都很好。让我们尝试切换回 async 方式来编写签名：

async fn sleepus() {
    DoNothing
}

我们获得了一个错误：

error[E0271]: type mismatch resolving `<impl std::future::Future as std::future::Future>::Output == ()`
  --> src/main.rs:17:20
   |
17 | async fn sleepus() {
   |                    ^ expected struct `DoNothing`, found ()
   |
   = note: expected type `DoNothing`
              found type `()`

您可以看到，当您有一个异步函数或块时，结果将自动包装在 Future 中。因此，我们不返回 DoNothing，而是返回一个 impl Future<Output = DoNothing> 。我们的类型需要 Output = ()。

练习：尝试猜测您需要向这个函数添加什么以使它能够编译。

解决这个问题非常容易：您只需将.await附加到DoNothing上：

async fn sleepus() {
    DoNothing.await
}

这使我们对 .await 所做的事情有了更多的直觉：它从某种程度上从DoNothing Future 中提取 () 输出。但是，我们仍然真的不知道它是如何实现的。让我们建立一个更复杂的 Future 来靠近。

SleepPrint

我们将构建一个新的 Future 实现，它是：

睡眠一定的时间
然后打印一条信息

这将涉及使用固定指针。我将不在这里描述。固定事件的具体细节并不能很好地启发 Future 主题。如果您希望对代码的这一部分感到满意，那么您就不会错过太多。

我们对 SleepPrint 的实现策略是用我们自己的 Future 封装一个现有的 sleep Future。由于我们不知道 sleep 调用结果的确切类型（这只是一个隐含的 future ），因此我们将使用一个参数：

struct SleepPrint<Fut> {
    sleep: Fut,
}

我们可以在sleepus函数中使用以下命令调用此函数：

fn sleepus() -> impl Future<Output=()> {
    SleepPrint {
        sleep: sleep(Duration::from_millis(3000)),
    }
}

当然，我们现在得到一个关于缺少的 Future 实现的编译器错误。所以让我们一起努力。我们的 impl 开始于:

impl<Fut: Future<Output=()>> Future for SleepPrint<Fut> {
    ...
}

这表示，如果 SleepPrint 包含的 sleep 值是输出类型为 () 的Future，则它是 Future。当然，对于 sleep 函数而言，这是正确的。很好。我们需要定义输出：

type Output = ();

然后我们需要一个 poll 函数：

fn poll(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Self::Output> {
    ...
}

接下来的一点是包裹令人眼花缭乱的固定指针部分。我们需要将Pin<mut Self> 投影到 Pin＆mut Fut> 中，以便我们可以处理底层的 sleep Future。我们可以使用一个帮助框架来使它更漂亮一些，但是我们需要做一些不安全的map:

let sleep: Pin<&mut Fut> = unsafe { self.map_unchecked_mut(|s| &mut s.sleep) };

好了，现在最重要的是。我们拥有基本的 future，我们需要用它做些什么。我们唯一能做的就是调用 poll。poll 需要一个 &mut Context，幸运的是我们已经提供了这个上下文。该上下文包含当前正在运行的任务的信息，因此当任务准备好时，它可以被唤醒(通过 Waker)。

注意: 在本文中，我们不打算深入探讨 Waker 是如何工作的。如果你想要一个现实生活中的例子来说明调用 Waker，我建议你阅读我在 Rust 博客上的 pid1。

目前，让我们做我们可以合理做的唯一一件事：

match sleep.poll(ctx) {
    ...
}

有两种可能。如果 poll 返回 Pending，则表示 sleep 还没有完成。在这种情况下，我们希望我们的 future 也表明它还没有完成。为了实现这个功能，我们只需要传播 Pending 值：

Poll::Pending => Poll::Pending,

但是如果 sleep 已经完成，我们就会收到一个 Ready(()) 变量。在这种情况下，终于是时候打印我们的消息，然后传播 Ready：

Poll::Ready(()) => {
    println!("Inside SleepPrint");
    Poll::Ready(())
},

就这样，我们已经从一个简单的 future 演变成了一个更复杂的 future。但这是临时的。

TwoFutures

SleepPrint是临时的：它对在Future结束后要执行的特定操作进行硬编码。让我们开始游戏，并对两个不同的Future的动作进行排序。我们将定义一个具有三个字段的新结构：

第一个 future 运行
第二个 future 运行
使用一个 bool 告诉我们是否完成了第一个 future

由于 Pin 的东西会变得有点复杂，现在是时候使用帮助框架来简化我们的实现并避免不安全的阻塞了。因此，在 Cargo.toml 中添加以下内容:

pin-project-lite = "0.1.1"

现在，我们可以定义一个TwoFutures结构，该结构允许我们将第一个和第二个Future投影到固定的指针中：

use pin_project_lite::pin_project;

pin_project! {
    struct TwoFutures<Fut1, Fut2> {
        first_done: bool,
        #[pin]
        first: Fut1,
        #[pin]
        second: Fut2,
    }
}

在 sleepus 中使用这个非常简单：

fn sleepus() -> impl Future<Output=()> {
    TwoFutures {
        first_done: false,
        first: sleep(Duration::from_millis(3000)),
        second: async { println!("Hello TwoFutures"); },
    }
}

现在，我们只需要定义我们的 Future 实现。容易吧？我们要确保 Fut1 和 Fut2 均为 future。我们的输出将是 Fut2 的输出。（如果需要，您还可以返回第一和第二个输出）。要使所有这些工作：

impl<Fut1: Future, Fut2: Future> Future for TwoFutures<Fut1, Fut2> {
    type Output = Fut2::Output;

    fn poll(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Self::Output> {
        ...
    }
}

为了使用固定的指针，我们将获得一个新值，该值将投影所有指针：

let this = self.project();

这样一来，我们就可以直接与我们的三个领域进行互动。我们要做的第一件事是检查第一个 Future 是否已经完成。如果没有，我们将对其进行 poll。如果 poll 测验为Ready，则我们将忽略输出，并指出第一个Future已完成：

if !*this.first_done {
    if let Poll::Ready(_) = this.first.poll(ctx) {
        *this.first_done = true;
    }
}

接下来，如果第一个 future 已经完成，我们希望对第二个进行 poll。如果第一个 future 没有完成，那么我们说我们正在等待：

if *this.first_done {
    this.second.poll(ctx)
} else {
    Poll::Pending
}

就这样，我们一起创造了两个 future，一个更大、更宏伟、更光明的 future。

练习：立刻去掉异步块的用法，让编译器的错误引导你。

您收到的错误消息 () 不是 future。相反，您需要在调用 println! 之后返回 Future 值。我们可以使用方便的 async_std::future:: ready：

second: {
    println!("Hello TwoFutures");
    async_std::future::ready(())
},

AndThen

像这样把两个任意的 future 粘在一起是很好的。但是第二个future取决于第一个future的结果就更好了。要做到这一点，我们需要一个类似 and_then 的函数(Monads FTW 给我的 Haskell 伙伴)。我不打算在这里用实现的血淋淋的细节来烦你，但是如果你感兴趣的话，请随意阅读 Gist。假设你有这个方法，我们可以自己编写这个函数:

fn sleepus() -> impl Future<Output = ()> {
    println!("Sleepus 1");
    sleep(Duration::from_millis(500)).and_then(|()| {
        println!("Sleepus 2");
        sleep(Duration::from_millis(500)).and_then(|()| {
            println!("Sleepus 3");
            sleep(Duration::from_millis(500)).and_then(|()| {
                println!("Sleepus 4");
                async_std::future::ready(())
            })
        })
    })
}

在 Rust 1.39 和 async/.await 语法之前，基本上这就是异步代码的工作方式。这远非完美。除了明显的正确步骤外，它实际上不是循环。您可以递归调用 sleepus，但是这会创建一个编译器不太喜欢的无限类型。

但是幸运的是，我们现在终于建立了足够的背景知识，可以轻松地解释 .await 语法在做什么，and_then到底在做什么，但不必大惊小怪！

练习：重写上面的 sleepus 函数以使用 .await 代替 and_then。

重写真的很简单，函数的主体变成了非正确的步骤，超扁平化：

println!("Sleepus 1");
sleep(Duration::from_millis(500)).await;
println!("Sleepus 2");
sleep(Duration::from_millis(500)).await;
println!("Sleepus 3");
sleep(Duration::from_millis(500)).await;
println!("Sleepus 4");

然后，我们还需要更改函数的签名以使用异步，或者将所有内容包装到异步块中。你说了算。

除了在此处明显改善了可读性之外，.await 还具有一些巨大的可用性改进。一个突出的问题是它与循环绑定的容易程度。对于较早的 future，这确实是一个痛苦。另外，将多个await调用连在一起非常容易，例如：

let body = make_http_request().await.get_body().await;

不仅如此，还与 ? 完美的错误处理运算符。上面的示例更有可能是：

let body = make_http_request().await?.get_body().await?;

main 属性

最后一个谜团还没有解开，那就是 main 上那个奇怪的属性究竟是怎么回事：

#[async_std::main]
async fn main() {
    ...
}

我们的 sleepus 函数和 interruptus 函数实际上什么都不做。他们提供 Future 有关工作方法的说明。有些东西必须真正地执行这些动作。执行这些操作的是一个执行者。async-std 库提供了一个执行器，tokio 也是如此。为了运行任何 Future，您需要一个执行程序。

上面的属性自动用 async-std 的执行程序包装 main 函数。然而，属性方法完全是可选的。相反，您可以使用 async std::task::block on。

练习：重写 main 以避免使用该属性。您需要将其从 async fn main 重写到 fn main。

由于我们在 main 主体中使用 .await，当我们简单地删除异步限定符时，会出现错误。因此，我们需要在 main 内部使用一个异步块（或定义一个单独的辅助异步函数）。综上所述：

fn main() {
    async_std::task::block_on(async {
        let sleepus = spawn(sleepus());
        interruptus().await;

        sleepus.await;

每个执行者都有能力管理多个任务。每个任务都在努力产生单个Future的输出。就像线程一样，您可以生成其他任务以使并发运行。这正是我们实现所需交互的方式！

协作并发

一句话警告。 Future 和 async/.await 实现了一种协作并发形式。相比之下，操作系统线程提供了抢占式并发。重要的区别在于，在协作并发中，您必须协作。如果您的一项任务导致了延迟，例如通过使用 std::thread::sleep或通过执行大量 CPU 计算，则不会中断该任务。

这样做的结果是您应确保在任务内部不执行阻塞调用。而且，如果您要执行占用大量 CPU 的任务，则可能值得为其生成 OS 线程，或者至少确保执行者不会饿死您的其他任务。

总结

我认为.await表面下的行为并不能说明什么，但我认为准确了解此处发生的情况很有用。特别是，了解Future值与将Future值的输出实际链接在一起之间的区别是，正确使用 async/.await 的核心。幸运的是，编译器错误和警告在引导您朝正确的方向方面做得很好。

在下一课中，我们可以开始使用我们新获得的 Future 知识和 async/.await 语法来构建一些异步应用程序。我们将致力于使用Tokio 0.2编写一些异步 I / O，包括网络代码。

练习

这里有一些可以带回家做的练习，你可以根据 Gist 中的代码做练习。

修改 main 函数以调用 spawn 两次而不是一次。
修改 main 函数以便根本不调用 spawn。相反，使用 join。您需要添加一个使用 async_std::prelude::* ; 并将“unstable”特性添加到 Cargo.toml 中的 async-std 依赖项中。
修改main函数以获得非交互行为，该程序在 Interruptus 之前多次打印Sleepus。
我们仍在使 println! 打印用阻止 I/O。再次打开“unstable”功能，然后尝试使用 async_std::println。您会收到一条难看的错误消息，直到您摆脱了错误为止。尝试了解为什么会发生这种情况。
编写一个函数foo，以使以下断言得以通过：assert_eq!(42, async_std::task::block_on(async { foo().await.await }));

上一页7. Async,Futures和Tokio 下一页9. Tokio 0.2

最后更新于3年前