Rust / 系统课时

处理异步超时

处理异步超时

异步任务一旦等待外部 I/O、锁或队列,就可能长期不返回。本节用 Tokio 把三类保护放在一起:用超时限制单次等待,用取消终止不再需要的任务,再用信号量限制同时执行的任务数量。

学习目标

  • 使用 tokio::time::timeout 为异步操作设置明确的等待上限。
  • 使用 JoinHandle::abort 取消已启动任务,并识别取消结果。
  • 使用 Semaphore 限制并发数量,避免下游资源被瞬时任务压满。

用三个边界保护异步任务

超时、取消和并发限制解决的是不同问题。超时回答“最多等多久”,取消回答“结果已经没用了怎么办”,并发限制回答“最多允许多少个任务同时占用资源”。实际服务通常需要三者同时存在,而不是互相替代。

异步超时、取消和并发限制的协作关系

timeout 会等待内部 Future,超过期限就返回错误;abort 针对已由 Tokio 调度的任务;Semaphore 则把“可进入执行区”的许可数量固定下来。把并发闸门放在昂贵操作之前,可以避免连接池、API 配额或文件句柄同时被大量占用。

可运行示例

先准备依赖:

toml
[package]
name = "async-guard"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["macros", "rt-multi-thread", "time", "sync"] }

生效行为:Tokio 会提供异步运行时、计时器、任务调度和信号量。可用 cargo check --quiet 验证依赖与源码能够通过编译;命令成功时不会产生终端输出。

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

rust
use std::{
    sync::{
        atomic::{AtomicUsize, Ordering},
        Arc,
    },
    time::Duration,
};
use tokio::{
    sync::Semaphore,
    task::JoinHandle,
    time::{sleep, timeout},
};

async fn slow_operation() -> &'static str {
    sleep(Duration::from_millis(500)).await;
    "done"
}

#[tokio::main]
async fn main() {
    match timeout(Duration::from_millis(100), slow_operation()).await {
        Ok(value) => println!("timeout_result={value}"),
        Err(_) => println!("timeout_result=timed_out"),
    }

    let handle: JoinHandle<()> = tokio::spawn(async {
        loop {
            sleep(Duration::from_secs(1)).await;
        }
    });

    sleep(Duration::from_millis(50)).await;
    handle.abort();
    match handle.await {
        Err(err) if err.is_cancelled() => println!("cancel_result=cancelled"),
        other => println!("cancel_result={other:?}"),
    }

    let semaphore = Arc::new(Semaphore::new(2));
    let in_flight = Arc::new(AtomicUsize::new(0));
    let max_seen = Arc::new(AtomicUsize::new(0));
    let mut workers = Vec::new();

    for _ in 0..4 {
        let semaphore = Arc::clone(&semaphore);
        let in_flight = Arc::clone(&in_flight);
        let max_seen = Arc::clone(&max_seen);

        workers.push(tokio::spawn(async move {
            // 没拿到 permit 的任务会等待,不会进入受保护的执行区。
            let _permit = semaphore
                .acquire_owned()
                .await
                .expect("semaphore closed");

            let current = in_flight.fetch_add(1, Ordering::SeqCst) + 1;
            max_seen.fetch_max(current, Ordering::SeqCst);

            sleep(Duration::from_millis(50)).await;
            in_flight.fetch_sub(1, Ordering::SeqCst);
        }));
    }

    for worker in workers {
        worker.await.expect("worker panicked");
    }

    println!("max_in_flight={}", max_seen.load(Ordering::SeqCst));
}

预期结果:源码能够编译,并分别触发一次超时、一次任务取消,同时把工作区的最大并发限制为 2。

运行:

bash
cargo run --quiet

预期输出:

text
timeout_result=timed_out
cancel_result=cancelled
max_in_flight=2

关键边界与选型

timeout 超时后会停止继续轮询被包裹的 Future,但已经提交给外部系统的请求、已经 spawn 出去的子任务或其他独立副作用,不一定会自动撤销。因此有写操作时,需要额外设计幂等、补偿或可传播的取消信号。

JoinHandle::abort 适合取消普通 Tokio 异步任务,但取消发生在任务再次让出执行权时;长时间不 .await 的同步计算不会及时响应。对于 spawn_blocking 中已经开始执行的阻塞任务,也不能依赖 abort 立即停止底层工作。

当任务必须在固定时间内完成、结果可能变得无意义,且下游有明确容量上限时,可以把“超时 + 取消 + 并发闸门”视为一组完整的异步防护边界。

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

目录与阅读设置

阅读设置

17

记录一个想法

处理异步超时

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

登录哪都通