前面三篇文章《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
  1. bool atomic_flag_test_and_set (volatile atomic_flag* obj) noexcept;
  2. 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
  1. bool atomic_flag_test_and_set (volatile atomic_flag* obj, memory_order sync) noexcept;
  2. 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
  1. void atomic_flag_clear (volatile atomic_flag* obj) noexcept;
  2. void atomic_flag_clear (atomic_flag* obj) noexcept;
清除 std::atomic_flag 对象，并设置它的值为 false，和 std::atomic::clear() 成员函数的功能相同，整个过程也是原子的，默认的内存序为memory_order_seq_cst。
atomic_flag_clear_explicit
  1. void atomic_flag_clear (volatile atomic_flag* obj, memory_order sync) noexcept;
  2. 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) 
  1. template <class T> bool atomic_is_lock_free (const volatile atomic<T>* obj) noexcept;
  2. template <class T> bool atomic_is_lock_free (const atomic<T>* obj) noexcept;
overloads (2) 
  1. bool atomic_is_lock_free (const volatile A* obj) noexcept;
  2. bool atomic_is_lock_free (const A* obj) noexcept;
判断该 std::atomic 对象是否具备 lock-free 的特性。如果某个对象满足 lock-free 特性，在多个线程访问该对象时不会导致线程阻塞。(可能使用某种事务内存transactional memory 方法实现 lock-free 的特性)。
atomic_init
template (1) 
  1. template <class T> void atomic_init (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> void atomic_init (atomic<T>* obj, T val) noexcept;
overloads (2) 
  1. void atomic_init (volatile A* obj, T val) noexcept;
  2. void atomic_init (A* obj, T val) noexcept;
初始化原子对象。val 指定原子对象的初始值。如果对一个已初始化的原子对象再次调用 atomic_init()，则会导致未定义行为(undefined behavior)，如果你想修改原子对象的值，应该使用 std::atomic_store();
atomic_store
template (1) 
  1. template <class T> void atomic_store (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> void atomic_store (atomic<T>* obj, T val) noexcept;
overloads (2) 
  1. void atomic_store (volatile A* obj, T val) noexcept;
  2. 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) 
  1. template <class T> T atomic_load (const volatile atomic<T>* obj) noexcept;
  2. template <class T> T atomic_load (const atomic<T>* obj) noexcept;
overloads (2) 
  1. T atomic_load (const volatile A* obj) noexcept;
  2. T atomic_load (const A* obj) noexcept;
读取被封装的值，默认的内存序为memory_order_seq_cst。该函数与 std::atomic 对象的atomic::load()和atomic::operator T() 成员函数等价。
atomic_load_explicit
template (1) 
  1. template <class T>
  2. T atomic_load_explicit (const volatile atomic<T>* obj, memory_order sync) noexcept;
  3. template <class T>
  4. T atomic_load_explicit (const atomic<T>* obj, memory_order sync) noexcept;
overloads (2) 
  1. T atomic_load_explicit (const volatile A* obj, memory_order sync) noexcept;
  2. 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) 
  1. template <class T> T atomic_exchange (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> T atomic_exchange (atomic<T>* obj, T val) noexcept;
overloads (2) 
  1. T atomic_exchange (volatile A* obj, T val) noexcept;
  2. T atomic_exchange (A* obj, T val) noexcept;
读取并修改被封装的值，exchange 会将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。该函数与 std::atomic 对象的atomic::exchange() 成员函数等价。
atomic_exchange_explicit
template (1) 
  1. template <class T>
  2. T atomic_store_explicit (volatile atomic<T>* obj, T val, memory_order sync) noexcept;
  3. template <class T>
  4. T atomic_store_explicit (atomic<T>* obj, T val, memory_order sync) noexcept;
overloads (2) 
  1. T atomic_store_explicit (volatile A* obj, T val, memory_order sync) noexcept;
  2. 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) 
  1. template <class T>
  2. bool atomic_compare_exchange_weak (volatile atomic<T>* obj, T* expected, T val) noexcept;
  3. template <class T>
  4. bool atomic_compare_exchange_weak (atomic<T>* obj, T* expected, T val) noexcept;
