生锈：异步不同意

Question

这是Rust Book中的示例。

async fn learn_and_sing() {
    // Wait until the song has been learned before singing it.
    // We use `.await` here rather than `block_on` to prevent blocking the
    // thread, which makes it possible to `dance` at the same time.
    let song = learn_song().await;
    sing_song(song).await;
}

async fn async_main() {
    let f1 = learn_and_sing();
    let f2 = dance();

    // `join!` is like `.await` but can wait for multiple futures concurrently.
    // If we're temporarily blocked in the `learn_and_sing` future, the `dance`
    // future will take over the current thread. If `dance` becomes blocked,
    // `learn_and_sing` can take back over. If both futures are blocked, then
    // `async_main` is blocked and will yield to the executor.
    futures::join!(f1, f2);
}

fn main() {
    block_on(async_main());
}

它说

在此示例中，学习歌曲必须在唱歌之前发生，但是学习和唱歌都可以在跳舞的同时发生。

但是我不能明白这一点。我在Rust中写了一个简短的代码

async fn learn_song() -> &'static str {
    println!("learn_song");
    "some song"
}

#[allow(unused_variables)]
async fn sing_song(song: &str) {
    println!("sing_song");
}

async fn dance() {
    println!("dance");
}

async fn learn_and_sing() {
    let song = learn_song().await;
    std::thread::sleep(std::time::Duration::from_secs(1));
    sing_song(song).await;
}

async fn async_main() {
    let f1 = learn_and_sing();
    let f2 = dance();
    let f3 = learn_and_sing();

    futures::join!(f1, f2, f3);
}

fn main() {
    futures::executor::block_on(async_main());
}

，似乎所有异步在async_main同步执行中的功能。

输出是

learn_song
sing_song
dance
learn_song
sing_song

，如果它们异步运行，我希望如果我添加了Learn_and_sing的额外调用，我希望在输出中得到类似的东西

learn_song
dance
learn_song
sing_song
sing_song

，它会像同步函数中一样打印钢。

问题为什么？是否可以仅使用async/.await和无线程制作真实的异步？

Answer 1

就像Tkausl的评论所述，STD :: Thread :: Sleep select sheep sheck the the the the Thread Sleep，可以防止线程上的任何代码在睡眠期间执行。您可以使用 async_std ::在这种情况下，因为它是睡眠功能的异步版本。

async fn learn_song() -> &'static str {
    println!("learn_song");
    "some song"
}

#[allow(unused_variables)]
async fn sing_song(song: &str) {
    println!("sing_song");
}

async fn dance() {
    println!("dance");
}

async fn learn_and_sing() {
    let song = learn_song().await;
    async_std::task::sleep(std::time::Duration::from_secs(1)).await;
    sing_song(song).await;
}

#[async_std::main] 
async fn main() {
    let f1 = learn_and_sing();
    let f2 = dance();
    let f3 = learn_and_sing();

    futures::join!(f1, f2, f3);
}