在Rust中async/await的目的是什么？

后

use std::io;

async fn fill_up(buf: &mut [u8]) -> io::Result {
    for b in buf.iter_mut() { *b = 42 }
    Ok(buf.len())
}

async fn foo() -> Vec {
    let mut data = vec![0; 8];
    fill_up(&mut data).await.expect("IO failed");
    data
}

这有效!

Future另一方面,围绕期货的整个系统的实施和设计与关键字async和无关await.实际上,在async/ await关键字存在之前,Rust拥有蓬勃发展的异步生态系统(例如Tokio).Javascript也是如此.

为什么不Future立即对创作进行调查？

有关最权威的答案,请在RFC pull请求中查看来自无船的评论:

Rust的期货与其他语言的期货之间的根本区别在于,除非进行调查,否则Rust的期货不会做任何事情.整个系统是围绕这个建立的:例如,取消正在降低未来正是出于这个原因.相比之下,在其他语言中,调用异步fn会旋转一个立即开始执行的未来.

关于这一点的一点是,Rust中的async和await不是固有的并发构造.如果您的程序只使用async&await且没有并发原语,程序中的代码将以定义的,静态已知的线性顺序执行.显然,大多数程序将使用某种并发方式在事件循环上调度多个并发任务,但它们不必这样做.这意味着你可以 - 平凡地 - 在本地保证某些事件的排序,即使在它们之间执行了非阻塞IO,你希望与一些更大的非本地事件异步(例如,你可以严格控制事件的顺序)在请求处理程序内部,同时与许多其他请求处理程序并发,甚至在等待点的两侧).

这个属性为Rust的async/await语法提供了一种本地推理和低级控制,使Rust成为现实.运行到第一个等待点本身并不违反 - 你仍然知道代码执行的时间,它只会在两个不同的地方执行,具体取决于它是在await之前还是之后.但是,我认为其他语言立即开始执行的决定很大程度上源于他们的系统,当你调用异步fn时,它会立即同时安排任务(例如,这是我从Dart 2.0文档得到的潜在问题的印象) .

本次讨论涵盖了Dart 2.0的一些背景知识:

嗨,我是Dart团队的成员.Dart的async/await主要是由Erik Meijer设计的,他也在为异步/等待C#工作.在C#中,async/await与第一个await同步.对于Dart,Erik和其他人认为C#的模型太混乱,而是指定异步函数在执行任何代码之前总是产生一次.

当时,我和我的团队中的另一个人负责成为试验品,在我们的包管理器中尝试新的正在进行的语法和语义.根据这一经验,我们认为异步函数应该与第一个等待同步运行.我们的论点主要是:

在没有充分理由的情况下,总是屈服于性能损失.在大多数情况下,这并不重要,但有些确实如此.即使在你可以忍受它的情况下,在任何地方流血也是一种拖累.

总是屈服意味着使用async/await无法实现某些模式.特别是,像(伪代码)这样​​的代码是很常见的:

getThingFromNetwork():
  if (downloadAlreadyInProgress):
    return cachedFuture

  cachedFuture = startDownload()
  return cachedFuture

换句话说,您有一个异步操作,可以在完成之前多次调用.以后的呼叫使用相同的先前创建的待定未来.您希望确保不要多次启动操作.这意味着您需要在开始操作之前同步检查缓存.

如果异步函数从一开始就是异步,则上述函数不能使用async/await.

我们恳求我们的案例,但最终语言设计师坚持使用async-from-the-top.这是几年前的事了.

结果证明是错误的电话.性能成本是足够的,许多用户开发了"异步功能很慢"的思维模式,即使在性价比很高的情况下也开始避免使用它.更糟糕的是,我们看到令人讨厌的并发错误,人们认为他们可以在一个函数的顶部做一些同步工作,并且发现他们已经创造了竞争条件而感到沮丧.总的来说,似乎用户在执行任何代码之前不会自然地假设异步函数产生.

因此,对于Dart 2,我们现在正在进行非常痛苦的重大改变,将异步函数更改为与第一个同步,并通过该转换迁移所有现有代码.我很高兴我们正在做出改变,但我真的希望我们在第一天做正确的事情.

