在 Rust 中执行此操作的正确方法是什么？

Question

Suppose a loop on main like this:

use crate::modules::very_ext::{one, two};
use crate::modules::much_wow::logic;

let result;
loop {
  let foo = one.next().await.expect("boom");

  // Do something with foo
  result = logic(foo)
}

This far, great. What happens when the logic inside the loop needs to "react" to multiple external events?

If we do something like this:

use crate::modules::very_ext::{one, two};
use crate::modules::much_wow::logic;

let result;
loop {
  let foo = one.next().await.expect("boom");
  let bar = two.next().await.expect("boom");

  // Do something with foo
  result = logic(foo, bar)
}

then logic will only run after:

• foo resolves first
• then bar eventually resolves as well

(which is not what we want, we need to react whenever a new value for either foo or bar is externally ready to be passed to the main loop).

By reading tokio 's docs, my guess is that this can be solved by using threads and channels. But I'm confused on exactly how. I am thinking it like this:

• Create an mpsc channel.
• Spawn one and two into their own threads.
• Each thread pushes a value on the channel with perhaps some encapsulation that distinguishes it.
• The main loop is the single consumer that "reacts" as the values come in over the mpsc channel.

Am I overthinking this? Is there a simpler way (assume the general problem with multiple producers, not just two)?

Thank you!

Answer 1

You can spawn lightweight tasks out of both futures, which will allow you to await them both without serializing them. It is conceptually similar to the solution you proposed, but doesn't use additional threads (it runs foo and bar on the normal executor threads, interleaving them with other futures as they await), and the channels created are one-shot channels highly optimized for this purpose.

loop {
    // spawn foo and bar to run in the background
    let foo = tokio::spawn(one.next());
    let bar = tokio::spawn(two.next());
    // awaiting foo now also executes bar
    let foo = foo.await.unwrap().expect("boom");
    let bar = bar.await.unwrap().expect("boom");

    result = logic(foo, bar);
}

Answer 2

You can use futures::future::try_select for this if you have exactly two futures to wait on, or futures::future::select_all if you have more than two - they return any remaining unresolved Futures so you can still wait on them in the future if you want.

Note that select_all requires that all futures resolve to the same type, so you may need to introduce a wrapper enum with one variant per type of your futures if they are different. Then you would map each of the Futures you're awaiting into their relevant enum wrapper before calling select_all .