防止 Fn 在它已经运行时再次被调用

Question

我正在使用inputbot 编写一个为我的计算机提供一些全局宏的程序。例如，当我按下 h 键时，它应该执行宏输入

你好世界

进入当前应用程序。我试图这样实现它：

extern crate inputbot;

fn main() {
    let mut callback = || {
        inputbot::KeySequence("Hello World").send();
    };

    inputbot::KeybdKey::HKey.bind(callback);

    inputbot::handle_input_events();
}

然而，当我按下 h 键时，我实际得到的是：

hHHHHHHHHHHHHHHHHHHHHHHHHHEHEHhEhEEHHhEhEhEHhEHHEHHEEHhEHlhEHEHHEHLEHLHeeleleelelelllelelleelehlhehlleeheehelheelleeleelhllllllellelolelellelleoleloloelellololol olollollelllolllol lloo醇○◎升LO lolooloooloo厕所LOWOLO 0 1 OLW WOWO大号WLLOLOW L O，○○○○WOWW低öoOow WWW WOW wowooWWWO oOWRWOoorW¯¯行oOWorororWRRWLR rLROwoRWLWOworo WorrrRWl流öWRLR OLWöOWLDol rollWWLDWowDLlroWWořoWDWOL dorRrwrolrdrrorlrLWDRdodRLowdllrllolrdlrddolrdlrldowldorowlrdlrorloLDLWDLoddlrddlrdldldldrrdordldrlrddrodlrrldoldlrlddldlrdlldlrdlddrlddldddlddlddd P>

宏在每次发送 h 键事件时都会自行触发。 ????

如何防止Fn 在另一个实例仍在运行时再次被调用？这是小型应用程序的主要功能，因此无需担心兼容性问题与。

---

我天真的尝试修复 这是在main 中添加一个mut running 变量，callback 在运行时将设置为true，或者immediately 在它已经为真时返回：

extern crate inputbot;

use std::time::Duration;
use std::thread::sleep;

fn main() {
    let mut running = false;
    let mut callback = || {
        if running { return };
        running = true;

        inputbot::KeySequence("Hello World").send();

        // wait to make sure keyboard events are done. 
        sleep(Duration::from_millis(125));

        running = false;
    };

    inputbot::KeybdKey::HKey.bind(callback);
    inputbot::handle_input_events();
}

但是，这不会编译：

error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`

经过一番阅读，我现在的理解是 Fn 闭包（inputbot 的 .bind() 方法需要）不能拥有任何可变数据，例如捕获的 mut 变量。

也许可以将变量包装在某种非mut 值中？可能是某种锁，以确保潜在的并发安全，比如这个伪代码？

fn main() {
    let mut running = false;
    let lockedRunning = example::Lock(&running);
    let mut callback = || {
        {
            let mut running = lockedRunning.acquire();
            if running { return };
            running = true;
        }

        inputbot::KeySequence("Hello World").send();

        // wait to make sure keyboard events are done. 
        sleep(Duration::from_millis(125));

        {
            let mut running = lockedRunning.acquire();
            running = false;
        }
    };
}

Answer 1

你想要的是这个函数与它自己是互斥的。

Rust 允许您使用 Mutex 结构来执行此操作。它允许你持有一个锁，当你获得它时，它会阻止其他人使用它，直到你释放它。

您想要的具体功能是try_lock 方法，它允许您检查锁是否已被获取并允许您处理这种情况。

let lock = mutex.try_lock();

match lock {
    Ok(_) => {
       // We are the sole owners here
    }
    Err(TryLockError::WouldBlock) => return,
    Err(TryLockError::Poisoned(_)) => {
        println!("The mutex is poisoned");
        return
    }
}

Answer 2

使用原子值比Mutex 简单一些，因为您无需担心失败情况，并且无需使用惰性静态即可轻松将其制成静态变量：

use std::sync::atomic::{AtomicBool, Ordering};

fn main() {
    let is_being_called = AtomicBool::new(false);

    bind(move || {
        if !is_being_called.compare_and_swap(false, true, Ordering::SeqCst) {
            print!("I'm doing work");
            is_being_called.store(false, Ordering::SeqCst);
        }
    });
}

我有一种预感，这也比使用 Mutex 更有效，因为不需要进行堆分配，但我没有对其进行基准测试。

如果您在单线程上下文中并且您的回调以某种方式（意外？）递归（which closures cannot be），您也可以使用Cell：

use std::cell::Cell;

fn main() {
    let is_being_called = Cell::new(false);

    bind(move || {
        if !is_being_called.get() {
            is_being_called.set(true);
            print!("doing work");
            is_being_called.set(false);
        }
    })
}

如果你碰巧有一个 FnMut 闭包，你甚至不需要 Cell 并且可以只使用一个布尔值：

fn main() {
    let mut is_being_called = false;

    bind(move || {
        if !is_being_called {
            is_being_called = true;
            print!("doing work");
            is_being_called = false;
        }
    })
}