總地來說，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），可能的取值如下：

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），可能的取值如下：

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

atomic_is_lock_free

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;

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 <class T> void atomic_init (volatile atomic<T>* obj, T val) noexcept;
template <class T> void atomic_init (atomic<T>* obj, T val) noexcept;

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 <class T> void atomic_store (volatile atomic<T>* obj, T val) noexcept;
template <class T> void atomic_store (atomic<T>* obj, T val) noexcept;

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 指定了記憶體序，可取的引數為：

atomic_load

template <class T> T atomic_load (const volatile atomic<T>* obj) noexcept;
template <class T> T atomic_load (const atomic<T>* obj) noexcept;

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 <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;

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)，可能的取值如下：

該函式與 std::atomic 物件的atomic::load() 成員函式等價。

atomic_exchange

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;

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 <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;

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)，可能的取值如下：

atomic_compare_exchange_weak

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;

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 <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;

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 引數指定，可選條件如下：

atomic_compare_exchange_strong

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;

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 <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;

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 引數指定，可選條件如下：

atomic_fetch_add

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 <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;

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 <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 <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;

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 引數指定記憶體序：

atomic_fetch_sub

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 <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;

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 <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 <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;

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 引數指定記憶體序：

atomic_fetch_and

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;

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 <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;

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 引數指定記憶體序：

atomic_fetch_or

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;

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 <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;

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 引數指定記憶體序：

atomic_fetch_xor

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;

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 <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;

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 引數指定記憶體序：

與原子物件初始化相關的巨集

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

ATOMIC_VAR_INIT(val)

初始化 std::atomic 物件。

ATOMIC_FLAG_INIT

初始化 std::atomic_flag 物件。