雙重檢查鎖定模式(DCLP)在無鎖編程(lock-free programming)中經常被討論，直到2004年，JAVA才提供了可靠的雙重檢查鎖定實現。而在C++11之前，C++沒有提供一種該模式的可移植的可靠實現。

隨著雙重檢查鎖定模式在各語言實現上存在的缺點暴露，人們開始研究如何安全可靠地實現它。2000年，一個JAVA高性能研究小組發布了一篇聲明《雙重檢查鎖定可能導致鎖定無效》。2004年，Scott Meyers 和Andrei Alexandrescu聯合發表了一篇名為《C++實現雙重檢查鎖定存在嚴重缺陷》。這兩篇論文都是重點闡述了雙重檢查鎖定（DCLP）是什么,以及雙重檢查鎖定的意義，和當前的各語言實現存在諸多不足。

現如今，JAVA為了安全地實現雙重檢查鎖定修改了其內存模型，并引入了關鍵詞volatile。與此同時，C++構建了一個全新的內存模型和原子 操作庫（atomic），使得不同編譯器實現雙重檢查鎖定（DCLP）更為容易。為了在更早期的C\C++編譯器中實現DCLP，在C++11引入了一個 名為Mintomic的庫，在今年早些時候由我發布了。

過去的一段時間，我都著力于C++中實現DCLP的研究。

什么是雙重檢查鎖定？

如果你想在多線程編程中安全使用單件模式（Singleton），最簡單的做法是在訪問時對其加鎖，使用這種方式，假定兩個線程同時調用Singleton::getInstance方法，其中之一負責創建單件：

Singleton* Singleton::getInstance() { 
    Lock lock;      // scope-based lock, released automatically when the function returns 
    if (m_instance == NULL) { 
        m_instance = new Singleton; 
    } 
    return m_instance; 
} 

使用這種方式是可行的，但是當單件被創建之后，實際上你已經不需要再對其進行加鎖，加鎖雖然不一定導致性能低下，但是在重負載情況下，這也可能導致響應緩慢。

使用雙重檢查鎖定模式避免了在單件對象已經創建好之后進行不必要的鎖定，然而實現卻有點復雜，在Meyers-Alexandrescu的論文中也 有過闡述，文中提出了幾種存在缺陷的實現方式，并逐一解釋了為什么這樣實現存在問題。在論文的結尾的第12頁，給出了一種可靠的實現方式，實現依賴一種標 準中未規范的內存柵欄技術。

Singleton* Singleton::getInstance() { 
    Singleton* tmp = m_instance; 
    ...                     // insert memory barrier 
    if (tmp == NULL) { 
        Lock lock; 
        tmp = m_instance; 
        if (tmp == NULL) { 
            tmp = new Singleton; 
            ...             // insert memory barrier 
            m_instance = tmp; 
        } 
    } 
    return tmp; 
} 

這里，我們可以看到：如模式名稱一樣，代碼中實現了雙重校驗，在m_instance指針為NULL時，我們做了一次鎖定，這一過程在***創建該對象的線程可見。在創建線程內部構造塊中，m_instance被再一次檢查，以確保該線程僅創建了一份對象副本。

這是雙重檢查鎖定的實現，只不過在被高亮的代碼行中還缺乏了內存柵欄技術做保證，在此文寫就之際，C/C++各編譯器未對該實現進行統一，而在C++11標準中，對這種情況下的實現進行了完善和統一。

在C++11中獲取和釋放內存柵欄

在C++11中，你可以獲取和釋放內存柵欄來實現上述功能（如何獲取和釋放內存柵欄在我上一篇博文中有講述）。為了使你的代碼在C++各種實現中具 備更好的可移植性，你應該使用C++11中新增的atomic類型來包裝你的m_instance指針，這使得對m_instance的操作是一個原子操作。下面的代碼演示了如何使用內存柵欄，請注意代碼高亮部分：

std::atomic<Singleton*> Singleton::m_instance; 
std::mutex Singleton::m_mutex; 
  
Singleton* Singleton::getInstance() { 
    Singleton* tmp = m_instance.load(std::memory_order_relaxed); 
    std::atomic_thread_fence(std::memory_order_acquire);  // 編注：原作者提示注意的 
    if (tmp == nullptr) { 
        std::lock_guard<std::mutex> lock(m_mutex); 
        tmp = m_instance.load(std::memory_order_relaxed); 
        if (tmp == nullptr) { 
            tmp = new Singleton; 
            std::atomic_thread_fence(std::memory_order_release); // 編注：作者提示注意的 
            m_instance.store(tmp, std::memory_order_relaxed); 
        } 
    } 
    return tmp; 
} 

