C++11 併發指南六(atomic 類型詳解四 C 風格原子操做介紹)

前面三篇文章《C++11 併發指南六(atomic 類型詳解一 atomic_flag 介紹)》、《C++11 併發指南六( <atomic> 類型詳解二 std::atomic )》、《C++11 併發指南六(atomic 類型詳解三 std::atomic (續))》都是採用 C++ 的方式介紹原子對象，本節我會給你們介紹 C++11 原子操做中 C 風格的 API。

總地來講，C++11 標準中規定了兩大類原子對象，std::atomic_flag 和 std::atomic，前者 std::atomic_flag 一種最簡單的原子布爾類型，只支持兩種操做，test-and-set 和 clear。而 std::atomic 是模板類，一個模板類型爲 T 的原子對象中封裝了一個類型爲 T 的值，而且C++11 標準中除了定義基本 std::atomic 模板類型外，還提供了針對整形(integral)和指針類型的特化實現，提供了大量的 API，極大地方便了開發者使用。下面我分別介紹基於 std::atomic_flag 和 std::atomic 的 C 風格 API。

基於 std::atomic_flag 類型的 C 風格 API

atomic_flag_test_and_set

bool atomic_flag_test_and_set (volatile atomic_flag* obj) noexcept;
bool atomic_flag_test_and_set (atomic_flag* obj) noexcept;

檢測並設置 std::atomic_flag 的值，並返回 std::atomic_flag 的舊值，和 std::atomic::test_and_set() 成員函數的功能相同，整個過程也是原子的，默認的內存序爲 memory_order_seq_cst。

atomic_flag_test_and_set_explicit

bool atomic_flag_test_and_set (volatile atomic_flag* obj, memory_order sync) noexcept;
bool atomic_flag_test_and_set (atomic_flag* obj, memory_order sync) noexcept;

檢測並設置 std::atomic_flag 的值，並返回 std::atomic_flag 的舊值，和 std::atomic::test_and_set() 成員函數的功能相同，整個過程也是原子的。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

atomic_flag_clear

void atomic_flag_clear (volatile atomic_flag* obj) noexcept;
void atomic_flag_clear (atomic_flag* obj) noexcept;

清除 std::atomic_flag 對象，並設置它的值爲 false，和 std::atomic::clear() 成員函數的功能相同，整個過程也是原子的，默認的內存序爲 memory_order_seq_cst。

atomic_flag_clear_explicit

void atomic_flag_clear (volatile atomic_flag* obj, memory_order sync) noexcept;
void atomic_flag_clear (atomic_flag* obj, memory_order sync) noexcept;

清除 std::atomic_flag 對象，並設置它的值爲 false，和 std::atomic::clear() 成員函數的功能相同，整個過程也是原子的，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

基於 std::atomic 模板類型的 C 風格 API

atomic_is_lock_free

template (1)	template <class T> bool atomic_is_lock_free (const volatile atomic<T>* obj) noexcept; template <class T> bool atomic_is_lock_free (const atomic<T>* obj) noexcept;
overloads (2)	bool atomic_is_lock_free (const volatile A* obj) noexcept; bool atomic_is_lock_free (const A* obj) noexcept;

判斷該 std::atomic 對象是否具有 lock-free 的特性。若是某個對象知足 lock-free 特性，在多個線程訪問該對象時不會致使線程阻塞。(可能使用某種事務內存 transactional memory 方法實現 lock-free 的特性) 。

atomic_init

template (1)	template <class T> void atomic_init (volatile atomic<T>* obj, T val) noexcept; template <class T> void atomic_init (atomic<T>* obj, T val) noexcept;
overloads (2)	void atomic_init (volatile A* obj, T val) noexcept; void atomic_init (A* obj, T val) noexcept;

初始化原子對象。 val 指定原子對象的初始值。若是對一個已初始化的原子對象再次調用 atomic_init()，則會致使未定義行爲(undefined behavior)，若是你想修改原子對象的值，應該使用 std::atomic_store();

atomic_store

template (1)	template <class T> void atomic_store (volatile atomic<T>* obj, T val) noexcept; template <class T> void atomic_store (atomic<T>* obj, T val) noexcept;
overloads (2)	void atomic_store (volatile A* obj, T val) noexcept; void atomic_store (A* obj, T val) noexcept;

修改原子對象的值，默認的內存序爲memory_order_seq_cst。該函數至關於 std::atomic 對象的 store 或者operator=() 成員函數，若是你須要顯式指定內存序，應該使用atomic_store_explicit。