我不知道Rust的所有权和性能模型是否会对你提出不同的限制,从顶部开始异步更好,但从我们的经验来看,同步到第一等待显然是Dart的更好的权衡.

cramert回复(请注意,此语法中的一些现已过时):

如果您需要在调用函数时立即执行代码而不是稍后在轮询未来时执行代码,您可以编写如下函数:

fn foo() -> impl Future {
    println!("prints immediately");
    async_block! {
        println!("prints when the future is first polled");
        await!(bar());
        await!(baz())
    }
}

代码示例

这些示例使用1.31.0-nightly(2018-10-15)中的异步支持和期货预览包(0.3.0-alpha.7).

C#代码的文字转录

use futures; // 0.3.1

async fn long_running_operation(a: u8, b: u8) -> u8 {
    println!("long_running_operation");

    a + b
}

fn another_operation(c: u8, d: u8) -> u8 {
    println!("another_operation");

    c * d
}

async fn foo() -> u8 {
    println!("foo");

    let sum = long_running_operation(1, 2);

    another_operation(3, 4);

    sum.await
}

fn main() {
    let task = foo();

    futures::executor::block_on(async {
        let v = task.await;
        println!("Result: {}", v);
    });
}

如果你打电话foo,Rust中的事件序列将是:

Future

返回实现的东西.

而已.尚未完成"实际"工作.如果您获取结果foo并将其推向完成(通过轮询,在这种情况下通过futures::executor::block_on),则接下来的步骤是:

Future

从调用返回实现的东西long_running_operation(它还没有开始工作).

another_operation 确实有效,因为它是同步的.

在.await宏导致的代码long_running_operation开始.在foo未来将继续返回"没有准备好",直到计算完成.

输出将是:

foo
another_operation
long_running_operation
Result: 3

use futures::{future, FutureExt}; // 0.3.1

fn long_running_operation(a: u8, b: u8) -> u8 {
    println!("long_running_operation");

    a + b
}

fn another_operation(c: u8, d: u8) -> u8 {
    println!("another_operation");

    c * d
}

async fn foo() -> u8 {
    println!("foo");

    let sum = async { long_running_operation(1, 2) };
    let oth = async { another_operation(3, 4) };

    let both = future::join(sum, oth).map(|(sum, _)| sum);

    both.await
}

// Requires the `thread-pool` feature to be enabled 
use futures::{executor::ThreadPool, future, task::SpawnExt, FutureExt};

async fn foo(pool: &mut ThreadPool) -> u8 {
    println!("foo");

    let sum = pool
        .spawn_with_handle(async { long_running_operation(1, 2) })
        .unwrap();
    let oth = pool
        .spawn_with_handle(async { another_operation(3, 4) })
        .unwrap();

    let both = future::join(sum, oth).map(|(sum, _)| sum);

    both.await
}

getData(url)
   .then(response -> parseObjects(response.data))
   .then(data -> findAll(data, 'foo'))
   .then(foos -> getWikipediaPagesFor(foos))
   .then(sumPages)
   .then(sum -> console.log("sum is: ", sum));

async {
    let respOnse= await getData(url);
    let objects = parseObjects(response.data);
    let foos = findAll(objects, 'foo');
    let pages = await getWikipediaPagesFor(foos);
    let sum = sumPages(pages);
    console.log("sum is: ", sum);
}

async {
    let respOnse= await getData(url);
    let objects = parseObjects(response.data);
    let foos = findAll(objects, 'foo');
    let pages = await getWikipediaPagesFor(foos);
    let sum = sumPages(pages, objects.length);
    console.log("sum is: ", sum, " and status was: ", response.status);
}

getData(url)
   .then(response -> Promise.resolve(parseObjects(response.data))
       .then(objects -> Promise.resolve(findAll(objects, 'foo'))
           .then(foos -> getWikipediaPagesFor(foos))
           .then(pages -> sumPages(pages, objects.length)))
       .then(sum -> console.log("sum is: ", sum, " and status was: ", response.status)));