搞懂無鎖程式設計的重要一步是完全理解記憶體順序！
本教學由作者和ChatGPT通力合作完成。
c++的記憶體模型共有6種
如果你有幸閱讀過cpprefence的這一章節，我想你一定會對這些概念的晦澀難懂有深刻的印象！有大量的教學都會從memory_order_relaxed的概念開始介紹，我認為這是不妥的，如果對記憶體順序沒有一個大致的瞭解之前，沒有對比，你根本無法得知「寬鬆」到底意味著什麼，到底寬鬆在什麼地方。
因此，我覺得有必要先對 memory_order_acquire 和memory_order_release 進行了解。我們需要指導 memory_order_acquire 和memory_order_release 會對我們的程式碼到底產生怎樣的影響，需要理解他們為什麼這樣命名。
記憶體順序 memory_order_acquire 表示該操作需要在後續的讀操作中確保獲得在當前操作之前已經完成的所有寫操作的結果。即，在當前操作之前，所有的寫操作必須在記憶體中完成，然後該操作才能進行。這意味著 memory_order_acquire 會阻止處理器和編譯器在該操作和後續讀操作之間重新排序。
記憶體順序 memory_order_release 表示該操作需要在當前操作之前確保所有已經完成的讀和寫操作都要被立即重新整理到記憶體中。也就是說，該操作會將其前面的寫操作立即重新整理到記憶體中，這樣後續的讀操作就能夠存取到這些資料了。同時，該操作之後的寫操作也不能被重排序到該操作之前。
以上是ChatGPT的解釋，不是我的解釋，僅僅依靠文字解釋，往往會讓人一頭霧水。如果用來解釋概念的概念仍然是你不懂得概念，那麼這個解釋本身就成為了學習的門檻，因此，我們必須要抽絲剝繭，慢慢來。
在上述解釋中，我們注意到，這裡有一個關鍵概念：指令重排。
是的，無論是否在多執行緒環境下，由於編譯器對程式碼的優化，實際的組合指令的順序，有可能與c++程式碼的順序不一致（處理器也會對指令進行重排）。
這種重排可以分為三種型別：
指令重排其實是一種優化手段，但它的出現也為多執行緒程式設計帶來了麻煩，下面的例子展示了指令重排是如何影響多執行緒程式設計的：
int x = 0;
int y = 0;
void thread1() {
y = 2;
}
void thread2() {
while (y != 2) {}
assert(x == 1);
}
如果此時執行兩個執行緒，我們期望的事情是,執行緒2一直等到y == 2，然後檢查x是否為1，當y已經等於2時，執行緒1執行了 x = 1;y = 2;
因此x一定等於1。
但由於指令重排，執行緒1的執行順序有可能是
y = 2;
x = 1;
如果執行緒1剛剛執行完y=2，執行緒2就開始執行，此時迴圈條件失敗，斷言語句在x=1前執行了，那麼此時就會斷言失敗。
體會到指令重排給我們帶來的麻煩了嗎？
且看我們如何使用記憶體順序來避免這種情況
int x = 0;
std::atomic_int y(0);
void thread1() {
x = 1;
y.store(2, std::memory_order_release);
}
void thread2() {
int tmp;
do {
tmp = y.load(std::memory_order_acquire);
} while (tmp != 2);
assert(x == 1);
}
在這個例子中memory_order_release memory_order_acquire 起到了什麼作用呢？他是如何幫助我們解決重排問題的？讓我們一步步解釋:
在這個例子中，使用了memory_order_release和memory_order_acquire兩個記憶體順序模型。
在解釋這兩個記憶體順序模型之前，有必要介紹兩個原子操作：
y.store(2, std::memory_order_release)的意思是將2原子的寫入y中，並使用memory_order_release要求記憶體順序。
tmp = y.load(std::memory_order_acquire)的意思從y中讀取值並賦值給tmp，並使用memory_order_acquire記憶體順序。
單獨的原子操作只能影響單個執行緒，無論它攜帶怎樣的記憶體順序模型，僅僅使用對單個執行緒的某個原子操作使用順序模型一般來說是沒有任何意義的，就拿這個範例來說，執行緒1的寫操作的memory_order_release表現用於保證在這個原子操作後，x=1必定是生效的，且線上程2的讀操作使用memory_order_acquire記憶體順序模型讀取到的數值一定是執行緒1儲存後的數值。這對原子操作本身和x都是一樣的。
為了更加清楚的表達它們的概念，體會它們在多執行緒程式設計中的共同作業，我將會給出另一個範例，並攜帶註釋，註釋按照[1] [2] [3]的循序觀看，請仔細閱讀，確保已經完全理解：
#include <atomic>
#include <cassert>
#include <string>
#include <thread>
std::atomic<std::string *> ptr;
int data;
void producer() {
auto *p = new std::string("Hello");
data = 42;
//store是一個寫操作，std::memory_order_release要求在這個寫指令完成後，所有的寫操作必須也是完成狀態，也就是說，
//編譯器看到這條指令後，就不能將data = 42這條指令移動到store操作之後，這便是memory_order_release對記憶體順序的要求
//memory_order_release中的release指的是將修改後（寫操作）的結果釋放出來，一旦其他執行緒使用了 memory_order_acquire,就可以觀測到
//上述對記憶體寫入的結果（release也可理解為釋放記憶體的控制權）
ptr.store(p, std::memory_order_release);//[1]
}
void consumer() {
std::string *p2;
//此處等待ptr的store操作 while保證了時間上的同步，也就是會等到ptr寫入的那一刻，memory_order_release，memory_order_acquire保證
//記憶體上的同步，也就是producer寫入的值一定會被consumer讀取到
while (!(p2 = ptr.load(std::memory_order_acquire)))//[3]
;
//如果執行到此處，說明p2是非空的，也就意味著ptr load 到了一個非空的字串，也就意味著 data = 42的指令已經執行了（memory_order_release保證），
//且此時data必定等於42 ，p2必定為「Hello」（memory_order_acquire保證）
assert(*p2 == "Hello");// 絕無問題//[2]
assert(data == 42); // 絕無問題
}
int main() {
std::thread t2(consumer);
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::thread t1(producer);
t1.join();
t2.join();
}
這些共同作業方式當然不是我杜撰的，而是在cppreference中有詳細的解釋，經過上述的例子，我們可以在從頭看看檔案中的內容了，請注意本章節存在大量摘抄文字，但是我仍然希望你能夠在理解上一章節的基礎上仔細閱讀這些文字，檔案是對概念最準確的解釋，是必須要跨越的一關：
原文： std::memory_order - cppreference.com
首先讓我們看看檔案是如何定義這些記憶體操作的：
| 值 | 解釋 |
|---|---|
| memory_order_relaxed | 寬鬆操作：沒有同步或順序制約，僅對此操作要求原子性（見下方 寬鬆順序）。 |
| memory_order_consume | 有此記憶體順序的載入操作，在其影響的記憶體位置進行_消費操作_：當前執行緒中依賴於當前載入的該值的讀或寫不能被重排到此載入前。其他釋放同一原子變數的執行緒的對資料依賴變數的寫入，為當前執行緒所可見。在大多數平臺上，這隻影響到編譯器優化（見下方 釋放消費順序）。 |
| memory_order_acquire | 有此記憶體順序的載入操作，在其影響的記憶體位置進行_獲得操作_：當前執行緒中讀或寫不能被重排到此載入前。其他釋放同一原子變數的執行緒的所有寫入，能為當前執行緒所見（見下方釋放獲得順序）。 |
| memory_order_release | 有此記憶體順序的儲存操作進行_釋放操作_：當前執行緒中的讀或寫不能被重排到此儲存後。當前執行緒的所有寫入，可見於獲得該同一原子變數的其他執行緒 釋放獲得順序），並且對該原子變數的帶依賴寫入變得對於其他消費同一原子物件的執行緒可見（見下方 釋放消費順序）。 |
| memory_order_acq_rel | 帶此記憶體順序的讀修改寫操作既是_獲得操作_又是_釋放操作_。當前執行緒的讀或寫記憶體不能被重排到此儲存前或後。所有釋放同一原子變數的執行緒的寫入可見於修改之前，而且修改可見於其他獲得同一原子變數的執行緒。 |
| memory_order_seq_cst | 有此記憶體順序的載入操作進行_獲得操作_，儲存操作進行_釋放操作_，而讀修改寫操作進行_獲得操作_和_釋放操作_，再加上存在一個單獨全序，其中所有執行緒以同一順序觀測到所有修改（見下方序列一致順序）。 |
接下來是他們之間的共同作業關係，這部分我會以自己的理解闡述它們，如果對原文感興趣請點選上方連結：
與其他執行緒沒有共同作業，僅僅保證原子性，也就是允許指令重排，僅僅保證這個原子變數的原子性。
釋放獲得順序就是我上面給的例子那樣，它規定了原子操作store with memory_order_release 時，在此程式碼行上方的記憶體讀寫操作都必須到位，而 load with memory_order_acquire 是一定可以取到 memory_order_release 所約束的那些變數的所寫入的值。
釋放消費順比釋放獲得順序要更加寬鬆，僅僅同步了原子操作本身的原子變數以及產生依賴關係的變數。
#include <thread>
#include <atomic>
#include <cassert>
#include <string>
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();
}
此程式碼不能保證data線上程中同步。
簡單來說就是拒絕一切重排，對所有執行緒可見，而獲得釋放操作只能影響相關執行緒。