Rust / 系统课时

竞争多个异步分支

竞争多个异步分支

当 Tokio 服务既要等待网络连接,又要接收内部通道消息,还必须及时响应关闭信号时,顺序 await 会让后续事件被阻塞。tokio::select! 能在同一任务中等待多个异步分支,并处理最先就绪的结果。

学习目标

  • 使用 tokio::select! 同时等待网络、通道与关闭信号
  • 理解分支选择、失败匹配与默认公平性
  • 在循环中正确处理通道关闭和服务退出

select! 如何决定下一步

tokio::select! 会在当前任务中轮询多个 Future;某个分支完成且模式匹配后,就执行该分支的处理代码,并结束这一次 select!。它不是为每个分支创建线程,也不会让多个处理器同时执行。

如果同一次轮询中有多个分支已经就绪,默认模式会随机化检查起点,以降低长期偏向某个分支的概率,但这不是严格的调度公平保证。写下 biased; 后会按源码顺序轮询,此时高频、总是就绪的前置分支可能让后面的关闭信号长期得不到机会。

select 分支竞争与循环处理

分支可以带模式,例如 Some(message) = rx.recv()。如果 Future 完成但结果与模式不匹配,该分支会在本次 select! 中被禁用;若所有分支都被禁用且没有 else,宏会 panic。服务循环里通常更稳妥的写法是先接住 recv() 的完整结果,再显式处理 Some 和 None。

组合网络、消息与关闭信号

下面的程序绑定一个本地 TCP 监听器,并分别制造通道消息、连接事件和关闭信号。三个事件由同一个事件循环处理,关闭信号到达后退出循环。

项目需要 Tokio 的完整特性集:

toml
[package]
name = "select-demo"
version = "0.1.0"
edition = "2024"

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

保存以下代码为 src/main.rs:

rust
use tokio::{
    net::{TcpListener, TcpStream},
    sync::{mpsc, oneshot},
    time::{sleep, Duration},
};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:0").await?;
    let addr = listener.local_addr()?;
    println!("listening on 127.0.0.1:<PORT>");

    let (msg_tx, mut msg_rx) = mpsc::channel::<String>(4);
    let producer_tx = msg_tx.clone();
    // 保留一个 Sender,避免演示期间通道提前关闭并让 recv() 立即返回 None。
    let _keep_channel_open = msg_tx;
    let (shutdown_tx, mut shutdown_rx) = oneshot::channel::<()>();

    // 分三个时间点制造不同来源的事件,便于观察同一循环如何选择分支。
    tokio::spawn(async move {
        sleep(Duration::from_millis(30)).await;
        producer_tx.send("refresh".to_string()).await.unwrap();
    });

    tokio::spawn(async move {
        sleep(Duration::from_millis(60)).await;
        TcpStream::connect(addr).await.unwrap();
    });

    tokio::spawn(async move {
        sleep(Duration::from_millis(90)).await;
        let _ = shutdown_tx.send(());
    });

    // 每轮只处理一个就绪事件,然后立即回到下一轮等待。
    loop {
        tokio::select! {
            message = msg_rx.recv() => {
                match message {
                    Some(message) => println!("message: {message}"),
                    None => {
                        println!("message channel closed");
                        break;
                    }
                }
            }
            accepted = listener.accept() => {
                let (_stream, _peer) = accepted?;
                println!("accepted one connection");
            }
            // 借用同一个 oneshot Receiver,使它在前几轮落选后仍能继续等待。
            shutdown = &mut shutdown_rx => {
                match shutdown {
                    Ok(()) => println!("shutdown requested"),
                    Err(_) => println!("shutdown sender dropped"),
                }
                break;
            }
        }
    }

    println!("event loop stopped");
    Ok(())
}

运行 cargo run。端口由操作系统动态分配,因此实际值会替换 <PORT>。

预期输出:

text
listening on 127.0.0.1:<PORT>
message: refresh
accepted one connection
shutdown requested
event loop stopped

循环写法的关键边界

select! 每执行一次只选中一个分支,所以长期运行的服务通常把它放在 loop 中。分支处理代码应尽量短;如果收到一个连接后直接在分支里长时间处理该连接,事件循环同样会暂停,其他消息与关闭信号无法及时响应。常见做法是把独立连接交给 tokio::spawn,让事件循环尽快回到下一轮等待。

还要注意,未胜出的分支 Future 会在这次 select! 返回时被丢弃。TcpListener::accept、mpsc::Receiver::recv 这类操作适合放进循环竞争,但并不是所有异步操作都能安全地被反复取消和重建。只要某个分支会在完成前修改外部资源或把进度保存在 Future 内部,就必须进一步检查它的取消安全性。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

竞争多个异步分支

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通