C++11 并發指南六(atomic 類型詳解一 atomic_flag 介紹) 一文介紹了 C++11 中最簡單的原子類型 std::atomic_flag，但是 std::atomic_flag 過于簡單，隻提供了 test_and_set 和 clear 兩個 API，不能滿足其他需求(如 store, load, exchange, compare_exchange 等)，是以本文将介紹功能更加完善的 std::atomic 類。
std::atomic 基本介紹
std::atomic 是模闆類，一個模闆類型為 T 的原子對象中封裝了一個類型為 T 的值。
template <class T> struct atomic; 原子類型對象的主要特點就是從不同線程通路不會導緻資料競争(data race)。是以從不同線程通路某個原子對象是良性 (well-defined) 行為，而通常對于非原子類型而言，并發通路某個對象（如果不做任何同步操作）會導緻未定義 (undifined) 行為發生。
C++11 标準中的基本 std::atomic 模闆定義如下：
template < class T > struct atomic {
bool is_lock_free() const volatile;
bool is_lock_free() const;
void store(T, memory_order = memory_order_seq_cst) volatile;
void store(T, memory_order = memory_order_seq_cst);
T load(memory_order = memory_order_seq_cst) const volatile;
T load(memory_order = memory_order_seq_cst) const;
operator T() const volatile;
operator T() const;
T exchange(T, memory_order = memory_order_seq_cst) volatile;
T exchange(T, memory_order = memory_order_seq_cst);
bool compare_exchange_weak(T &, T, memory_order, memory_order) volatile;
bool compare_exchange_weak(T &, T, memory_order, memory_order);
bool compare_exchange_strong(T &, T, memory_order, memory_order) volatile;
bool compare_exchange_strong(T &, T, memory_order, memory_order);
bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst);
bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst) volatile;
bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst);
atomic() = default;
constexpr atomic(T);
atomic(const atomic &) = delete;
atomic & operator=(const atomic &) = delete;
atomic & operator=(const atomic &) volatile = delete;
T operator=(T) volatile;
T operator=(T);
}; 另外，C++11 标準庫 std::atomic 提供了針對整形(integral)和指針類型的特化實作，分别定義如下：
針對整形(integal)的特化，其中 integal 代表了如下類型char, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, char16_t, char32_t, wchar_t：
?
|
針對指針的特化：
?
|
std::atomic 成員函數
好了，對 std::atomic 有了一個最基本認識之後我們來看 std::atomic 的成員函數吧。
std::atomic 構造函數
std::atomic 的構造函數如下：
| default (1) | |
|---|---|
| initialization (2) | |
| copy [deleted] (3) | |
- 預設構造函數，由預設構造函數建立的 std::atomic 對象處于未初始化(uninitialized)狀态，對處于未初始化(uninitialized)狀态 std::atomic對象可以由 atomic_init 函數進行初始化。
- 初始化構造函數，由類型 T初始化一個 std::atomic對象。
- 拷貝構造函數被禁用。
請看下例：
?
|
std::atomic::operator=() 函數
std::atomic 的指派操作函數定義如下：
| set value (1) | |
|---|---|
| copy [deleted] (2) | |
可以看出，普通的指派拷貝操作已經被禁用。但是一個類型為 T 的變量可以指派給相應的原子類型變量（相當與隐式轉換），該操作是原子的，記憶體序(Memory Order) 預設為順序一緻性(std::memory_order_seq_cst)，如果需要指定其他的記憶體序，需使用 std::atomic::store()。
?
|
基本 std::atomic 類型操作
本節主要介紹基本 std::atomic 類型所具備的操作（即成員函數）。我們知道 std::atomic 是模闆類，一個模闆類型為 T 的原子對象中封裝了一個類型為 T 的值。本文<std::atomic 基本介紹>一節中也提到了 std::atomic 類模闆除了基本類型以外，還針對整形和指針類型做了特化。 特化的 std::atomic 類型支援更多的操作，如 fetch_add, fetch_sub, fetch_and 等。本小節介紹基本 std::atomic 類型所具備的操作：
- is_lock_free
?
|
- 判斷該 std::atomic 對象是否具備 lock-free 的特性。如果某個對象滿足 lock-free 特性，在多個線程通路該對象時不會導緻線程阻塞。(可能使用某種事務記憶體 transactional memory方法實作 lock-free 的特性)。
- store
?
|
- 修改被封裝的值，std::atomic::store 函數将類型為 T 的參數 val 複制給原子對象所封裝的值。T 是 std::atomic 類模闆參數。另外參數 sync 指定記憶體序(Memory Order)，可能的取值如下：
| Memory Order 值 | Memory Order 類型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_release | Release |
| memory_order_seq_cst | Sequentially consistent |
- 請看下面例子：
?
|
- load
?
|
- 讀取被封裝的值，參數 sync 設定記憶體序(Memory Order)，可能的取值如下：
| Memory Order 值 | Memory Order 類型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_seq_cst | Sequentially consistent |
- 請看下面例子：
?
|
- operator T
?
|
- 與 load 功能類似，也是 讀取被封裝的值，operator T() 是類型轉換( type-cast) 操作，預設的記憶體序是 std::memory_order_seq_cst，如果需要指定其他的記憶體序，你應該使用 load() 函數。請看下面例子：
?
|
- exchange
T exchange (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T exchange (T val, memory_order sync = memory_order_seq_cst) noexcept; - 讀取并修改被封裝的值，exchange 會将 val 指定的值替換掉之前該原子對象封裝的值，并傳回之前該原子對象封裝的值，整個過程是原子的(是以exchange 操作也稱為 read-modify-write 操作)。sync參數指定記憶體序(Memory Order)，可能的取值如下：
| Memory Order 值 | Memory Order 類型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_release | Release |
| memory_order_acq_rel | Acquire/Release |
| memory_order_seq_cst | Sequentially consistent |
請看下面例子，各個線程計數至 1M，首先完成計數任務的線程列印自己的 ID，
?
|
- compare_exchange_weak
| (1) | |
|---|---|
| (2) | |
- 比較并交換被封裝的值(weak)與參數 expected 所指定的值是否相等，如果：
- 相等，則用 val 替換原子對象的舊值。
- 不相等，則用原子對象的舊值替換 expected ，是以調用該函數之後，如果被該原子對象封裝的值與參數 expected 所指定的值不相等，expected 中的内容就是原子對象的舊值。
該函數通常會讀取原子對象封裝的值，如果比較為 true(即原子對象的值等于 expected)，則替換原子對象的舊值，但整個操作是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。
在第 (2)種情況下，記憶體序（Memory Order）的選擇取決于比較操作結果，如果比較結果為 true(即原子對象的值等于 expected)，則選擇參數 success 指定的記憶體序，否則選擇參數 failure 所指定的記憶體序。
注意，該函數直接比較原子對象所封裝的值與參數 expected 的實體内容，是以某些情況下，對象的比較操作在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，因為對象底層的實體内容中可能存在位對齊或其他邏輯表示相同但是實體表示不同的值(比如 true 和 2 或 3，它們在邏輯上都表示"真"，但在實體上兩者的表示并不相同)。
與 compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允許( spuriously 地)傳回 false(即原子對象所封裝的值與參數 expected 的實體内容相同，但卻仍然傳回 false)，不過在某些需要循環操作的算法下這是可以接受的，并且在一些平台下 compare_exchange_weak 的性能更好 。如果 compare_exchange_weak 的判斷确實發生了僞失敗( spurious failures)——即使原子對象所封裝的值與參數 expected 的實體内容相同，但判斷操作的結果卻為 false，compare_exchange_weak函數傳回 false，并且參數
expected 的值不會改變。
對于某些不需要采用循環操作的算法而言, 通常采用 compare_exchange_strong 更好。另外，該函數的記憶體序由 sync 參數指定，可選條件如下：
| Memory Order 值 | Memory Order 類型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_release | Release |
| memory_order_acq_rel | Acquire/Release |
| memory_order_seq_cst | Sequentially consistent |
- 請看下面的例子（ 參考）：
?
|
- 可能的執行結果如下：
?
|
- compare_exchange_strong
| (1) | |
|---|---|
| (2) | |
- 比較并交換被封裝的值(strong)與參數 expected 所指定的值是否相等，如果：
- 相等，則用 val 替換原子對象的舊值。
- 不相等，則用原子對象的舊值替換 expected ，是以調用該函數之後，如果被該原子對象封裝的值與參數 expected 所指定的值不相等，expected 中的内容就是原子對象的舊值。
該函數通常會讀取原子對象封裝的值，如果比較為 true(即原子對象的值等于 expected)，則替換原子對象的舊值，但整個操作是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。
在第 (2)種情況下，記憶體序（Memory Order）的選擇取決于比較操作結果，如果比較結果為 true(即原子對象的值等于 expected)，則選擇參數 success 指定的記憶體序，否則選擇參數 failure 所指定的記憶體序。
注意，該函數直接比較原子對象所封裝的值與參數 expected 的實體内容，是以某些情況下，對象的比較操作在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，因為對象底層的實體内容中可能存在位對齊或其他邏輯表示相同但是實體表示不同的值(比如 true 和 2 或 3，它們在邏輯上都表示"真"，但在實體上兩者的表示并不相同)。
與 compare_exchange_weak 不同, strong版本的 compare-and-exchange 操作不允許( spuriously 地)傳回 false，即原子對象所封裝的值與參數 expected 的實體内容相同，比較操作一定會為 true。不過在某些平台下，如果算法本身需要循環操作來做檢查， compare_exchange_weak 的性能會更好。
是以對于某些不需要采用循環操作的算法而言, 通常采用 compare_exchange_strong 更好。另外，該函數的記憶體序由 sync 參數指定，可選條件如下：
| Memory Order 值 | Memory Order 類型 |
|---|---|
| memory_order_relaxed | Relaxed |
| memory_order_consume | Consume |
| memory_order_acquire | Acquire |
| memory_order_release | Release |
| memory_order_acq_rel | Acquire/Release |
| memory_order_seq_cst | Sequentially consistent |
- 請看下面的例子：
?
|
好了，本文花了大量的篇幅介紹 std::atomic 基本類型，下一篇部落格我會給大家介紹 C++11 的标準庫中std::atomic 針對整形(integral)和指針類型的特化版本做了哪些改進。
![C++11之前和C++11之後的 vector 構造函數的差別[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)