我如何在不等待的情况下经营未来？ （生锈）

Question

我有一些异步功能

async fn get_player(name: String, i: Instant) -> Option<Player> {
// some code here that returns a player structs
}

在我的主函数中，我想在一个循环中同时运行上述函数，这个函数大约需要 1 秒才能完成，我需要运行它至少 50 次，因此我想让它同时运行这个函数 50 次.在我的主函数中，我有一个lazy_static 自定义Client 结构，不应多次创建。

主要功能

#[tokio::main]
async fn main() {
    client.init().await;

    println!("start");
    for i in 0..10 {
        println!("{}", i);
        let now = Instant::now();

        tokio::spawn(async move  {
            client.get_player("jay".to_string(), now).await;
        });
    }
    loop {}
}

我传递即时的原因是因为在我的 get_player 函数中我有一个 println!() 只打印执行时间。

上面的main方法每个函数调用大约需要500ms，而下面的代码只需要100ms。

#[tokio::main]
async fn maain(){
    client.init().await;

    for i in 0..10 {
        let now = Instant::now();
        client.get_player("jay".to_string(), now).await.expect("panic");
    }
}

但是这个函数仍然是同步代码，我如何真正并发运行异步函数而不需要时间成本？

• 为了更好地理解 am after 是一个与此类似的实现（它在 java 中顺便说一句），

     CompleteableFuture.thenAccept(x -> x.SayHello(););

或者在 Js 中它类似于 .then 在异步函数之后。

rust 中有没有类似的实现？

Answer 1

我假设您的 get_player 函数需要一秒钟，因为它等待网络交互，而不是因为某些计算需要那么长时间。如果它是计算密集型的，那么异步是错误的方法，你想改用并行。

此外，我假设get_player 的函数签名实际上是async fn get_player(&self, name: String, i: Instant) -> Option<Player>，否则您的main 代码示例将没有任何意义。虽然我很困惑为什么会是 &self 而不是 &mut self。

基于这些假设，我试图重现您的最小可重现示例：

use std::time::{Duration, Instant};

#[derive(Debug)]
struct Player {
    name: String,
}

struct Client {}

impl Client {
    async fn init(&self) {}

    async fn get_player(&self, name: String, _now: Instant) -> Option<Player> {
        // Dummy code that simulates a delay of 1 second
        tokio::time::sleep(Duration::from_millis(1000)).await;
        Some(Player { name })
    }
}

static client: Client = Client {};

#[tokio::main]
async fn main() {
    let begin = Instant::now();
    client.init().await;

    for i in 0..10 {
        let now = Instant::now();
        let player = client
            .get_player(format!("Player #{}", i), now)
            .await
            .expect("panic");
        println!(
            "[{} ms] Retreived player: {:?}",
            begin.elapsed().as_millis(),
            player.name
        );
    }
}

[1002 ms] Retreived player: "Player #0"
[2004 ms] Retreived player: "Player #1"
[3005 ms] Retreived player: "Player #2"
[4008 ms] Retreived player: "Player #3"
[5010 ms] Retreived player: "Player #4"
[6011 ms] Retreived player: "Player #5"
[7013 ms] Retreived player: "Player #6"
[8014 ms] Retreived player: "Player #7"
[9016 ms] Retreived player: "Player #8"
[10018 ms] Retreived player: "Player #9"

这是基于您上一个 main 示例。如您所见，检索所有玩家需要 10 秒，因为它们都是按顺序运行的。

现在让我们异步运行它们。这里的问题是同时加入它们。遗憾的是，Tokio 并没有为此提供简单的方法。你可以tokio::spawn所有人，收集JoinHandles，然后一一加入。但是，板条箱 futures 提供的正是您想要的：

use std::time::{Duration, Instant};

#[derive(Debug)]
struct Player {
    name: String,
}

struct Client {}

impl Client {
    async fn init(&self) {}

    async fn get_player(&self, name: String, _now: Instant) -> Option<Player> {
        // Dummy code her that simulates a delay of 1 second
        tokio::time::sleep(Duration::from_millis(1000)).await;
        Some(Player { name })
    }
}

static client: Client = Client {};

#[tokio::main]
async fn main() {
    let begin = Instant::now();
    client.init().await;

    let get_player_futures = (0..10).into_iter().map(|i| async move {
        let now = Instant::now();
        let player = client
            .get_player(format!("Player #{}", i), now)
            .await
            .expect("panic");
        println!(
            "[{} ms] Retreived player: {:?}",
            begin.elapsed().as_millis(),
            player.name
        );
    });

    futures::future::join_all(get_player_futures).await;
}

[1002 ms] Retreived player: "Player #0"
[1002 ms] Retreived player: "Player #1"
[1002 ms] Retreived player: "Player #2"
[1002 ms] Retreived player: "Player #3"
[1002 ms] Retreived player: "Player #4"
[1002 ms] Retreived player: "Player #5"
[1002 ms] Retreived player: "Player #6"
[1002 ms] Retreived player: "Player #7"
[1003 ms] Retreived player: "Player #8"
[1003 ms] Retreived player: "Player #9"

如您所见，整个程序只用了一秒钟，全部同时被检索出来。

get_player_futures 这里是一个迭代器，遍历所有需要等待以检索玩家的期货。 futures::future::join_all 然后同时等待所有这些。您甚至可以使用join_all 的返回值来检索期货的值，但我们在这里不使用它。

我希望这能有所帮助；由于您的部分问题不连贯，因此很难找到答案。