使用 `futures` crate。
我有一个返回布尔值的 futures 向量，我想专门等待返回 true 的 future。
考虑以下一组 futures。
```rust
async fn async_function(guess: u8) -> bool {
    let random_wait = rand::thread_rng().gen_range(0..2);
    std::thread::sleep(std::time::Duration::from_secs(random_wait));
    println!("Running guess {guess}");
    guess == 231
}
fn main() {
    let mut pool: Vec<impl Future<Output = bool>> = vec![];
    for guess in 0..=255 {
        pool.push(async_function(guess));
    }
}

<details>
<summary>英文:</summary>
Using the `futures` crate.
I have a vec of futures which return a bool and I want to wait specifically for the future that returns true.
consider the following pool of futures.

- How do I wait for the futures in the vec?
- Is it possible to wait until only one future returns true?
- Can I identify the value of guess for the future that returns true?
I'm new to async rust, so I've been looking at the async-book.
From there, these are the options I've considered:
- `join!` waits until all threads are done, so that doesn't work for me since I want to drop the remaining futures.
- `select!` doesn't seem to be an option, because I need to specify the specific future in the select block and I'm not about to make 255 line select.
- `try_join!` is tempting me to break semantics and have my async_function return `Err(guess)`so that it causes the try_join to exit and return the value I want.
- I tried using `async_fn(guess).boxed.into_stream()` and then using `select_all` from `futures::stream` but it doesn't seem to run concurrently. I see my async functions running in order.
</details>
# 答案1
**得分**: 1
以下是翻译好的部分：
"Ok, my thinking of futures was wrong. I knew that they weren't executed immediately, but I wasn't using the executors correctly from the futures crate.
Here's what I've got that seems to work.
let thread_pool = ThreadPool::new().unwrap();
let mut pool = vec![];
for guess in 0..=255 {
    let thread = thread_pool.spawn_with_handle(async_fn(guess)).expect("Failed to spawn thread");
    pool.push(thread.into_stream());
}
let stream = block_on_stream(futures::stream::select_all(pool));
for value in stream {
    println!("Got value {value}");
}
the thread pool executor is what creates the separate threads needed to run. Without this my application was single threaded so no matter what I tried, it would only run functions one at a time, not concurrently.
This way I spawn each request into the thread pool. The thread pool appears to spawn 4 background threads. By pushing them all into a stream, using select_all, and iterating over the stream, my main thread blocks until a new value is available.
There's always 4 workers and the thread pool is scheduling them in the order they were requested like a queue. This is perfect."
<details>
<summary>英文:</summary>
Ok, my thinking of futures was wrong. I knew that they weren&#39;t executed immediately, but I wasn&#39;t using the executors correctly from the futures crate.
Here&#39;s what I&#39;ve got that seems to work.
    let thread_pool = ThreadPool::new().unwrap();
    let mut pool = vec![];
    for guess in 0..=255 {
        let thread = thread_pool.spawn_with_handle(async_fn(guess)).expect(&quot;Failed to spawn thread&quot;);
        pool.push(thread.into_stream());
    }
    let stream = block_on_stream(futures::stream::select_all(pool));
    for value in stream {
        println!(&quot;Got value {value}&quot;);
    }
the thread pool executor is what creates the separate threads needed to run. Without this my application was single threaded so no matter what I tried, it would only run functions one at a time, not concurrently.
This way I spawn each request into the thread pool. The thread pool appears to spawn 4 background threads. By pushing them all into a stream, using select_all, and iterating over the stream, my main thread blocks until a new value is available.
There&#39;s always 4 workers and the thread pool is scheduling them in the order they were requested like a queue. This is perfect.
</details>