overloads (2) 
  1. bool atomic_compare_exchange_weak (volatile A* obj, T* expected, T val) noexcept;
  2. 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) 
  1. template <class T>
  2. bool atomic_compare_exchange_weak_explicit (volatile atomic<T>* obj,
  3.         T* expected, T val, memory_order success, memory_order failure) noexcept;
  4. template <class T>
  5. bool atomic_compare_exchange_weak_explicit (atomic<T>* obj,
  6.         T* expected, T val, memory_order success, memory_order failure) noexcept;
overloads (2) 
  1. bool atomic_compare_exchange_weak_explicit (volatile A* obj,
  2.         T* expected, T val, memory_order success, memory_order failure) noexcept;
  3. bool atomic_compare_exchange_weak_explicit (A* obj,
  4.         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) 
  1. template <class T>
  2. bool atomic_compare_exchange_strong (volatile atomic<T>* obj, T* expected, T val) noexcept;
  3. template <class T>
  4. bool atomic_compare_exchange_strong (atomic<T>* obj, T* expected, T val) noexcept;
overloads (2) 
  1. bool atomic_compare_exchange_strong (volatile A* obj, T* expected, T val) noexcept;
  2. 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) 
  1. template <class T>
  2. bool atomic_compare_exchange_strong_explicit (volatile atomic<T>* obj,
  3.         T* expected, T val, memory_order success, memory_order failure) noexcept;
  4. template <class T>
  5. bool atomic_compare_exchange_strong_explicit (atomic<T>* obj,
  6.         T* expected, T val, memory_order success, memory_order failure) noexcept;
overloads (2) 
  1. bool atomic_compare_exchange_strong_explicit (volatile A* obj,
  2.         T* expected, T val, memory_order success, memory_order failure) noexcept;
  3. bool atomic_compare_exchange_strong_explicit (A* obj,
  4.         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) 
  1. template <class T> T atomic_fetch_add (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> T atomic_fetch_add (atomic<T>* obj, T val) noexcept;
template (pointer) (2) 
  1. template <class U> U* atomic_fetch_add (volatile atomic<U*>* obj, ptrdiff_t val) noexcept;
  2. template <class U> U* atomic_fetch_add (atomic<U*>* obj, ptrdiff_t val) noexcept;
overloads (3) 
  1. T atomic_fetch_add (volatile A* obj, M val) noexcept;
  2. 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) 
  1. template <class T>
  2. T atomic_fetch_add_explicit (volatile atomic<T>* obj,
  3.                              T val, memory_order sync) noexcept;
  4. template <class T>
  5. T atomic_fetch_add_explicit (atomic<T>* obj,
  6.                              T val, memory_order sync) noexcept;
template (pointer) (2) 
  1. template <class U>
  2. U* atomic_fetch_add_explicit (volatile atomic<U*>* obj,
  3.                               ptrdiff_t val, memory_order sync) noexcept;
  4. template <class U>
  5. U* atomic_fetch_add_explicit (atomic<U*>* obj,
  6.                               ptrdiff_t val, memory_order sync) noexcept;
