【Example】C++ 標準庫 std::atomic 及 std::memory_order

C++ 標準庫提供了原子操作。（我已經懶得寫序言了）

====================================

先來說原子操作的概念：

原子操作是多線程當中對資源進行保護的一種手段，主要作用是和互斥量(Mutex)一樣，避免對資源的併發訪問、修改。

互斥量的粒度衡量是作用域(哪怕作用域內只有一個變數)，而原子的粒度衡量則是以一個變數或對象為單位。因此，原子相對於互斥量更加高效，但並非替代關係。

互斥量的主要作用是保護作用域內的資源，而原子的作用是保護一個變數或對象。

因此，當你需要保護的資源僅僅是某個變數或對象時，應首先考慮使用原子。

1，std::atomic

頭文件：

#include <atomic>

std::atomic 是一個模板類，它的語法是：

std::atomic<Type> name(default_value);

如果你並不明白 std::atomic (原子) 的作用，請看以下代碼及執行結果：

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

int basic_value(0);
void ThreadChangeValue() {
    for (size_t i = 0; i < 1000000; i++)
    {
        basic_value++;
    }
    return;
}

std::atomic<int> atomic_int_value(0);
void ThreadChangeAtomic() {
    for (size_t i = 0; i < 1000000; i++)
    {
        atomic_int_value.fetch_add(1, std::memory_order_relaxed);
    }
    return;
};

int main()
{
    std::thread t1(ThreadChangeValue);
    std::thread t2(ThreadChangeValue);

    std::thread t3(ThreadChangeAtomic);
    std::thread t4(ThreadChangeAtomic);

    t1.join();
    t2.join();

    t3.join();
    t4.join();

    std::cout << "Basic Value: " << basic_value << std::endl;
    std::cout << "Atomic Value: " << atomic_int_value << std::endl;

    return EXIT_SUCCESS;
}

執行結果：

Basic Value: 1123299
Atomic Value: 2000000

以上代碼分別定義了兩個 int 變數，一個是普通的變數，一個是原子變數。兩個變數分別用兩個線程去遞增1000000次。

理論上，兩個變數最終值應同為2000000。然而，普通變數卻出現了資源競爭性錯誤，兩個線程都有接近一半的操作都是失敗的，導致最終值僅為1123299。

而受原子保護的變數，兩個線程的操作則全部成功。

std::atomic 的成員函數表：

除此之外 std::atomic 還對 int 及指針類型做了特殊化增強，以下操作函數僅適用於 int 及指針類型操作：

額外備註：C++ 20 後部分特化支持 float 。

額外補充 std::atomic_flag :

 std::atomic_flag 是原子的最基本布爾類型，它是無鎖的，並且它沒有拷貝構造函數，也不提供 load 和 store 操作。主要用於提供比 std::atomic 更簡單基本化布爾操作效率。

構造語法：

std::atomic<bool> name(false);
std::atomic_flag name = ATOMIC_FLAG_INIT;

成員函數表:

 2，std::memory_order

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

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

-- 《C++ Reference》

要理解記憶體序是做什麼的，要先從硬體講起：（儘量簡單通俗）

以一顆 CPU i7-10875H 為例，它有8顆物理內核，從物理上來講，它可以同時處理8條並行線程，通過超線程技術可以擴展到16條線程(物理上還是8條)。

再在軟體層面來講，並行的數千條線程是邏輯並行，終究都要交給 CPU 進行串列處理，而 CPU 可以同時處理的線程數量，就是由內核數量決定的。

而每個 CPU 內核所運算數據的存取，並不是直接存取到記憶體當中，而是要先經過每個內核互相獨立的 L1、L2 兩級高速緩存，再到 CPU 內核之間共用的 L3 高速緩存，再然後到記憶體。

這樣就造成了一個問題，就是，假設一個內核負責的一條線程修改了某個變數的值，但是還沒有刷新到內核之間共用的 L3 緩存或者記憶體之中，那麼這時候其他 CPU 內核從記憶體中讀取到的該變數就仍然是舊值。

所以，為了避免這種情況，這就是 std::memory_order 的作用。

首先，要明白 std::memory_order 本身是什麼，它是定義於 <atomic> 頭文件當中的六個枚舉值，使用時用做參數傳遞給 std::atomic 相關的操作函數，比如 load、store 等。

支持傳 std::memory_order 枚舉的相關操作函數上文都已經列出，這裡重點將這六個枚舉都代表什麼。

std::memory_order 枚舉值說明：

以下代碼演示了一些最簡單的使用：

下例演示兩個線程間傳遞性的釋放獲得順序:

#include <iostream>
#include <atomic>
#include <thread>
#include <string>

std::atomic<std::string*> atom_str(nullptr);
int flag = 0;
void Producer()
{
    std::string* str = new std::string("Hello Byte");
    flag = 1;
    atom_str.store(str, std::memory_order_release);
    return;
}

void Consumer()
{
    std::string* str;
    while (!(str = atom_str.load(std::memory_order_acquire)));
    
    if (flag != 1)
    {
        // 絕不會執行
        std::cout << "Error..." << std::endl;
    }
    else
    {
        std::cout << str->c_str() << std::endl;
    }

    return;
}


int main()
{
    std::thread t1(Producer);
    std::thread t2(Consumer);

    t1.join();
    t2.join();

    if (atom_str.load() != nullptr)
    {
        delete atom_str.load();
    }

    return EXIT_SUCCESS;
}

下例演示三個線程間傳遞性的釋放獲得順序:

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

std::vector<int> data;
std::atomic<int> flag(0);
void Producer()
{
    data.push_back(42);
    flag.store(1, std::memory_order_release);
    return;
}

void Broker() {
    int expected = 1;
    while (!flag.compare_exchange_strong(expected, 2, std::memory_order_acq_rel)) 
    {
        expected = 1;
    }
};

void Consumer()
{
    while (flag.load(std::memory_order_acquire) < 2);

    if (data[0] != 42)
    {
        // 絕不會執行
        std::cout << "False..." << std::endl;
    }
    else
    {
        std::cout << "True..." << std::endl;
    }

    return;
}

int main()
{
    std::thread t1(Producer);
    std::thread t2(Broker);
    std::thread t3(Consumer);

    t1.join();
    t2.join();
    t3.join();

    return EXIT_SUCCESS;
}