c++ 記憶體順序

搞懂無鎖編程的重要一步是完全理解記憶體順序！

本教程由作者和ChatGPT通力合作完成。

都有哪幾種？

c++的記憶體模型共有6種

• memory_order_relaxed
• memory_order_consume
• memory_order_acquire
• memory_order_release
• memory_order_acq_rel
• memory_order_seq_cst

萬事開頭難，如何入手？

如果你有幸閱讀過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++代碼的順序不一致（處理器也會對指令進行重排）。

這種重排可以分為三種類型：

1. 編譯器重排：編譯器在生成目標代碼時，可能會重新排列原本在c++源代碼中出現的語句，以優化代碼執行速度。
2. 處理器重排：處理器會通過亂序執行、流水線等技術來優化指令執行的速度。
3. 記憶體系統重排：記憶體系統也會對指令進行重排，以最小化記憶體訪問延遲。

指令重排其實是一種優化手段，但它的出現也為多線程編程帶來了麻煩，下麵的例子展示了指令重排是如何影響多線程編程的：

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兩個記憶體順序模型。

在解釋這兩個記憶體順序模型之前，有必要介紹兩個原子操作：

• store ：寫操作，第一個參數為要寫入的數值，第二個參數可以設置記憶體順序模型
• load：讀操作，返回讀到的值，參數為記憶體順序模型

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();
}

這些協作關係是你的經驗總結還是C++預定義的？

這些協作方式當然不是我杜撰的，而是在cppreference中有詳細的解釋，經過上述的例子，我們可以在從頭看看文檔中的內容了，請註意本章節存在大量摘抄文本，但是我仍然希望你能夠在理解上一章節的基礎上仔細閱讀這些文本，文檔是對概念最準確的解釋，是必須要跨越的一關：

原文： std::memory_order - cppreference.com

首先讓我們看看文檔是如何定義這些記憶體操作的：

接下來是他們之間的協作關係，這部分我會以自己的理解闡述它們，如果對原文感興趣請點擊上方鏈接：

寬鬆順序：memory_order_relaxed

與其他線程沒有協作，僅僅保證原子性，也就是允許指令重排，僅僅保證這個原子變數的原子性。

釋放獲得順序 memory_order_release memory_order_acquire

釋放獲得順序就是我上面給的例子那樣，它規定了原子操作store with memory_order_release 時，在此代碼行上方的記憶體讀寫操作都必須到位，而 load with memory_order_acquire 是一定可以取到 memory_order_release 所約束的那些變數的所寫入的值。

釋放消費順序 memory_order_release memory_order_consume

釋放消費順比釋放獲得順序要更加寬鬆，僅僅同步了原子操作本身的原子變數以及產生依賴關係的變數。

#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線上程中同步。

序列一致順序 memory_order_seq_cst

簡單來說就是拒絕一切重排，對所有線程可見，而獲得釋放操作只能影響相關線程。