具有原子读写的 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 时，可能会出现另一个线程。要解决此问题，您可以直接存储 GLOBAL_FLAG.lock().unwrap() 返回的 MutexGuard (docs)：

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

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

这不仅关乎性能方面的好处，还关乎代码量和推理代码的易用性。使用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