Function core::sync::atomic::fence

pub fn fence(order: Ordering)

原子栅栏。

根据指定的顺序，栅栏可防止编译器和 CPU 对其周围的某些类型的内存操作重新排序。 这会在它与其他线程中的原子操作或栅栏之间创建同步关系。

具有 (至少) Release 排序语义的栅栏 A 与具有 (至少) Acquire 语义的栅栏 B 同步，当且仅当存在操作 X 和 Y 时，这两个操作都在某个原子对象 M 上操作，使得 A 在 X 之前排序，Y 在 B 之前排序，并且 Y 观察到 M 的变化 这提供了 A 和 B 之间的依存关系。

    Thread 1                                          Thread 2

fence(Release);      A --------------
x.store(3, Relaxed); X ---------    |
                               |    |
                               |    |
                               -------------> Y  if x.load(Relaxed) == 3 {
                                    |-------> B      fence(Acquire);
                                                     ...
                                                 }

具有 Release 或 Acquire 语义的原子操作也可以与栅栏同步。

除了具有 Acquire 和 Release 语义外，具有 SeqCst 顺序的栅栏还参与其他 SeqCst 操作和/或栅栏的全局程序顺序。

接受 Acquire，Release，AcqRel 和 SeqCst 排序。

Panics

如果 order 为 Relaxed，就会出现 panics。

Examples

use std::sync::atomic::AtomicBool;
use std::sync::atomic::fence;
use std::sync::atomic::Ordering;

// 基于自旋锁的互斥原语。
pub struct Mutex {
    flag: AtomicBool,
}

impl Mutex {
    pub fn new() -> Mutex {
        Mutex {
            flag: AtomicBool::new(false),
        }
    }

    pub fn lock(&self) {
        // 等待直到旧值为 `false`。
        while self
            .flag
            .compare_exchange_weak(false, true, Ordering::Relaxed, Ordering::Relaxed)
            .is_err()
        {}
        // 此栅栏与 `unlock` 中的存储同步。
        fence(Ordering::Acquire);
    }

    pub fn unlock(&self) {
        self.flag.store(false, Ordering::Release);
    }
}