overloads (3) 
  1. T atomic_fetch_add_explicit (volatile A* obj, M val, memory_order sync) noexcept;
  2. 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) 
  1. template <class T> T atomic_fetch_sub (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> T atomic_fetch_sub (atomic<T>* obj, T val) noexcept;
template (pointer) (2) 
  1. template <class U> U* atomic_fetch_sub (volatile atomic<U*>* obj, ptrdiff_t val) noexcept;
  2. template <class U> U* atomic_fetch_sub (atomic<U*>* obj, ptrdiff_t val) noexcept;
overloads (3) 
  1. T atomic_fetch_sub (volatile A* obj, M val) noexcept;
  2. T atomic_fetch_sub (A* obj, M val) noexcept;
将原子对象的封装值减 val，并返回原子对象的旧值（适用于整形和指针类型的 std::atomic 特化版本），整个过程是原子的。
atomic_fetch_sub_explicit
template (integral) (1) 
  1. template <class T>
  2. T atomic_fetch_sub_explicit (volatile atomic<T>* obj,
  3.                              T val, memory_order sync) noexcept;
  4. template <class T>
  5. T atomic_fetch_sub_explicit (atomic<T>* obj,
  6.                              T val, memory_order sync) noexcept;
template (pointer) (2) 
  1. template <class U>
  2. U* atomic_fetch_sub_explicit (volatile atomic<U*>* obj,
  3.                               ptrdiff_t val, memory_order sync) noexcept;
  4. template <class U>
  5. U* atomic_fetch_sub_explicit (atomic<U*>* obj,
  6.                               ptrdiff_t val, memory_order sync) noexcept;
overloads (3) 
  1. T atomic_fetch_sub_explicit (volatile A* obj, M val, memory_order sync) noexcept;
  2. 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) 
  1. template <class T> T atomic_fetch_and (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> T atomic_fetch_and (atomic<T>* obj, T val) noexcept;
overloads (2) 
  1. T atomic_fetch_and (volatile A* obj, T val) noexcept;
  2. T atomic_fetch_and (A* obj, T val) noexcept;
将原子对象的封装值按位与 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。
atomic_fetch_and_explicit
template (integral) (1) 
  1. template <class T>
  2. T atomic_fetch_and_explicit (volatile atomic<T>* obj,
  3.                              T val, memory_order sync) noexcept;
  4. template <class T>
  5. T atomic_fetch_and_explicit (atomic<T>* obj,
  6.                              T val, memory_order sync) noexcept;
overloads (2) 
  1. T atomic_fetch_and_explicit (volatile A* obj, T val, memory_order sync) noexcept;
  2. 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) 
  1. template <class T> T atomic_fetch_or (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> T atomic_fetch_or (atomic<T>* obj, T val) noexcept;
overloads (2) 
  1. T atomic_fetch_or (volatile A* obj, T val) noexcept;
  2. T atomic_fetch_or (A* obj, T val) noexcept;
将原子对象的封装值按位或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。
atomic_fetch_or_explicit
template (integral) (1) 
  1. template <class T>
  2. T atomic_fetch_or_explicit (volatile atomic<T>* obj,
  3.                              T val, memory_order sync) noexcept;
  4. template <class T>
  5. T atomic_fetch_or_explicit (atomic<T>* obj,
  6.                              T val, memory_order sync) noexcept;
overloads (2) 
  1. T atomic_fetch_or_explicit (volatile A* obj, T val, memory_order sync) noexcept;
  2. 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) 
  1. template <class T> T atomic_fetch_xor (volatile atomic<T>* obj, T val) noexcept;
  2. template <class T> T atomic_fetch_xor (atomic<T>* obj, T val) noexcept;
overloads (2) 
  1. T atomic_fetch_xor (volatile A* obj, T val) noexcept;
  2. T atomic_fetch_xor (A* obj, T val) noexcept;
将原子对象的封装值按位异或 val，并返回原子对象的旧值（只适用于整型的 std::atomic 特化版本），整个过程是原子的。
atomic_fetch_xor_explicit
template (integral) (1) 
  1. template <class T>
  2. T atomic_fetch_xor_explicit (volatile atomic<T>* obj,
  3.                              T val, memory_order sync) noexcept;
  4. template <class T>
  5. T atomic_fetch_xor_explicit (atomic<T>* obj,
  6.                              T val, memory_order sync) noexcept;
overloads (2) 
  1. T atomic_fetch_xor_explicit (volatile A* obj, T val, memory_order sync) noexcept;
  2. 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 对象。

