The first terminal event is ignored after using stdin

[dalance]

Version

tokio v1.26.0

Platform

x86_64 GNU/Linux

Description

I want to use tokio::io::stdin with timeout and terminal event after it.
But the first event seems to be ignored.
The procedure of reproduce is below:

use crossterm::event::read;
use crossterm::terminal;
use std::time::Duration;

fn main() {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_time()
        .build()
        .unwrap();
    let buf = runtime.block_on(async {
        tokio::time::timeout(Duration::new(1, 0), async {
            use tokio::io::AsyncReadExt;
            let mut buf = [0; 1];
            let mut stdin = tokio::io::stdin();
            let _ = stdin.read_exact(&mut buf).await;
            buf
        })
        .await
    });
    dbg!(buf);

    terminal::enable_raw_mode().unwrap();

    println!("{:?}", read());

    terminal::disable_raw_mode().unwrap();
}

• run the above code
• wait until dbg! message is shown
• press any key

I expected to see this happen: the first key pressing is shown

Instead, this happened: the first key pressing is ignored, and the second key pressing is shown.

If let buf = ... code block is commented out, the first key pressing is shown.

This seems to be the same behaviour as async_std.
async-rs/async-std#1055

Is there any usage mistake or any known limitation?

[Darksonn]

Reading from stdin is based on spawn_blocking, so you cannot cancel it, even with a timeout. It will keep running in the background.

This is a well known issue, and it is the reason we added this to the documentation for tokio::io::stdin.

This handle is best used for non-interactive uses, such as when a file is piped into the application. For technical reasons, stdin is implemented by using an ordinary blocking read on a separate thread, and it is impossible to cancel that read. This can make shutdown of the runtime hang until the user presses enter.

For interactive uses, it is recommended to spawn a thread dedicated to user input and use blocking IO directly in that thread.

Since your IO is interactive, I recommend not using Tokio's stdin for it.

[dalance]

I understood it. Thanks.