atomic_store_explicit

修改原子對象的值。該函數至關於 std::atomic 對象的 store 或者operator=() 成員函數 ，sync 指定了內存序，可取的參數爲：

Memory Order 值	Memory Order 類型
memory_order_relaxed	Relaxed
memory_order_release	Release
memory_order_seq_cst	Sequentially consistent

atomic_load

template (1)	template <class T> T atomic_load (const volatile atomic<T>* obj) noexcept; template <class T> T atomic_load (const atomic<T>* obj) noexcept;
overloads (2)	T atomic_load (const volatile A* obj) noexcept; T atomic_load (const A* obj) noexcept;

讀取被封裝的值， 默認的內存序爲memory_order_seq_cst。該函數與 std::atomic 對象的atomic::load()和atomic::operator T() 成員函數等價。

atomic_load_explicit

template (1)	template <class T> T atomic_load_explicit (const volatile atomic<T>* obj, memory_order sync) noexcept; template <class T> T atomic_load_explicit (const atomic<T>* obj, memory_order sync) noexcept;
overloads (2)	T atomic_load_explicit (const volatile A* obj, memory_order sync) noexcept; T atomic_load_explicit (const A* obj, memory_order sync) noexcept;

讀取被封裝的值，參數 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

該函數與 std::atomic 對象的atomic::load() 成員函數等價。

atomic_exchange

template (1)	template <class T> T atomic_exchange (volatile atomic<T>* obj, T val) noexcept; template <class T> T atomic_exchange (atomic<T>* obj, T val) noexcept;
overloads (2)	T atomic_exchange (volatile A* obj, T val) noexcept; T atomic_exchange (A* obj, T val) noexcept;

讀取並修改被封裝的值，exchange 會將 val 指定的值替換掉以前該原子對象封裝的值，並返回以前該原子對象封裝的值，整個過程是原子的(所以exchange 操做也稱爲 read-modify-write 操做)。 該函數與 std::atomic 對象的atomic::exchange() 成員函數等價。

atomic_exchange_explicit

template (1)	template <class T> T atomic_store_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept; template <class T> T atomic_store_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
overloads (2)	T atomic_store_explicit (volatile A* obj, T val, memory_order sync) noexcept; T atomic_store_explicit (A* obj, T val, memory_order sync) 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

atomic_compare_exchange_weak

template (1)	template <class T> bool atomic_compare_exchange_weak (volatile atomic<T>* obj, T* expected, T val) noexcept; template <class T> bool atomic_compare_exchange_weak (atomic<T>* obj, T* expected, T val) noexcept;
overloads (2)	bool atomic_compare_exchange_weak (volatile A* obj, T* expected, T val) noexcept; bool atomic_compare_exchange_weak (A* obj, T* expected, T val) noexcept;

比較並交換被封裝的值(weak)與參數  expected 所指定的值是否相等，若是：

• 相等，則用 val 替換原子對象的舊值。
• 不相等，則用原子對象的舊值替換 expected ，所以調用該函數以後，若是被該原子對象封裝的值與參數 expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。

該函數一般會讀取原子對象封裝的值，若是比較爲 true(即原子對象的值等於 expected)，則替換原子對象的舊值，但整個操做是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。

注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，因此某些狀況下，對象的比較操做在使用 operator==() 判斷時相等，但 atomic_compare_exchange_weak 判斷時卻可能失敗，由於對象底層的物理內容中可能存在位對齊或其餘邏輯表示相同可是物理表示不一樣的值(好比 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上二者的表示並不相同)。

與 atomic_compare_exchange_strong 不一樣, weak 版本的 compare-and-exchange 操做容許( spuriously 地)返回 false(即原子對象所封裝的值與參數 expected 的物理內容相同，但卻仍然返回 false)，不過在某些須要循環操做的算法下這是能夠接受的，而且在一些平臺下 compare_exchange_weak 的性能更好 。若是 atomic_compare_exchange_weak 的判斷確實發生了僞失敗( spurious failures)——即便原子對象所封裝的值與參數 expected 的物理內容相同，但判斷操做的結果卻爲 false，atomic_compare_exchange_weak 函數返回 false，而且參數 expected 的值不會改變。

atomic_compare_exchange_weak_explicit

