具有原子读写的 Mutex<bool>

Question

我需要一个将被多个线程访问的全局布尔标志。

这是我需要的示例：

static GLOBAL_FLAG: SyncLazy<Mutex<bool>> = SyncLazy::new(|| {
    Mutex::new(false)
});

fn set_flag_to_true() {  // can be called by 2+ threads concurrently 
    *GLOBAL_FLAG.lock().unwrap() = true;
}

fn get_flag_and_set_to_true() -> bool {  // only one thread is calling this function
    let v = *GLOBAL_FLAG.lock().unwrap();  // Obtain current flag value
    *GLOBAL_FLAG.lock().unwrap() = true;  // Always set the flag to true
    v  // Return the previous value
}

get_flag_and_set_to_true() 实施感觉不太正确。我想最好只锁一次。最好的方法是什么？

顺便说一句，我想 Arc<[AtomicBool]> 也可以使用并且理论上应该更快，尽管在我的特定情况下速度优势将不明显。

Answer 1

可以想象，当您阅读 GLOBAL_FLAG 和将 GLOBAL_FLAG 设置为 true 时，可能会出现另一个线程。要解决此问题，您可以直接存储 MutexGuard (docs) that GLOBAL_FLAG.lock().unwrap() returns:

fn get_flag_and_set_to_true() -> bool {  // only one thread is calling this function
    let mut global_flag = GLOBAL_FLAG.lock().unwrap();
    let v = *global_flag;  // Obtain current flag value
    *global_flag = true;  // Always set the flag to true
    v  // Return the previous value
}

global_flag 将保持锁定互斥直到它被删除。

Answer 2

BTW I suppose Arc<[AtomicBool]> can also be used and should in theory be faster, although in my particular case the speed benefit will be unnoticeable.

这不仅仅是性能上的好处，还有代码量和推理代码的便利性。使用 AtomicBool 你既不需要 SyncLazy 也不需要互斥量，而且代码更短更清晰：

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

static GLOBAL_FLAG: AtomicBool = AtomicBool::new(false);

pub fn set_flag_to_true() {
    GLOBAL_FLAG.store(true, Ordering::SeqCst);
}

pub fn get_flag_and_set_to_true() -> bool {
    GLOBAL_FLAG.swap(true, Ordering::SeqCst)
}

Playground

具有原子读写的 Mutex<bool>

Mutex<bool> with an atomic read&write

concurrency

mutex

rust