在Rust中如何阻塞线程直到多个通道中的任意一个变为可读？

轮询try_recv的写法确实会造成CPU空转浪费，Rust生态有成熟的阻塞等待多通道消息的方案，语义和你提到的Ada select语句完全等价，不会产生额外CPU消耗：

同步阻塞场景 #

推荐方案：使用crossbeam-channel的select!宏 #

这是生产环境最常用的方案，crossbeam-channel的API和标准库mpsc兼容，支持任意数量通道的监听，线程会完全阻塞直到任意通道有消息到达：

use crossbeam_channel::{select, unbounded};

// 示例对应你给出的Ada代码逻辑
fn main() {
    let (tx1, rx1) = unbounded();
    let (tx2, rx2) = unbounded();
    let (tx3, rx3) = unbounded();

    // 其他线程调用发送逻辑等价于Ada中的远程调用触发accept
    std::thread::spawn(move || tx1.send(()).unwrap());
    std::thread::spawn(move || tx2.send(()).unwrap());
    std::thread::spawn(move || tx3.send("参数值".to_string()).unwrap());

    loop {
        select! {
            // 对应accept Task1
            recv(rx1) -> _ => {
                // 处理Task1逻辑
                println!("执行Task1");
            }
            // 对应accept Task2
            recv(rx2) -> _ => {
                // 处理Task2逻辑
                println!("执行Task2");
            }
            // 对应带参数的accept Task3
            recv(rx3) -> param => {
                let param = param.unwrap();
                // 处理Task3逻辑，使用传入参数
                println!("执行Task3，传入参数：{}", param);
            }
        }
    }
}

无第三方依赖方案：标准库std::sync::mpsc::select! #

如果你不想引入外部依赖，标准库也提供了select宏，仅限制最多监听16个通道，用法和crossbeam的select基本一致。

异步运行时场景 #

如果你在Tokio等异步runtime下开发，不需要阻塞操作系统线程，可使用Tokio提供的select!宏实现异步等待多通道消息，语义和同步场景一致：

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (tx1, mut rx1) = mpsc::unbounded_channel();
    let (tx2, mut rx2) = mpsc::unbounded_channel();

    tokio::spawn(async move { tx1.send(()).unwrap() });
    tokio::spawn(async move { tx2.send("参数".to_string()).unwrap() });

    loop {
        tokio::select! {
            Some(_) = rx1.recv() => {
                println!("执行Task1");
            }
            Some(param) = rx2.recv() => {
                println!("执行Task2，参数：{}", param);
            }
        }
    }
}

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