template (1)	template <class T> bool atomic_compare_exchange_weak_explicit (volatile atomic<T>* obj, T* expected, T val, memory_order success, memory_order failure) noexcept; template <class T> bool atomic_compare_exchange_weak_explicit (atomic<T>* obj, T* expected, T val, memory_order success, memory_order failure) noexcept;
overloads (2)	bool atomic_compare_exchange_weak_explicit (volatile A* obj, T* expected, T val, memory_order success, memory_order failure) noexcept; bool atomic_compare_exchange_weak_explicit (A* obj, T* expected, T val, memory_order success, memory_order failure) noexcept;

比較並交換被封裝的值(weak)與參數  expected 所指定的值是否相等，若是：

• 相等，則用 val 替換原子對象的舊值。
• 不相等，則用原子對象的舊值替換 expected ，所以調用該函數以後，若是被該原子對象封裝的值與參數 expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。

該函數一般會讀取原子對象封裝的值，若是比較爲 true(即原子對象的值等於 expected)，則替換原子對象的舊值，但整個操做是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。

內存序（Memory Order）的選擇取決於比較操做結果，若是比較結果爲 true(即原子對象的值等於 expected)，則選擇參數 success 指定的內存序，不然選擇參數 failure 所指定的內存序。

注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，因此某些狀況下，對象的比較操做在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，由於對象底層的物理內容中可能存在位對齊或其餘邏輯表示相同可是物理表示不一樣的值(好比 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上二者的表示並不相同)。

與 atomic_compare_exchange_strong 不一樣, weak 版本的 compare-and-exchange 操做容許( spuriously 地)返回 false(即原子對象所封裝的值與參數 expected 的物理內容相同，但卻仍然返回 false)，不過在某些須要循環操做的算法下這是能夠接受的，而且在一些平臺下 compare_exchange_weak 的性能更好 。若是 atomic_compare_exchange_weak 的判斷確實發生了僞失敗( spurious failures)——即便原子對象所封裝的值與參數 expected 的物理內容相同，但判斷操做的結果卻爲 false，atomic_compare_exchange_weak函數返回 false，而且參數 expected 的值不會改變。

對於某些不須要採用循環操做的算法而言, 一般採用 atomic_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

atomic_compare_exchange_strong

template (1)	template <class T> bool atomic_compare_exchange_strong (volatile atomic<T>* obj, T* expected, T val) noexcept; template <class T> bool atomic_compare_exchange_strong (atomic<T>* obj, T* expected, T val) noexcept;
overloads (2)	bool atomic_compare_exchange_strong (volatile A* obj, T* expected, T val) noexcept; bool atomic_compare_exchange_strong (A* obj, T* expected, T val) noexcept;

比較並交換被封裝的值(strong)與參數  expected 所指定的值是否相等，若是：

• 相等，則用 val 替換原子對象的舊值。
• 不相等，則用原子對象的舊值替換 expected ，所以調用該函數以後，若是被該原子對象封裝的值與參數 expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。

該函數一般會讀取原子對象封裝的值，若是比較爲 true(即原子對象的值等於 expected)，則替換原子對象的舊值，但整個操做是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。

注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，因此某些狀況下，對象的比較操做在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，由於對象底層的物理內容中可能存在位對齊或其餘邏輯表示相同可是物理表示不一樣的值(好比 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上二者的表示並不相同)。

與 atomic_ compare_exchange_weak 不一樣, strong版本的 compare-and-exchange 操做不容許( spuriously 地)返回 false，即原子對象所封裝的值與參數 expected 的物理內容相同，比較操做必定會爲 true。不過在某些平臺下，若是算法自己須要循環操做來作檢查， atomic_compare_exchange_weak 的性能會更好。

所以對於某些不須要採用循環操做的算法而言, 一般採用 atomic_ compare_exchange_strong 更好。

atomic_compare_exchange_strong_explicit

template (1)	template <class T> bool atomic_compare_exchange_strong_explicit (volatile atomic<T>* obj, T* expected, T val, memory_order success, memory_order failure) noexcept; template <class T> bool atomic_compare_exchange_strong_explicit (atomic<T>* obj, T* expected, T val, memory_order success, memory_order failure) noexcept;
overloads (2)	bool atomic_compare_exchange_strong_explicit (volatile A* obj, T* expected, T val, memory_order success, memory_order failure) noexcept; bool atomic_compare_exchange_strong_explicit (A* obj, T* expected, T val, memory_order success, memory_order failure) noexcept;

