动态调用带有变量 arguments 的随机 function

Question

我有一个带有变量 arguments 的函数列表，我想在运行时随机选择其中一个，并在循环中调用它。 我希望提高我的解决方案的性能。

我有一个 function，它根据一些随机性计算 arguments，然后（应该）返回一个 function 指针，然后我可以调用它。

pub async fn choose_random_endpoint(
    &self,
    rng: ThreadRng,
    endpoint_type: EndpointType,
) -> impl Future<Output = Result<std::string::String, MyError>> {
    match endpoint_type {
        EndpointType::Type1 => {
            let endpoint_arguments = self.choose_endpoint_arguments(rng);
            let endpoint = endpoint1(&self.arg1, &self.arg2, &endpoint_arguments.arg3);
            endpoint
        }
        EndpointType::Type2 => {
            let endpoint_arguments = self.choose_endpoint_arguments(rng);
            let endpoint = endpoint2(
                &self.arg1,
                &self.arg2,
                &endpoint_arguments.arg3,
                rng.clone(),
            );
            endpoint
        }
        EndpointType::Type3 => {
            let endpoint_arguments = self.choose_endpoint_arguments(rng);
            let endpoint = endpoint3(
                &self.arg1,
                &self.arg2,
                &endpoint_arguments.arg3,
                rng.clone(),
            );
            endpoint
        }
    }
}

我得到的错误是

expected opaque type `impl Future<Output = Result<std::string::String, MyError>>` (opaque type at <src/calls/type1.rs:14:6>)
   found opaque type `impl Future<Output = Result<std::string::String, MyError>>` (opaque type at <src/type2.rs:19:6>)

. 编译器建议我await端点，这解决了问题，但这是否有性能开销？

外部 function：

假设有一个循环调用这个 function：

pub async fn make_call(arg1: &str, arg2: &str) -> Result<String> {
    let mut rng = rand::thread_rng();
    let random_endpoint_type = choose_random_endpoint_type(&mut rng);
    let random_endpoint = choose_random_endpoint(&rng, random_endpoint_type);
    // call the endpoint
    Ok(response)
}

现在，我想每 X 秒调用一次make_call ，但我不希望我的主线程在端点调用期间阻塞，因为它们很昂贵。 我想解决这个问题的正确方法是每 X 秒间隔生成一个新线程，调用make_call ？

此外，在性能方面：在 rng 上拥有如此多的克隆似乎相当昂贵。 有没有更好的方法来做到这一点？

Answer 1

您得到的错误与异步无关。 这与您尝试从 function 返回两个不同的迭代器时得到的相同。 您编写的 function 甚至不需要异步。 我打算在不需要时从中删除async ，但是如果您需要async （例如实现async-trait ），那么您可以将其添加回来，它可能会以相同的方式工作。

我已将您的代码缩减为一个具有相同问题的更简单示例 ( playground )：

async fn a() -> &'static str {
    "a"
}

async fn b() -> &'static str {
    "b"
}

fn a_or_b() -> impl Future<Output = &'static str> {
    if rand::random() {
        a()
    } else {
        b()
    }
}

你想写什么

当你想返回一个特征，但在编译时不知道实现该特征的具体类型时，你可以返回一个特征 object。Futures 需要被Unpin才能等待，所以这使用了一个固定框（ playground ）。

fn a_or_b() -> Pin<Box<dyn Future<Output = &'static str>>> {
    if rand::random() {
        Box::pin(a())
    } else {
        Box::pin(b())
    }
}

您可能需要类型类似于Pin<Box<dyn Future<Output = &'static str> + Send + Sync + 'static>> ，具体取决于上下文。

你应该写什么

我认为您执行上述操作的唯一原因是，如果您想使用某种异步 rng 生成未来，然后执行其他操作，然后运行生成的未来。 否则就没有必要嵌套期货； 当你打电话给他们（ 游乐场）时，只需等待内心的未来。

async fn a_or_b() -> &'static str {
    if rand::random() {
        a().await
    } else {
        b().await
    }
}

这在概念上等同于Pin<Box>方法，只是无需分配Box 。 相反，您有一个实现Future本身的不透明类型。

阻塞

它们的阻塞行为只是略有不同。 当你调用Pin<Box>时，它会阻塞非异步的东西，而async的会阻塞你等待它的非异步的东西。 这可能主要是随机生成。

端点的阻塞行为是相同的，取决于那里发生的事情。 无论您在哪里等待，它都会阻止或不阻止。

如果您想同时进行多个make_call调用，则无论如何都需要在 function 之外进行。 使用 tokio 运行时，它看起来像这样：

use tokio::task;
use futures::future::join_all;
let tasks: Vec<_> = (0..100).map(|_| task::spawn(make_call())).collect();
let results = join_all(tasks).await;

这也让你在 futures 运行时做其他事情，在collect();之间。 并let results 。

如果您的 function 块中有某些东西，您希望使用task::spawn_blocking生成它（然后等待该句柄），这样make_call中的 await 调用就不会被阻塞。

随机数生成器

如果您的运行时是多线程的， ThreadRng将是一个问题。 您可以创建一个使用from_entropy实现Rng + Send的类型，并将其传递到您的函数中。 或者您可以在需要的地方调用thread_rng或什至只是调用rand::random 。 这会为每个线程创建一个新的 rng，但会在以后的调用中重用它们，因为它是线程本地的 static。另一方面，如果您不需要那么多的随机性，您可以从一开始就使用Rng + Send类型的 go .

如果你的运行时不是多线程的，你应该能够一直传递&mut ThreadRng ，假设借用检查器足够聪明。 但是，您将无法将其传递到异步 function 中然后spawn它，因此您必须在该 function 中创建一个新的。