std::atomic_thread_fence

定义在头文件 `<atomic>` 中
extern "C" void atomic_thread_fence( std::memory_order order ) noexcept;		(自 C++11 起)

根据 order 指示，建立非原子和松散原子访问的内存同步顺序，不涉及相关的原子操作。但是请注意，至少需要一个原子操作来设置同步，如下所述。

内容

1 栅栏-原子同步
2 原子-栅栏同步
3 栅栏-栅栏同步
4 参数
5 返回值
6 注释
7 示例
8 另请参见

[编辑] 栅栏-原子同步

如果线程 A 中的发布栅栏 F 与线程 B 中的原子获取操作 Y 同步，则

存在一个原子存储 X（具有任何内存顺序），
Y 读取 X 写入的值（或者如果 X 是发布操作，则读取由以 X 为首的发布序列写入的值），
F 在线程 A 中按顺序位于 X 之前。

在这种情况下，在线程 A 中按顺序位于 F 之前的所有非原子和松散原子存储将发生在线程 B 中 Y 之后从相同位置进行的所有非原子和松散原子加载之前。

[编辑] 原子-栅栏同步

如果线程 A 中的原子发布操作 X 与线程 B 中的获取栅栏 F 同步，则

存在一个原子读取 Y（具有任何内存顺序），
Y 读取 X 写入的值（或由以 X 为首的发布序列写入的值），
Y 在线程 B 中按顺序位于 F 之前。

在这种情况下，在线程 A 中按顺序位于 X 之前的所有非原子和松散原子存储将发生在线程 B 中 F 之后从相同位置进行的所有非原子和松散原子加载之前。

[编辑] 栅栏-栅栏同步

如果线程 A 中的发布栅栏 FA 与线程 B 中的获取栅栏 FB 同步，则

存在一个原子对象 M，
存在一个修改线程 A 中的 M 的原子写入 X（具有任何内存顺序），
FA 在线程 A 中按顺序位于 X 之前，
存在一个线程 B 中的原子读取 Y（具有任何内存顺序），
Y 读取 X 写入的值（或者如果 X 是发布操作，则读取由以 X 为首的发布序列写入的值），
Y 在线程 B 中按顺序位于 FB 之前。

在这种情况下，在线程 A 中按顺序位于 FA 之前的所有非原子和松散原子存储将发生在线程 B 中 FB 之后从相同位置进行的所有非原子和松散原子加载之前。

[编辑] 参数

order

-

此栅栏执行的内存排序

[编辑] 返回值

(无)

[编辑] 注释

在 x86（包括 x86-64）上，atomic_thread_fence 函数不发出任何 CPU 指令，仅影响编译时代码移动，除了 std::atomic_thread_fence(std::memory_order_seq_cst)。

atomic_thread_fence 施加的同步约束比具有相同 std::memory_order 的原子存储操作更强。虽然原子存储-发布操作可以阻止所有先前的读取和写入越过存储-发布，但具有 std::memory_order_release 排序的 atomic_thread_fence 可以阻止所有先前的读取和写入越过所有后续存储。

栅栏-栅栏同步可用于向一系列松散原子操作添加同步，例如

// Global
std::string computation(int);
void print(std::string);
 
std::atomic<int> arr[3] = {-1, -1, -1};
std::string data[1000]; //non-atomic data
 
// Thread A, compute 3 values.
void ThreadA(int v0, int v1, int v2)
{
//  assert(0 <= v0, v1, v2 < 1000);
    data[v0] = computation(v0);
    data[v1] = computation(v1);
    data[v2] = computation(v2);
    std::atomic_thread_fence(std::memory_order_release);
    std::atomic_store_explicit(&arr[0], v0, std::memory_order_relaxed);
    std::atomic_store_explicit(&arr[1], v1, std::memory_order_relaxed);
    std::atomic_store_explicit(&arr[2], v2, std::memory_order_relaxed);
}
 
// Thread B, prints between 0 and 3 values already computed.
void ThreadB()
{
    int v0 = std::atomic_load_explicit(&arr[0], std::memory_order_relaxed);
    int v1 = std::atomic_load_explicit(&arr[1], std::memory_order_relaxed);
    int v2 = std::atomic_load_explicit(&arr[2], std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);
//  v0, v1, v2 might turn out to be -1, some or all of them.
//  Otherwise it is safe to read the non-atomic data because of the fences:
    if (v0 != -1)
        print(data[v0]);
    if (v1 != -1)
        print(data[v1]);
    if (v2 != -1)
        print(data[v2]);
}

[编辑] 示例

扫描一个邮箱数组，只处理面向我们的邮箱，无需不必要的同步。此示例使用原子-栅栏同步。

const int num_mailboxes = 32;
std::atomic<int> mailbox_receiver[num_mailboxes];
std::string mailbox_data[num_mailboxes];
 
// The writer threads update non-atomic shared data 
// and then update mailbox_receiver[i] as follows:
mailbox_data[i] = ...;
std::atomic_store_explicit(&mailbox_receiver[i], receiver_id, std::memory_order_release);
 
// Reader thread needs to check all mailbox[i], but only needs to sync with one.
for (int i = 0; i < num_mailboxes; ++i)
    if (std::atomic_load_explicit(&mailbox_receiver[i],
        std::memory_order_relaxed) == my_id)
    {
        // synchronize with just one writer
        std::atomic_thread_fence(std::memory_order_acquire);
        // guaranteed to observe everything done in the writer thread
        // before the atomic_store_explicit()
        do_work(mailbox_data[i]);
    }

[编辑] 另请参见

memory_order (C++11)	为给定的原子操作定义内存排序约束 (枚举) [编辑]
atomic_signal_fence (C++11)	同一个线程中线程与信号处理程序之间的栅栏 (函数) [编辑]
C 文档 for atomic_thread_fence

编译器支持
独立和宿主
语言
标准库
标准库头文件
命名需求
功能测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作