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 = https://www.cnblogs.com/xdblog/archive/2023/03/13/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 =https://www.cnblogs.com/xdblog/archive/2023/03/13/= 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 = https://www.cnblogs.com/xdblog/archive/2023/03/13/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 =https://www.cnblogs.com/xdblog/archive/2023/03/13/= 42); // 可能也可能不會出錯： data 不從 ptr 攜帶依賴
}
 
int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

此代碼不能保證data在執行緒中同步，

序列一致順序 memory_order_seq_cst

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

標籤：其他

上一篇：10、const和constexpr區別

下一篇：Git 倉庫7K stars！學Java開源專案austin要多久？