Rust中如何在每个线程结束后执行主线程任务且不阻塞？

问题根源 #

你原来的代码中，join()会阻塞当前线程直到对应子线程完成，循环遍历handles时必须按顺序等待每个子线程结束，才能继续下一个，最终要等所有线程都完成后，主线程才能执行后续逻辑，这就是导致阻塞到所有任务结束的原因。

标准库方案：消息传递（无额外依赖） #

利用std::sync::mpsc通道，让子线程完成后将结果发送给主线程，主线程实时接收并处理，无需等待所有任务结束。

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    // 创建多生产者单消费者通道
    let (sender, receiver) = mpsc::channel();

    // 启动5个不同耗时的任务线程
    let handles: Vec<_> = (0..5).map(|task_id| {
        let sender_clone = sender.clone();
        thread::spawn(move || {
            // 模拟任务耗时：偶数ID任务耗时3秒，奇数ID耗时1秒
            let sleep_duration = if task_id % 2 == 0 {
                Duration::from_secs(3)
            } else {
                Duration::from_secs(1)
            };
            thread::sleep(sleep_duration);
            
            // 任务完成后发送结果到通道
            let result = format!("任务{}执行完毕", task_id);
            sender_clone.send(result).unwrap();
        })
    }).collect();

    // 主线程循环接收结果，哪个任务先完成就先处理
    for _ in 0..handles.len() {
        let finished_task = receiver.recv().unwrap();
        println!("主线程处理：{}", finished_task);
    }

    // 可选：等待所有线程彻底退出，确保资源释放
    for handle in handles {
        handle.join().unwrap();
    }
}

说明 #

• 每个子线程持有通道的发送端克隆，任务完成后立即发送结果
• 主线程通过recv()阻塞等待下一个结果，收到后立即处理，完全符合“任务完成即处理”的需求
• 无需额外依赖，仅用标准库即可实现

异步方案：Tokio JoinSet（适合复杂并发场景） #

如果你的项目本身使用异步编程，推荐用Tokio的JoinSet，它可以更灵活地跟踪多个异步任务，逐个处理完成的结果：

use tokio::{task, time};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let mut join_set = task::JoinSet::new();

    // 启动5个异步任务
    for task_id in 0..5 {
        join_set.spawn(async move {
            let sleep_duration = if task_id % 2 == 0 {
                Duration::from_secs(3)
            } else {
                Duration::from_secs(1)
            };
            time::sleep(sleep_duration).await;
            
            format!("任务{}执行完毕", task_id)
        });
    }

    // 逐个处理完成的任务结果
    while let Some(task_result) = join_set.join_next().await {
        let finished_task = task_result.unwrap();
        println!("主线程处理：{}", finished_task);
    }
}

说明 #

• join_next().await会异步等待下一个完成的任务，不会阻塞主线程的其他异步操作
• 适合需要同时处理多个异步事件的复杂场景，代码更简洁
• 需要在Cargo.toml中添加Tokio依赖：

  [dependencies]
  tokio = { version = "1.0", features = ["full"] }
  

总结 #

• 标准库通道方案：轻量、无依赖，适合简单的多线程场景
• Tokio异步方案：灵活、高效，适合复杂的异步并发场景

内容的提问来源于stack exchange，提问作者Rtxx