如何从异步环境中取消同步的stdin().read_line()调用？

问题原因 #

你的代码中，spawn_blocking启动的线程阻塞在std::io::stdin().read_line系统调用时，调用abort()无法立即中断任务。这是因为：

• Tokio的abort()仅能标记异步任务为取消状态，无法强制终止处于内核态阻塞的线程（比如等待用户输入的read_line）。
• 线程只有回到用户态后，才会检查取消标记并退出，所以必须等read_line完成（用户输入）后任务才会结束。

解决方案 #

方案1：使用Tokio异步标准输入（推荐，跨平台） #

Tokio提供了异步的标准输入处理API，异步操作天然支持取消，无需阻塞线程。

use tokio::io::{AsyncBufReadExt, BufReader};
use tokio::time::{sleep, Duration};
use anyhow::Result;

#[tokio::test]
async fn test() -> Result<()> {
    // 创建异步stdin读取器
    let stdin = tokio::io::stdin();
    let mut reader = BufReader::new(stdin).lines();

    // 启动异步读取任务
    let input_task = tokio::spawn(async move {
        match reader.next_line().await {
            Ok(Some(line)) => Ok(line),
            Ok(None) => Err(anyhow::anyhow!("标准输入已关闭")),
            Err(e) => Err(e.into()),
        }
    });

    // 模拟延迟后取消任务
    sleep(Duration::from_secs(1)).await;
    input_task.abort();
    let res = input_task.await;

    println!("结果: {:#?}", res);
    Ok(())
}

方案2：用管道中断阻塞读取（兼容同步代码） #

如果必须使用同步的read_line，可以通过管道结合select系统调用，主动触发任务退出：

Unix平台示例（依赖nix crate）：

use anyhow::Result;
use nix::unistd::{pipe, read, write};
use std::io::{self, Read};
use std::os::unix::io::AsRawFd;
use tokio::task::spawn_blocking;
use tokio::time::{sleep, Duration};

#[tokio::test]
async fn test() -> Result<()> {
    // 创建管道，用于触发取消信号
    let (read_fd, write_fd) = pipe()?;
    let stdin_fd = io::stdin().as_raw_fd();

    let input_handle = spawn_blocking(move || {
        let mut fds = [stdin_fd, read_fd];
        // 同时监听stdin和管道读端
        match nix::sys::select::select(None, Some(&mut fds), None, None, None) {
            Ok(_) => {
                if fds.contains(&stdin_fd) {
                    // 处理用户输入
                    let mut user_input = String::new();
                    io::stdin().read_line(&mut user_input)?;
                    Ok(user_input)
                } else {
                    // 管道收到数据，触发取消
                    Err(anyhow::anyhow!("任务已取消"))
                }
            }
            Err(e) => Err(e.into()),
        }
    });

    // 延迟后向管道写入数据，触发任务退出
    sleep(Duration::from_secs(1)).await;
    write(write_fd, b"cancel")?;
    let res = input_handle.await;

    println!("结果: {:#?}", res);
    Ok(())
}

总结 #

• 优先使用Tokio的异步stdin API，它是最简洁、安全且跨平台的方案。
• 如果必须保留同步读取逻辑，可以用管道结合select的方式主动中断阻塞调用，避免依赖用户输入才能退出。

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