std::memory_order

enum memory_order
{
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
};

enum class memory_order : /* 未指定 */
{
    relaxed, consume, acquire, release, acq_rel, seq_cst
};
inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
inline constexpr memory_order memory_order_consume = memory_order::consume;
inline constexpr memory_order memory_order_acquire = memory_order::acquire;
inline constexpr memory_order memory_order_release = memory_order::release;
inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;

std::memory_order 指定內存訪問，包括常規的非原子內存訪問，如何圍繞原子操作排序。在沒有任何約束的多處理器系統上，多個線程同時讀或寫數個變量時，一個線程能觀測到變量值更改的順序不同於另一個線程寫它們的順序。實際上，更改的順序甚至能在多個讀取線程間相異。一些類似的效果還能在單處理器系統上出現，因為內存模型允許編譯器進行變換。

庫中所有原子操作的默認行為提供序列一致定序（見後述討論）。該默認行為可能有損性能，不過可以給予庫的原子操作額外的 std::memory_order 實參，以指定確切的約束，在原子性外，編譯器和處理器還必須強制該操作。

常量

正式描述

線程間同步和內存定序決定了表達式的求值 和副作用 如何在不同的執行線程間排序。它們用下列術語定義：

先序於

在同一線程中，求值 A 可以先序於求值 B，如求值順序中所描述。

修改順序

對一個特定的原子變量的修改，以限定於此原子變量的單獨全序進行。

對所有原子操作保證下列四個要求：

釋放序列

在原子對象 M 上執行一次釋放操作 A 之後，M 的修改順序的最長連續子序列由下列內容組成：

被稱為以 A 為首的釋放序列。

同步於

如果在線程 A 上的一個原子存儲是釋放操作，在線程 B 上的對相同變量的一個原子加載是獲得操作，且線程 B 上的加載讀取由線程 A 上的存儲寫入的值，則線程 A 上的存儲同步於線程 B 上的加載。

此外，某些庫調用也可能定義為同步於其它線程上的其它庫調用。

線程間先發生於

在線程間，若下列任一為真，則求值 A 線程間先發生於 求值 B

強先發生於

無關乎線程，若下列之一為真，則求值 A 強先發生於 求值 B ：

可見副作用

若下列皆為真，則標量 M 上的副作用 A（寫入）相對於 M 上的值計算（讀取）可見：

如果副作用 A 相對於值計算 B 可見，那麼 M 上滿足 B 不先發生於 的副作用，在 M 上按修改順序 排列的最長連續子集，稱為副作用的可見序列（由 B 確定的 M 值將是這些副作用之一存儲的值）。

標準要求實現應當確保原子存儲操作在一個合理的時間內對其它原子加載操作可見（但並未明確「合理的時間」的要求）。

注意：線程間同步可歸結為避免數據競爭（通過建立先發生於關係），及定義在何種條件下哪些副作用成為可見。數據的可見性與 CPU 緩存強相關。

消費操作

帶 memory_order_consume 或更強標籤的原子加載是消費操作。注意 std::atomic_thread_fence 會施加比消費操作更強的同步要求。

獲得操作

帶 memory_order_acquire 或更強標籤的原子加載是獲得操作。互斥上的 lock() 操作亦為獲得操作。注意 std::atomic_thread_fence 會施加比獲得操作更強的同步要求。

釋放操作

帶 memory_order_release 或更強標籤的原子存儲是釋放操作。互斥上的 unlock() 操作亦為釋放操作。注意 std::atomic_thread_fence 會施加比釋放操作更強的同步要求。

解釋

寬鬆定序

被標以 memory_order_relaxed 的原子操作不是同步操作；它們不會為並發的內存訪問行為添加定序約束。它們只保證原子性和修改順序的一致性。

例如，對於初始值為零的 x 和 y，

// 线程 1：
r1 = y.load(std::memory_order_relaxed); // A
x.store(r1, std::memory_order_relaxed); // B
// 线程 2：
r2 = x.load(std::memory_order_relaxed); // C 
y.store(42, std::memory_order_relaxed); // D