上述代碼在多核系統中仍然工作正常，這是因為內存柵欄技術在創建對象線程和使用對象線程之間建立了一種“同步-與”的關系（synchronizes-with）。Singleton::m_instance扮演了守衛變量的角色，而單件本身則作為負載內容。

而其他存在缺陷的雙重檢查鎖定實現都缺乏該機制的保障：在沒有“同步-與”關系保證的情況下，***個創建線程的寫操作，確切地說是在其構造函數中， 可以被其他線程感知，即m_instance指針能被其他線程訪問！創建單件線程中的鎖也不起作用，由于該鎖對其他線程不可見，從而導致在某些情況下，創 建對象被執行多次。

如果你想了解關于內存柵欄技術是如何可靠實現雙重檢查鎖定的內部原理，在我的前一篇文章中有一些背景信息（previous post），之前的博客也有一些相關內容。

#p#

使用Mintomic 內存柵欄

Mintomic是一個很小的c庫，提供了C++11 atomic庫中的一些功能函數子集，包含獲取和釋放內存柵欄，同時它能工作在早期的編譯器之上。Mintomic依賴于與C++11相似的內存模型—— 確切地說是不使用Out-of-thin-air存儲——這一技術在早期編譯器中未進行實現，而這是在沒有C++11標準情況下我們能做的***實現。以我 多年C++多線程開發的經驗看來，Out-of-thin-air存儲并不流行，而且大多數編譯器會避免實現它。

下面的代碼演示了如何使用Mintomic的獲取和釋放內存柵欄機制實現雙重檢查鎖定，基本上與上面的例子類似：

mint_atomicPtr_t Singleton::m_instance = { 0 }; 
mint_mutex_t Singleton::m_mutex; 
  
Singleton* Singleton::getInstance() { 
    Singleton* tmp = (Singleton*) mint_load_ptr_relaxed(&m_instance); 
    mint_thread_fence_acquire(); 
    if (tmp == NULL) { 
        mint_mutex_lock(&m_mutex); 
        tmp = (Singleton*) mint_load_ptr_relaxed(&m_instance); 
        if (tmp == NULL) { 
            tmp = new Singleton; 
            mint_thread_fence_release(); 
            mint_store_ptr_relaxed(&m_instance, tmp); 
        } 
        mint_mutex_unlock(&m_mutex); 
    } 
    return tmp; 
} 

為了實現獲取和釋放內存柵欄，Mintomic會試圖在其支持的編譯器平臺產生***效的機器碼。例如，下面的匯編代碼來自Xbox 360，使用的是PowerPC處理器。在該平臺上，內聯的lwsync關鍵字是針對獲取和釋放內存柵欄的優化指令。

上述采用C++11標準庫編譯的例子在PowerPC處理器編譯應該會產生一樣的匯編代碼（理想情況下）。不過，我沒有能夠在PowerPC下編譯C++11來驗證這一點。

使用C++11低階指令順序約束

在C++11中使用內存柵欄鎖定技術可以很方便地實現雙重檢查鎖定。同時也保證在現今流行的多核系統中產生優化的機器碼（Mintomic也能做到 這一點）。不過使用這種方式并不是常用，在C++11中更好的實現方式是使用保證低階指令執行順序約束的原子操作。之前的圖片中可以看到，一個寫-釋放操 作可以與一個獲取-讀操作同步：

std::atomic<Singleton*> Singleton::m_instance; 
std::mutex Singleton::m_mutex; 
  
Singleton* Singleton::getInstance() { 
    Singleton* tmp = m_instance.load(std::memory_order_acquire); 
    if (tmp == nullptr) { 
        std::lock_guard<std::mutex> lock(m_mutex); 
        tmp = m_instance.load(std::memory_order_relaxed); 
        if (tmp == nullptr) { 
            tmp = new Singleton; 
            m_instance.store(tmp, std::memory_order_release); 
        } 
    } 
    return tmp; 
} 

從技術上講，使用這種形式的無鎖同步比獨立內存柵欄技術限制更低。上述操作只是為了防止自身操作的內存排序，而內存柵欄技術則阻止了臨近操作的內存 排序。盡管如此,現今的x86/64,ARMv6 / v7,和PowerPC處理器架構，針對這兩種形式產生的機器碼應該是一致的。在我之前的博文中，我展示了C++11低階指令順序約束在ARM7中使用了 dmb指令，這和使用內存柵欄技術產生的匯編代碼相一致。

上述兩種方式在Itanium平臺可能產生不一樣的機器碼，在Itanium平臺上，C++11標準中的 load(memory_order_acquire)可以用單CPU指令：ld.acq，而store(tmp, memory_order_release)使用st.rel就可以實現。

