封装crossterm同步输入为异步Future：解决高CPU占用与优化实现

问题本质 #

你碰到的是同步阻塞API适配异步Runtime的典型问题：直接在Future里循环轮询Crossterm的同步输入会导致线程空转（CPU拉满），之前手动加sleep没生效，大概率是用了同步sleep而非异步sleep——同步sleep会卡死整个异步线程，而非让Future主动让出执行权。

为什么初始实现CPU跑满？ #

异步Runtime的调度依赖Future通过.await主动挂起，把执行权交还给调度器。如果你的Future里是无挂起的loop { check_input() }，调度器会一直调度这个Future，导致CPU100%占用。而用std::thread::sleep的话，会阻塞整个异步线程，让Runtime无法处理其他任务，完全违背异步的初衷。

惯用实现方案 #

方案1：异步轮询+可控挂起 #

如果Crossterm支持非阻塞读取（比如read_char_nb），可以配合异步sleep实现低CPU占用的轮询：

use crossterm::input::Input;
use std::time::Duration;
use tokio::time::sleep;

async fn poll_input() -> Option<char> {
    let input = Input::new();
    loop {
        match input.read_char_nb() {
            Ok(Some(c)) => return Some(c),
            _ => {
                // 每隔10ms轮询一次，主动让出执行权
                sleep(Duration::from_millis(10)).await;
            }
        }
    }
}

方案2：同步阻塞操作隔离到阻塞线程池 #

如果Crossterm没有非阻塞API，更优雅的方式是把同步阻塞的读取操作放到Runtime的阻塞任务池（比如Tokio的spawn_blocking），避免阻塞异步执行线程：

use crossterm::input::Input;
use tokio::task::spawn_blocking;

async fn wait_for_input() -> char {
    // 将同步阻塞操作交给专门的阻塞线程池处理
    spawn_blocking(|| {
        let input = Input::new();
        input.read_char().unwrap()
    }).await.unwrap()
}

这个方式不会导致CPU空转，因为阻塞任务会在单独的线程里运行，异步Runtime的线程可以去处理其他任务，直到阻塞任务完成后再唤醒对应的Future。

关于异步范式的澄清 #

完全可以为无异步支持的同步逻辑封装Future，但必须遵守两个原则：

1. 绝对不要在异步执行线程里做同步阻塞操作，否则会拖垮整个Runtime的并发能力；
2. 封装的Future必须能通过.await主动挂起，或者把阻塞逻辑隔离到专门的线程池，避免空转。

你的async块能运行，应该是里面包含了.await挂起逻辑，但如果是无挂起的轮询，那依然是错误的写法。

进阶优雅方案：封装为Stream #

如果需要持续监听输入，把逻辑封装成Stream会更符合异步编程的惯用风格，方便和其他异步逻辑组合：

use crossterm::input::Input;
use futures::stream::Stream;
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::task::spawn_blocking;

struct InputStream {
    input: Input,
}

impl InputStream {
    fn new() -> Self {
        Self { input: Input::new() }
    }
}

impl Stream for InputStream {
    type Item = char;

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let input = self.input.clone();
        // 提交阻塞任务，完成后自动唤醒当前Future
        spawn_blocking(move || input.read_char().unwrap())
            .poll_unpin(cx)
            .map(|res| Some(res.unwrap()))
    }
}

// 使用示例
async fn listen_input() {
    let mut stream = InputStream::new();
    while let Some(c) = stream.next().await {
        println!("收到输入: {}", c);
    }
}

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