比較並交換被封裝的值(strong)與參數  expected 所指定的值是否相等，若是：

• 相等，則用 val 替換原子對象的舊值。
• 不相等，則用原子對象的舊值替換 expected ，所以調用該函數以後，若是被該原子對象封裝的值與參數 expected 所指定的值不相等，expected 中的內容就是原子對象的舊值。

該函數一般會讀取原子對象封裝的值，若是比較爲 true(即原子對象的值等於 expected)，則替換原子對象的舊值，但整個操做是原子的，在某個線程讀取和修改該原子對象時，另外的線程不能對讀取和修改該原子對象。

內存序（Memory Order）的選擇取決於比較操做結果，若是比較結果爲 true(即原子對象的值等於 expected)，則選擇參數 success 指定的內存序，不然選擇參數 failure 所指定的內存序。

注意，該函數直接比較原子對象所封裝的值與參數 expected 的物理內容，因此某些狀況下，對象的比較操做在使用 operator==() 判斷時相等，但 compare_exchange_weak 判斷時卻可能失敗，由於對象底層的物理內容中可能存在位對齊或其餘邏輯表示相同可是物理表示不一樣的值(好比 true 和 2 或 3，它們在邏輯上都表示"真"，但在物理上二者的表示並不相同)。

與atomic_ compare_exchange_weak 不一樣, strong版本的 compare-and-exchange 操做不容許( spuriously 地)返回 false，即原子對象所封裝的值與參數 expected 的物理內容相同，比較操做必定會爲 true。不過在某些平臺下，若是算法自己須要循環操做來作檢查， atomic_compare_exchange_weak 的性能會更好。

所以對於某些不須要採用循環操做的算法而言, 一般採用 atomic_ 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

atomic_fetch_add

template (integral) (1)	template <class T> T atomic_fetch_add (volatile atomic<T>* obj, T val) noexcept; template <class T> T atomic_fetch_add (atomic<T>* obj, T val) noexcept;
template (pointer) (2)	template <class U> U* atomic_fetch_add (volatile atomic<U*>* obj, ptrdiff_t val) noexcept; template <class U> U* atomic_fetch_add (atomic<U*>* obj, ptrdiff_t val) noexcept;
overloads (3)	T atomic_fetch_add (volatile A* obj, M val) noexcept; T atomic_fetch_add (A* obj, M val) noexcept;

將原子對象的封裝值加 val，並返回原子對象的舊值（適用於整形和指針類型的 std::atomic 特化版本），整個過程是原子的。該函數默認內存序爲 memory_order_seq_cst。

該函數等價於 std::atomic 對象的atomic::fetch_add和 atomic::operator+= 成員函數。

atomic_fetch_add_explicit

template (integral) (1)	template <class T> T atomic_fetch_add_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept; template <class T> T atomic_fetch_add_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
template (pointer) (2)	template <class U> U* atomic_fetch_add_explicit (volatile atomic<U*>* obj, ptrdiff_t val, memory_order sync) noexcept; template <class U> U* atomic_fetch_add_explicit (atomic<U*>* obj, ptrdiff_t val, memory_order sync) noexcept;
overloads (3)	T atomic_fetch_add_explicit (volatile A* obj, M val, memory_order sync) noexcept; T atomic_fetch_add_explicit (A* obj, M val, memory_order sync) noexcept;

將原子對象的封裝值加 val，並返回原子對象的舊值（適用於整形和指針類型的 std::atomic 特化版本），整個過程是原子的。

該函數等價於 std::atomic 對象的atomic::fetch_add成員函數。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

atomic_fetch_sub

template (integral) (1)	template <class T> T atomic_fetch_sub (volatile atomic<T>* obj, T val) noexcept; template <class T> T atomic_fetch_sub (atomic<T>* obj, T val) noexcept;
template (pointer) (2)	template <class U> U* atomic_fetch_sub (volatile atomic<U*>* obj, ptrdiff_t val) noexcept; template <class U> U* atomic_fetch_sub (atomic<U*>* obj, ptrdiff_t val) noexcept;
overloads (3)	T atomic_fetch_sub (volatile A* obj, M val) noexcept; T atomic_fetch_sub (A* obj, M val) noexcept;

將原子對象的封裝值減 val，並返回原子對象的舊值（適用於整形和指針類型的 std::atomic 特化版本），整個過程是原子的。

atomic_fetch_sub_explicit