在ARMv8處理器架構中，也提供了和Itanium指令等價的ldar 和 stlr 指令，而不同的地方是：這些指令還會導致stlr和后續ldar之間進一級的存儲裝載指令進行排序。實際上，ARMv8的新指令試圖實現C++11標準中 的順序約束原子操作，這會在后面進一步講述。

使用C++順序一致的原子操作

C++11標準提供了一個不同的方式來編寫無鎖程序（可以把雙重檢查鎖定歸類為無鎖編程的一種，因為不是所有線程都會獲取鎖）。在所有原子操作庫方 法中使用可選參數std::memory_order可以使得所有原子變量變為順序的原子操作（sequentially consistent），方法的默認參數為std::memory_order_seq_cst。使用順序約束（SC）原子操作庫，整個函數執行都將保證 順序執行，并且不會出現數據競態（data races）。順序約束（SC）原子操作和JAVA5版本之后出現的volatile變量很相似。

使用SC原子操作實現雙重檢查鎖定的代碼如下：和前面的例子一樣，高亮的第二行會與***次創建單件的線程進行同步與操作。

std::atomic<Singleton*> Singleton::m_instance; 
std::mutex Singleton::m_mutex; 
  
Singleton* Singleton::getInstance() { 
    Singleton* tmp = m_instance.load(); 
    if (tmp == nullptr) { 
        std::lock_guard<std::mutex> lock(m_mutex); 
        tmp = m_instance.load(); 
        if (tmp == nullptr) { 
            tmp = new Singleton; 
            m_instance.store(tmp); 
        } 
    } 
    return tmp; 
} 

順序約束（SC）原子操作使得開發者更容易預測代碼執行結果，不足之處在于使用順序約束（SC）原子操作類庫的代碼效率要比之前的例子低一些。例如，在x64位機器上，上述代碼使用Clang3.3優化后產生如下匯編代碼：

由于使用了順序約束（SC）原子操作類庫，變量m_instance的存儲操作使用了xchg指令，在x64處理器上相當于一個內存柵欄操作。該指 令在x64位處理器是一個長周期指令，使用輕量級的mov指令也可以完成操作。不過，這影響不大，因為xchg指令只被單件創建過程調用一次。

不過，在PowerPC or ARMv6/v7處理器上編譯上述代碼，產生的匯編操作要糟糕得多，具體情形可以參見Herb Sutter的演講（atomic Weapons talk, part 2.00:44:25 – 00:49:16）。

#p#

使用C++11數據順序依賴原理

上面的例子都是使用了創建單件線程和使用單件其他線程之間的同步與關系。守衛的是數據指針單個元素，開銷也是創建單件內容本身。這里，我將演示一種使用數據依賴來保護防衛的指針。

在使用數據依賴時候，上述例子中都使用了一個讀-獲取操作，這也會產生性能消耗，我們可以使用消費指令來進一步優化。消費指令（consume instruction）非常酷，在PowerPc處理器上它使用了lwsync指令，在ARMv7處理器上則編譯為dmd指令。今后我會寫一些文章來講 述消費指令和數據依賴機制。

使用C++11靜態初始化

一些讀者可能已經知道C++11中，你可以跳過之前的檢查過程而直接得到線程安全的單件。你只需要使用一個靜態初始化：

C++11標準在6.7.4節中規定：

如果指令邏輯進入一個未被初始化的聲明變量，所有并發執行應當等待完成該變量完成初始化。

上述操作在編譯時由編譯器保證。雙重檢查鎖定則可以利用這一點。編譯器并不保證會使用雙重檢查鎖定，但是大部分編譯器會這樣做。gcc4.6使用-std=c++0x編譯選項在ARM處理器產生的匯編代碼如下：

由于單件使用的是一個固定地址，編譯器會使用一個特殊的防衛變量來完成同步。請注意這里，在初始化變量讀操作時沒有使用dmb指令來獲取一個內存柵 欄。守衛變量指向了單件，因此編譯器可以使用數據依賴原則來避免使用dmb指令的開銷。__cxa_guard_release指令扮演了一個寫-釋放來 解除變量守衛。一旦守衛柵欄被設置，這里存在一個指令順序強制在讀-消費操作之前。這里和前面的例子一樣，對內存排序的進行適應性的變更。

前面的長篇累牘主要講述了C++11標準修復了雙層檢查鎖定實現，并且講述了其他一些相關知識。

就我個人而言，我認為應當在程序初始化時就初始化一個singleton。使用雙重檢查鎖定可以幫你將任意數據類型存儲在一個無鎖的哈希表中。這會在后續的文章進一步闡述。

原文鏈接：http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/

譯文鏈接：http://blog.jobbole.com/52164/