Rust 等待 Tokio 线程完成

Question

我正在尝试创建一个小程序，它会在 MPSC 频道收到消息时启动新线程。 我能够让程序启动线程，但无法弄清楚如何让程序保持打开状态。

这是应用程序：

#[tokio::main]
async fn main() {
    let (sender, mut receiver) = mpsc::channel(100);

    let handles = Arc::new(tokio::sync::Mutex::new(vec![]));
    let handles_clone = handles.clone();
    let consumer_task = tokio::spawn(async move {
        while let Some(item) = receiver.recv().await {
            println!("Consumer received: {}", item);
            let h = tokio::spawn(async move {
                println!("Thread {} working", item);
                sleep(Duration::from_secs(2)).await;
                println!("Thread {} done", item);
            });
            {
                let mut handles = handles_clone.lock().await;
                handles.push(h);
            }
        }
    });

    let producer_task = tokio::spawn(async move {
        for i in 0..5 {
            let _ = sender.send(i).await;
        }
    });

    let mut handles = handles.lock().await;
    handles.push(consumer_task);
    handles.push(producer_task);

    let a = handles.deref();

    join_all(a);

我的想法是我需要在我开始的句柄上加入 join_all，但是我无法弄清楚如何将句柄推到接收器线程内的向量上，然后在程序末尾加入 join_all 以阻止直到那些线程完成了。

我将句柄 vec 包装在 Arc<Mutex<_>> 中，因为我想在接收器线程中引用句柄 vec，但我似乎无法在最后加入 join_all，并收到此错误：

`&tokio::task::JoinHandle<()>` is not a future
the trait `futures::Future` is not implemented for `&tokio::task::JoinHandle<()>`
&tokio::task::JoinHandle<()> must be a future or must implement `IntoFuture` to be awaited
the trait `futures::Future` is implemented for `tokio::task::JoinHandle<T>`
`futures::Future` is implemented for `&mut tokio::task::JoinHandle<()>`, but not for `&tokio::task::JoinHandle<()>`

任何帮助将不胜感激。

Answer 1

您在错误消息中看到&了吗？ 编译器错误是由于您在调用join_all时不拥有JoinHandle的事实（ JoinHandle只能加入一次，因此需要拥有它们才能做到这一点。）您可以通过替换最后两个来修复该错误符合：

join_all(handles.drain(..)).await;

但随后你陷入了僵局：消费者任务将尝试锁定handles_clone ，但它被“主”任务锁定，等待join_all ，永远不会完成。 您可以通过锁定、弹出句柄和一个一个地等待来规避这个问题，但这样做实际上已经实现了一个低效的 (lifo) 通道。 那么实际使用一个频道会更好。

不过，更好的是，通过将handles Vec移到您的消费者任务中并加入那里，让您的生活更轻松。 这使得互斥量变得不必要了。

let (sender, mut receiver) = mpsc::channel(100);

let consumer_task = tokio::spawn(async move {
    let mut handles = vec![];
    while let Some(item) = receiver.recv().await {
        println!("Consumer received: {}", item);
        let h = tokio::spawn(async move {
            println!("Thread {} working", item);
            sleep(Duration::from_secs(2)).await;
            println!("Thread {} done", item);
        });

        handles.push(h);
    }
    join_all(handles).await;
});

let producer_task = tokio::spawn(async move {
    for i in 0..5 {
        let _ = sender.send(i).await;
    }
});

consumer_task.await.unwrap();
producer_task.await.unwrap();