template (integral) (1)	template <class T> T atomic_fetch_sub_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept; template <class T> T atomic_fetch_sub_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
template (pointer) (2)	template <class U> U* atomic_fetch_sub_explicit (volatile atomic<U*>* obj, ptrdiff_t val, memory_order sync) noexcept; template <class U> U* atomic_fetch_sub_explicit (atomic<U*>* obj, ptrdiff_t val, memory_order sync) noexcept;
overloads (3)	T atomic_fetch_sub_explicit (volatile A* obj, M val, memory_order sync) noexcept; T atomic_fetch_sub_explicit (A* obj, M val, memory_order sync) noexcept;

將原子對象的封裝值減 val，並返回原子對象的舊值（適用於整形和指針類型的 std::atomic 特化版本），整個過程是原子的。

該函數等價於 std::atomic 對象的atomic::fetch_sub成員函數。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

atomic_fetch_and

emplate (integral) (1)	template <class T> T atomic_fetch_and (volatile atomic<T>* obj, T val) noexcept; template <class T> T atomic_fetch_and (atomic<T>* obj, T val) noexcept;
overloads (2)	T atomic_fetch_and (volatile A* obj, T val) noexcept; T atomic_fetch_and (A* obj, T val) noexcept;

將原子對象的封裝值按位與 val，並返回原子對象的舊值（只適用於整型的 std::atomic 特化版本），整個過程是原子的。

atomic_fetch_and_explicit

template (integral) (1)	template <class T> T atomic_fetch_and_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept; template <class T> T atomic_fetch_and_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
overloads (2)	T atomic_fetch_and_explicit (volatile A* obj, T val, memory_order sync) noexcept; T atomic_fetch_and_explicit (A* obj, T val, memory_order sync) noexcept;

將原子對象的封裝值按位與 val，並返回原子對象的舊值（只適用於整型的 std::atomic 特化版本），整個過程是原子的。

該函數等價於 std::atomic 對象的atomic::fetch_and成員函數。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

atomic_fetch_or

template (integral) (1)	template <class T> T atomic_fetch_or (volatile atomic<T>* obj, T val) noexcept; template <class T> T atomic_fetch_or (atomic<T>* obj, T val) noexcept;
overloads (2)	T atomic_fetch_or (volatile A* obj, T val) noexcept; T atomic_fetch_or (A* obj, T val) noexcept;

將原子對象的封裝值按位或 val，並返回原子對象的舊值（只適用於整型的 std::atomic 特化版本），整個過程是原子的。

atomic_fetch_or_explicit

template (integral) (1)	template <class T> T atomic_fetch_or_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept; template <class T> T atomic_fetch_or_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
overloads (2)	T atomic_fetch_or_explicit (volatile A* obj, T val, memory_order sync) noexcept; T atomic_fetch_or_explicit (A* obj, T val, memory_order sync) noexcept;

A 將原子對象的封裝值按位或 val，並返回原子對象的舊值（只適用於整型的 std::atomic 特化版本），整個過程是原子的。

該函數等價於 std::atomic 對象的atomic::fetch_or成員函數。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

atomic_fetch_xor

template (integral) (1)	template <class T> T atomic_fetch_xor (volatile atomic<T>* obj, T val) noexcept; template <class T> T atomic_fetch_xor (atomic<T>* obj, T val) noexcept;
overloads (2)	T atomic_fetch_xor (volatile A* obj, T val) noexcept; T atomic_fetch_xor (A* obj, T val) noexcept;

將原子對象的封裝值按位異或 val，並返回原子對象的舊值（只適用於整型的 std::atomic 特化版本），整個過程是原子的。

atomic_fetch_xor_explicit

template (integral) (1)	template <class T> T atomic_fetch_xor_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept; template <class T> T atomic_fetch_xor_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
overloads (2)	T atomic_fetch_xor_explicit (volatile A* obj, T val, memory_order sync) noexcept; T atomic_fetch_xor_explicit (A* obj, T val, memory_order sync) noexcept;

將原子對象的封裝值按位異或 val，並返回原子對象的舊值（只適用於整型的 std::atomic 特化版本），整個過程是原子的。

該函數等價於 std::atomic 對象的atomic::fetch_xor成員函數。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

與原子對象初始化相關的宏

此外，還有兩個宏值得關注，他們分別是：

ATOMIC_VAR_INIT(val)

初始化 std::atomic 對象。

ATOMIC_FLAG_INIT

初始化 std::atomic_flag 對象。