Function core::sync::atomic::fence

pub fn fence(order: Ordering)

原子 fence。

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

具有 (至少) Release 排序语义的 Fence ‘A’ 与具有 (至少) Acquire 语义的 Fence ‘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);
    }
}