Rust：Futures :: future :: join_all...await按顺序运行Futures但需要并行处理

如何解决Rust：Futures :: future :: join_all...await按顺序运行Futures但需要并行处理

我具有以下async函数（实现并不重要）：

async fn long_task(task_number: i32) {
    // do some long work
    println!("Task {} executed",task_number);
}

我想同时运行此函数 n 次，所以我定义了此函数：

async fn execute_long_tasks_async(n: i32) {
    let mut futures = Vec::new();
    for i in 1..=n {
        futures.push(long_task(i));
    }
    futures::future::join_all(futures).await;
}

我正在使用join_all函数等待所有任务执行完毕。然后，在我的main中调用此函数：

fn main() {
    futures::executor::block_on(execute_long_tasks_async(3));
}

我的问题是任务按顺序运行：

Executing task 1
Task 1 executed
Executing task 2
Task 2 executed
Executing task 3
Task 3 executed

但是我希望它可以同时运行，并且我会得到类似的东西：

Executing task 1
Executing task 3
Executing task 2
Task 1 executed
Task 3 executed
Task 2 executed

futures::future::join_all是否可以并行运行所有任务？

我想使用await创建一个简单的示例来演示async和await。

解决方法

import time from buildbot.interfaces import IRenderable from zope.interface import implementer @implementer(IRenderable) class FromDict(object): def __init__(self,key,default = None): self.key = key self.default = default def getRenderingFor(self,props): return props.getPropety('mydictionary',{}).value(key,default) # When used,the renderer must be initialized and # the parameters can be passed to its constructor ShellCommand(command=['echo',FromDict(key='aaa',default='42')]) 同时（而不是并行）运行任务。它的局限性在于，只有在任务屈服时才可以在任务之间切换。此外，如果该任务尚未准备就绪，它将始终喜欢执行第一个任务。

如果您的功能是定义为

join_all

然后，函数中间的async fn long_task(task_number: i32) { println!("Executing Task {}task_number); tokio::time::delay_for(Duration::from_secs(1)).await; println!("Task {} executed",task_number); } /挂起点将为await提供运行其他函数/ join_all的机会-您将观察到预期的输出。

但是如果Future不产生（例如，因为它将被线程阻塞），则此函数将在其他任务开始之前运行完成：

long_task

如果您具有这样的功能，那么它们通常不适合async fn long_task(task_number: i32) { println!("Executing Task {}task_number); std::thread::sleep(Duration::from_secs(1)); println!("Task {} executed",task_number); } 的世界。 async函数的目的不是占用大量CPU资源，也不应该阻塞线程-这样，在同一执行程序上调度的其他函数仍然可以运行。

一种可能会为您提供更多并行性的替代方法是使用多线程异步运行时（例如tokio）和async每个异步函数作为单独的任务。在那种情况下，这些任务可以在单独的CPU内核和线程上运行，而不会互相阻塞太多。然后，您可以在返回的spawn的集合上使用join_all，以等待所有任务完成。