允許產生 r1 == r2 && r2 == 42。因為即使線程 1 中 A 先序於 B 且線程 2 中 C 先序於 D，卻無法避免在 y 的修改順序中 D 會出現於 A 之前，且在 x 的修改順序中 B 會出現於 C 之前。D 的對 y 的副效應可能可見於線程 1 中 A 的加載操作，而 B 對 x 的副效應可能可見於線程 2 中 C 的加載操作。尤其是，這可能在線程 2 中 D 於 C 之前完成的情況下發生，無論因為編譯器重排還是發生於運行時。

// 线程1：
r1 = y.load(std::memory_order_relaxed);
if (r1 == 42)
    x.store(r1, std::memory_order_relaxed);
// 线程2：
r2 = x.load(memory_order_relaxed);
if (r2 == 42)
    y.store(42, std::memory_order_relaxed);

寬鬆內存定序的典型的應用是計數器自增，例如 std::shared_ptr 的引用計數器，因為這只要求原子性，但不要求定序或同步（注意 std::shared_ptr 計數器的自減要求與析構函數間進行獲得-釋放同步）。

#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

std::atomic<int> cnt = {0};

void f()
{
    for (int n = 0; n < 1000; ++n)
        cnt.fetch_add(1, std::memory_order_relaxed);
}

int main()
{
    std::vector<std::thread> v;
    for (int n = 0; n < 10; ++n)
        v.emplace_back(f);
    for (auto& t : v)
        t.join();
    std::cout << "最终计数器值为 " << cnt << '\n';
}

最终计数器值为 10000

釋放-獲取定序

若線程 A 中的一個原子存儲被標以 memory_order_release，而線程 B 中從同一變量的原子加載被標以 memory_order_acquire，且線程 B 中的加載讀到了線程 A 中的存儲所寫入的值，則線程 A 中的存儲同步於線程 B 中的加載。

從線程 A 的視角先發生於原子存儲的所有內存寫入（包括非原子及寬鬆原子的），在線程 B 中成為可見副效應。即一旦原子加載完成，則保證線程 B 能觀察到線程 A 寫入內存的所有內容。僅當 B 實際上返回了 A 所存儲的值或其釋放序列中後面的值時，才有此保證。

同步僅建立在釋放和獲得同一原子變量的線程之間。其他線程可能看到與被同步線程的一者或兩者相異的內存訪問順序。

在強順序系統（x86、SPARC TSO、IBM 大型機）上，釋放-獲得定序對於多數操作是自動進行的。無需為此同步模式發出額外的 CPU 指令，只有某些編譯器優化受影響（例如，編譯器被禁止將非原子存儲移到原子存儲-釋放之後，或將非原子加載移到原子加載-獲得之前）。在弱順序系統（ARM、Itanium、Power PC）上，必須使用特別的 CPU 加載或內存柵欄指令。

互斥鎖（例如 std::mutex 或原子自旋鎖）是釋放-獲得同步的例子：線程 A 釋放鎖而線程 B 獲得它時，發生於線程 A 上下文的臨界區（釋放之前）中的所有事件，必須對於執行同一臨界區的線程 B（獲得之後）可見。

#include <atomic>
#include <cassert>
#include <string>
#include <thread>
 
std::atomic<std::string*> ptr;
int data;
 
void producer()
{
    std::string* p = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}
 
void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_acquire)))
        ;
    assert(*p2 == "Hello"); // 绝无问题
    assert(data == 42); // 绝无问题
}
 
int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

#include <atomic>
#include <cassert>
#include <thread>
#include <vector>

std::vector<int> data;
std::atomic<int> flag = {0};

void thread_1()
{
    data.push_back(42);
    flag.store(1, std::memory_order_release);
}