C++11 并发指南六(atomic 类型详解四 C 风格原子操作介绍)的更多相关文章

  1. C++11 并发指南六(atomic 类型详解三 std::atomic (续))

    C++11 并发指南六( <atomic> 类型详解二 std::atomic ) 介绍了基本的原子类型 std::atomic 的用法,本节我会给大家介绍C++11 标准库中的 std: ...

  2. C++11 并发指南六( <atomic> 类型详解二 std::atomic )

    C++11 并发指南六(atomic 类型详解一 atomic_flag 介绍)  一文介绍了 C++11 中最简单的原子类型 std::atomic_flag,但是 std::atomic_flag ...

  3. C++11 并发指南六(atomic 类型详解一 atomic_flag 介绍)

    C++11 并发指南已经写了 5 章,前五章重点介绍了多线程编程方面的内容,但大部分内容只涉及多线程.互斥量.条件变量和异步编程相关的 API,C++11 程序员完全可以不必知道这些 API 在底层是 ...

  4. 【C/C++开发】C++11 并发指南三(std::mutex 详解)

    本系列文章主要介绍 C++11 并发编程,计划分为 9 章介绍 C++11 的并发和多线程编程,分别如下: C++11 并发指南一(C++11 多线程初探)(本章计划 1-2 篇,已完成 1 篇) C ...

  5. C++11 并发指南五(std::condition_variable 详解)

    前面三讲<C++11 并发指南二(std::thread 详解)>,<C++11 并发指南三(std::mutex 详解)>分别介绍了 std::thread,std::mut ...

  6. C++11 并发指南五(std::condition_variable 详解)（转）

    前面三讲<C++11 并发指南二(std::thread 详解)>,<C++11 并发指南三(std::mutex 详解)>分别介绍了 std::thread,std::mut ...

  7. 【转】C++11 并发指南五(std::condition_variable 详解)

    http://www.cnblogs.com/haippy/p/3252041.html 前面三讲<C++11 并发指南二(std::thread 详解)>,<C++11 并发指南三 ...

  8. C++11 并发指南三(std::mutex 详解)

    上一篇<C++11 并发指南二(std::thread 详解)>中主要讲到了 std::thread 的一些用法,并给出了两个小例子,本文将介绍 std::mutex 的用法. Mutex ...

  9. C++11 并发指南三(std::mutex 详解)（转）

    转自:http://www.cnblogs.com/haippy/p/3237213.html 上一篇<C++11 并发指南二(std::thread 详解)>中主要讲到了 std::th ...

随机推荐

  1. vi 使用

      1)命令 gf  ,可以从光标指定的文件位置打开对应文件 :bd回来 2)http://www.cnblogs.com/wangkangluo1/archive/2012/04/12/244495 ...

  2. 不使用容器构建Registry

    安装必要的软件 $ sudo apt-get install build-essential python-dev libevent-dev python-pip liblzma-dev 配置 doc ...

  3. centos安装mysql5.6的正确姿态

    1.准备工作 a)卸载centos默认软件 yum remove mariadb-libs-5.5.35-3.el7.x86_64 b)安装依赖包 yum install -y perl-Module ...

  4. C#语法灵活运用之排列组合算法

    今天群里有朋友求一个排列组合算法,题目是给定长度,输出所有指定字母的组合. 如指定字母a.b.c.d.e.f,长度为2,则结果应为:aa.ab.ac ... ef.ff. 有朋友给出算法,很有特色: ...

  5. hdu 1577 WisKey的眼神 (数学几何)

    WisKey的眼神 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total S ...

  6. C# 生成条形码

    原文地址:http://www.cnblogs.com/xcsn/p/4514759.html 引用BarcodeLib.dll(百度云中有)生成条形 protected void Button2_C ...

  7. iOS7.0适配问题

    self.navigationController.navigationBar.translucent = YES,导航栏透明 extendedLayoutIncludesOpaqueBars = Y ...

  8. hdu4738 Caocao's Bridges

    http://acm.hdu.edu.cn/showproblem.php?pid=4738 题目大意:曹操赤壁之战大败,于是卷土重来.为了避免水上作战,他在长江上建立了一些岛屿,这样他的士兵就可以在 ...

  9. 屏蔽input导致的回车提交事件

    onkeypress="if(event.keyCode == 13) return false;"

  10. Java线程池的几种实现 及 常见问题讲解

    工作中,经常会涉及到线程.比如有些任务,经常会交与线程去异步执行.抑或服务端程序为每个请求单独建立一个线程处理任务.线程之外的,比如我们用的数据库连接.这些创建销毁或者打开关闭的操作,非常影响系统性能 ...