并发异步/等待与睡眠

Question

我想知道这个关于期货的老问题的答案是否仍然适用于更新的语言结构async/await。似乎是这样，因为下面的代码打印：

hello 
good bye 
hello

虽然指南说

futures::join 宏可以等待多个不同的 future 完成，同时执行它们。

显然，对于许多其他异步系统（例如， node.js）而言，这是对预期行为的转移sleep。

有什么根本原因吗？

hello 
good bye 
hello

添加：实际线程预期的行为 (I)

fn main() {

    let fut1 = do_async( move || {
        println!( "hello" );
        thread::sleep( Duration::from_millis( 3000 ) );
        println!( "good bye" );
    });

    let fut2 = do_async( move || {
        println!( "hello" );
    });

    fut1();
    fut2();

}

use std::time::Duration;
use std::thread;

async fn sayHiOne() {
    println!( " hello " );
    thread::sleep( Duration::from_millis( 3000 ) );
    println!( " good bye " );
} // ()

async fn sayHiTwo() {
    println!( " hello " );
} // ()

async fn mainAsync() {

    let fut1 = sayHiOne();

    let fut2 = sayHiTwo();

    futures::join!( fut1, fut2 );
} // ()

fn main() {
    block_on( mainAsync() );
} // ()

Answer 1

由于标准/原始版本thread::sleep是阻塞的，因此异步库正在提供async_std::task::sleep( ... )睡眠的非阻塞版本。.await它与（无括号）一起使用：

task::sleep::( Duration::from_millis( 1 ) ).await;

这与不稳定sleep版本具有相同的效果：yield_now，因为它

将当前正在执行的 future 移动到执行队列的后面，为其他 future 的执行腾出空间。这在未来运行 CPU 密集型操作后特别有用。

所以我想，每当任务计划执行长时间工作时，预期用途是在未来之间“友好地”共享线程的使用。