void thread_2()
{
    int expected=1;
    // memory_order_relaxed 是可以的，因为这是一个 RMW 操作
    // 而 RMW（以任意定序）跟在释放之后将组成释放序列
    while (!flag.compare_exchange_strong(expected, 2, std::memory_order_relaxed))
    {
        expected = 1;
    }
}

void thread_3()
{
    while (flag.load(std::memory_order_acquire) < 2)
        ;
    // 如果我们从 atomic flag 中读到 2，将看到 vector 中储存 42
    assert(data.at(0) == 42); //决不出错
}

int main()
{
    std::thread a(thread_1);
    std::thread b(thread_2);
    std::thread c(thread_3);
    a.join(); b.join(); c.join();
}

釋放-消費定序

#include <atomic>
#include <cassert>
#include <string>
#include <thread>

std::atomic<std::string*> ptr;
int data;

void producer()
{
    std::string* p = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}

void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_consume)))
        ;
    assert(*p2 == "Hello"); // 绝无出错： *p2 从 ptr 携带依赖
    assert(data == 42); // 可能也可能不会出错： data 不从 ptr 携带依赖
}

int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

序列一致定序

被標為 memory_order_seq_cst 的原子操作不僅以與釋放-獲得定序相同的方式進行內存定序（在一個線程中先發生於存儲的任何副作用都變成進行加載的線程中的可見副作用），還對所有帶此標籤的內存操作建立了一個單獨全序。

// 线程 1 ：
x.store(1, std::memory_order_seq_cst); // A
y.store(1, std::memory_order_release); // B
// 线程 2 ：
r1 = y.fetch_add(1, std::memory_order_seq_cst); // C
r2 = y.load(std::memory_order_relaxed); // D
// 线程 3 ：
y.store(3, std::memory_order_seq_cst); // E
r3 = x.load(std::memory_order_seq_cst); // F

在多生產者-多消費者的情形中，若所有消費者都必須以相同順序觀察到所有生產者的動作出現，則可能必須進行序列定序。

全序列定序在所有多核系統上都要求完全的內存柵欄 CPU 指令。這可能成為性能瓶頸，因為它強制受影響的內存訪問傳播到每個核心。

#include <atomic>
#include <cassert>
#include <thread>

std::atomic<bool> x = {false};
std::atomic<bool> y = {false};
std::atomic<int> z = {0};

void write_x()
{
    x.store(true, std::memory_order_seq_cst);
}

void write_y()
{
    y.store(true, std::memory_order_seq_cst);
}

void read_x_then_y()
{
    while (!x.load(std::memory_order_seq_cst))
        ;
    if (y.load(std::memory_order_seq_cst))
        ++z;
}

void read_y_then_x()
{
    while (!y.load(std::memory_order_seq_cst))
        ;
    if (x.load(std::memory_order_seq_cst))
        ++z;
}

int main()
{
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x);
    a.join(); b.join(); c.join(); d.join();
    assert(z.load() != 0);  //决不发生
}

與 volatile 的關係

在執行線程中，不能將通過 volatile 泛左值進行的訪問（讀和寫）重排到同線程內先序於 或後序於 它的可觀測副效應（包含其他 volatile 訪問）後，但不保證另一線程觀察到此順序，因為 volatile 訪問不建立線程間同步。

另外，volatile 訪問不是原子的（共時的讀和寫是數據競爭），且沒有內存定序（非 volatile 內存訪問可以自由地重排到 volatile 訪問前後）。

一個值得注意的例外是 Visual Studio，其中默認設置下，每個 volatile 寫擁有釋放語義，而每個 volatile 讀擁有獲得語義（微軟文檔），故而可將 volatile 對象用於線程間同步。標準的 volatile 語義不可應用於多線程編程，儘管它們在應用到 sig_atomic_t 對象時，足以用於例如與運行於同一線程的 std::signal 處理函數間的通信。可以使用編譯器選項 /volatile:iso 恢復和標準一致的行為，當目標平台是 ARM 時這是默認設置。

參閱

外部連結