如何在Rust中使用Crossterm实现多线程共享键盘事件？

问题 #

我通过循环创建多个线程，每个线程监听不同按键，期望在对应按键按下时执行操作。当前使用的wait_until_user_input函数如下：

#[cfg(target_os = "windows")]
pub fn wait_until_user_input(input_config: &InputConfig) {
    loop {
        if let Ok(_) = poll(Duration::from_millis(20)) {
            println!("Event polled, expecting '{}'", input_config.key.unwrap());
            match read().unwrap() {
                Event::Key(KeyEvent {
                    code,
                    modifiers: _,
                    kind,
                    state: _,
                }) => {
                    if code == KeyCode::Char(input_config.key.unwrap())
                        && kind == KeyEventKind::Press
                    {
                        break;
                    }
                    println!(
                        "Expected: '{}', Found: '{:?}' {:?}",
                        input_config.key.unwrap(),
                        code,
                        kind
                    );
                }
                _ => {
                    println!("No event");
                }
            }
        }

        // Sleep for a short duration to avoid high CPU usage while waiting for input.
        thread::sleep(Duration::from_millis(20));
    }
}

运行时按下空格，得到如下输出：

Expected: 'x', Found: 'Char(' ')' Press
Expected: ' ', Found: 'Char(' ')' Release
Event polled, expecting 'x'
Event polled, expecting ' '

可见线程会抢占键盘事件，导致目标线程无法捕获对应事件（如监听空格的线程可能被监听x的线程抢占）。线程创建代码如下：

// The configuration
#[derive(Debug, Clone)]
pub struct InputConfig {
    pub key: Option<char>,
    // ...
}

let input_configs = vec![
    InputConfig { key: Some(' ') },
    InputConfig { key: Some('x') },
];

// Spawn the threads
let mut handles = vec![];
for (n, config) in input_configs.iter().enumerate() {
    let cloned_config = config.clone();
    let handle = thread::spawn(move || {
        wait_until_user_input(&cloned_config)
    });
    handles.push(handle);
}

// Wait for all threads to finish
for handle in handles {
    handle.join().expect("Thread panicked");
}

请问如何实现多线程共享键盘事件？

解决方案 #

核心思路是单线程集中捕获所有键盘事件，再通过通道将事件分发给各监听线程，彻底避免多线程抢占事件流的问题。具体实现如下：

1. 用通道实现事件分发 #

使用Rust标准库std::sync::mpsc创建多生产者单消费者通道，让专门的事件捕获线程读取所有键盘事件，再将事件发送给所有监听线程，由线程自行判断是否处理目标按键。

2. 修改监听线程逻辑 #

每个监听线程不再主动轮询键盘，而是从通道接收事件，匹配到目标按键的按下事件后退出。

完整代码示例 #

use std::sync::mpsc;
use std::thread;
use std::time::Duration;
// 根据实际使用的输入库调整导入，这里以crossterm为例
use crossterm::event::{poll, read, Event, KeyCode, KeyEvent, KeyEventKind};

#[derive(Debug, Clone)]
pub struct InputConfig {
    pub key: Option<char>,
    // ... 其他配置字段
}

// 监听线程：接收事件并匹配目标按键
fn wait_for_target_key(config: InputConfig, receiver: mpsc::Receiver<KeyEvent>) {
    let target_key = config.key.unwrap();
    println!("Listening for key '{}'", target_key);
    
    loop {
        match receiver.recv() {
            Ok(event) => {
                if event.code == KeyCode::Char(target_key) && event.kind == KeyEventKind::Press {
                    println!("Key '{}' pressed, exiting thread", target_key);
                    break;
                }
            }
            Err(_) => break, // 通道关闭时退出循环
        }
    }
}

fn main() {
    let input_configs = vec![
        InputConfig { key: Some(' ') },
        InputConfig { key: Some('x') },
    ];

    // 创建多生产者通道，每个监听线程持有克隆的接收器
    let (sender, receiver) = mpsc::channel();
    let mut handles = vec![];

    // 启动各监听线程
    for config in input_configs {
        let thread_receiver = receiver.clone();
        let handle = thread::spawn(move || {
            wait_for_target_key(config, thread_receiver);
        });
        handles.push(handle);
    }

    // 启动事件捕获线程：读取所有键盘事件并分发
    let event_handle = thread::spawn(move || {
        loop {
            if poll(Duration::from_millis(20)).unwrap() {
                match read().unwrap() {
                    Event::Key(key_event) => {
                        // 将事件发送给所有监听线程
                        let _ = sender.send(key_event);
                    }
                    _ => {} // 忽略非键盘事件
                }
            }
            thread::sleep(Duration::from_millis(20));
        }
    });

    // 等待所有监听线程完成
    for handle in handles {
        handle.join().expect("Thread panicked");
    }

    // 监听线程全部结束后，终止事件捕获线程
    event_handle.detach();
}

关键说明 #

• 集中捕获事件：仅一个线程负责读取键盘事件，彻底解决多线程抢占问题。
• 通道分发：通过克隆接收器，每个监听线程都能收到所有键盘事件，自行过滤处理目标按键。
• 资源高效：避免多线程轮询导致的高CPU占用，逻辑更简洁可控。

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