C++ 参考手册
- C++11
- C++14
- C++17
- C++20
- C++ 编译器支持情况表
- 独立与宿主实现
- C++ 语言
- C++ 关键词
- 预处理器
- C++ 标准库头文件
- 具名要求
- 功能特性测试 (C++20)
- 工具库
- 类型支持(基本类型、RTTI、类型特性)
- 概念库 (C++20)
- 错误处理
- 动态内存管理
- 日期和时间工具
- 字符串库
- 容器库
- 迭代器库
- 范围库 (C++20)
- 算法库
- 数值库
- 输入/输出库
- 文件系统库
- 本地化库
- 正则表达式库
- 原子操作库
- std::atomic
- std::atomic<T>::atomic
- std::atomic<T>::operator=
- std::atomic<T>::is_lock_free
- std::atomic<T>::is_always_lock_free
- std::atomic<T>::store
- std::atomic<T>::load
- std::atomic<T>::operator T()
- std::atomic<T>::exchange
- std::atomic<T>::compare_exchange_weak, std::atomic<T>::compare_exchange_strong
- std::atomic<T>::wait
- std::atomic<T>::notify_one
- std::atomic<T>::notify_all
- std::atomic<T>::fetch_add
- std::atomic<T>::fetch_sub
- std::atomic<T>::fetch_and
- std::atomic<T>::fetch_or
- std::atomic<T>::fetch_xor
- std::atomic<T>::operator++,++(int),--,--(int)
- std::atomic<T>::operator+=,-=,&=,|=,^=
- std::atomic_store, std::atomic_store_explicit
- std::atomic_load, std::atomic_load_explicit
- std::atomic_exchange, std::atomic_exchange_explicit
- std::atomic_flag
- std::atomic_ref
- std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit
- std::atomic_fetch_add, std::atomic_fetch_add_explicit
- std::atomic_fetch_sub, std::atomic_fetch_sub_explicit
- std::atomic_fetch_and, std::atomic_fetch_and_explicit
- std::atomic_fetch_or, std::atomic_fetch_or_explicit
- std::atomic_fetch_xor, std::atomic_fetch_xor_explicit
- std::atomic_is_lock_free, ATOMIC_xxx_LOCK_FREE
- std::atomic_wait, std::atomic_wait_explicit
- std::atomic_notify_one
- std::atomic_notify_all
- std::atomic_flag_test_and_set, std::atomic_flag_test_and_set_explicit
- std::atomic_flag_clear, std::atomic_flag_clear_explicit
- std::atomic_flag_test, std::atomic_flag_test_explicit
- std::atomic_flag_wait, std::atomic_flag_wait_explicit
- std::atomic_flag_notify_one
- std::atomic_flag_notify_all
- std::atomic_init
- ATOMIC_VAR_INIT
- ATOMIC_FLAG_INIT
- std::memory_order
- std::kill_dependency
- std::atomic_thread_fence
- std::atomic_signal_fence
- 注释
- 线程支持库
- 实验性 C++ 特性
- 有用的资源
- 索引
- std 符号索引
- 协程支持 (C++20)
- C++ 关键词
位置:首页 > C++ 参考手册 >原子操作库 >std::atomic > std::atomic<T>::compare_exchange_weak, std::atomic<T>::compare_exchange_strong
std::atomic<T>::compare_exchange_weak, std::atomic<T>::compare_exchange_strong
定义于头文件 <atomic>
|
||
(1) | (C++11 起) | |
bool compare_exchange_weak( T& expected, T desired, std::memory_order success, |
||
bool compare_exchange_weak( T& expected, T desired, std::memory_order success, |
||
(2) | (C++11 起) | |
bool compare_exchange_weak( T& expected, T desired, std::memory_order order = |
||
bool compare_exchange_weak( T& expected, T desired, std::memory_order order = |
||
(3) | (C++11 起) | |
bool compare_exchange_strong( T& expected, T desired, std::memory_order success, |
||
bool compare_exchange_strong( T& expected, T desired, std::memory_order success, |
||
(4) | (C++11 起) | |
bool compare_exchange_strong( T& expected, T desired, std::memory_order order = |
||
bool compare_exchange_strong( T& expected, T desired, std::memory_order order = |
||
原子地比较 *this
和 expected
的对象表示 (C++20 前)值表示 (C++20 起),而若它们逐位相等,则以 desired
替换前者(进行读修改写操作)。否则,将 *this
中的实际值加载进 expected
(进行加载操作)。
读修改写和加载操作的内存模型分别为 success
和 failure
。在 (2) 和 (4) 版本中, order
用于读修改写操作和加载操作,除了若 order == std::memory_order_acq_rel 或 order == std::memory_order_release ,则加载操作分别使用 std::memory_order_acquire 和 std::memory_order_relaxed 。
参数
expected | - | 到期待在原子对象中找到的值的引用 |
desired | - | 若符合期待则存储于原子对象的值 |
success | - | 若比较成功,则读修改写操作所用的内存同步顺序。容许所有值。 |
failure | - | 若比较失败,则加载操作所用的内存同步顺序。不能为 std::memory_order_release 或 std::memory_order_acq_rel ,且不能指定强于 success 的顺序 (C++17 前)
|
order | - | 两个操作所用的内存同步顺序 |
返回值
若成功更改底层原子值则为 true ,否则为 false 。
注意
比较和复制是逐位的(类似 std::memcmp 和 std::memcpy );不使用构造函数、赋值运算符或比较运算符。
允许函数的弱形式 (1-2) 虚假地失败,即表现如同 *this != expected ,纵使它们相等。比较和交换在循环中时,弱版本在有的平台上会产出更好的性能。
弱版本比较和交换会要求循环,而强版本不要求时,推荐用强版本,除非 T
的对象表示可包含填充位、 (C++20 前)陷阱位或为同一值提供多个对象表示(例如浮点 NaN )。这些情况下,弱比较和交换典型地可用,因为它在一些稳定对象表示上快速收敛。
若有参与 union 某些成员,但非其他成员的值表示的位,则比较和交换可能始终失败,因为这种填充位在不参与活跃成员的值表示时拥有不确定值。
忽略决不参与对象值表示的填充位。 |
(C++20 起) |
示例
比较和交换操作通常用作无锁数据结构的基本建筑块
#include <atomic> template<typename T> struct node { T data; node* next; node(const T& data) : data(data), next(nullptr) {} }; template<typename T> class stack { std::atomic<node<T>*> head; public: void push(const T& data) { node<T>* new_node = new node<T>(data); // 放 head 的当前值到 new_node->next 中 new_node->next = head.load(std::memory_order_relaxed); // 现在领 new_node 为新的 head ,但若 head 不再是 // 存储于 new_node->next 的值(某些其他线程必须在刚才插入结点) // 则放新的 head 到 new_node->next 中并再尝试 while(!head.compare_exchange_weak(new_node->next, new_node, std::memory_order_release, std::memory_order_relaxed)) ; // 循环体为空 // 注意:上述使用至少在这些版本不是线程安全的 // 先于 4.8.3 的 GCC (漏洞 60272 ),先于 2014-05-05 的 clang (漏洞 18899 ) // 先于 2014-03-17 的 MSVC (漏洞 819819 )。下面是变通方法: // node<T>* old_head = head.load(std::memory_order_relaxed); // do { // new_node->next = old_head; // } while(!head.compare_exchange_weak(old_head, new_node, // std::memory_order_release, // std::memory_order_relaxed)); } }; int main() { stack<int> s; s.push(1); s.push(2); s.push(3); }
演示 compare_exchange_strong 如何要么更改原子对象的值,要么将变量用于比较。
本节未完成 原因:强 CAS 的更实际用法会更好,例如在 Concurrency in Action 使用它的地方 |
#include <atomic> #include <iostream> std::atomic<int> ai; int tst_val= 4; int new_val= 5; bool exchanged= false; void valsout() { std::cout << "ai= " << ai << " tst_val= " << tst_val << " new_val= " << new_val << " exchanged= " << std::boolalpha << exchanged << "\n"; } int main() { ai= 3; valsout(); // tst_val != ai ==> tst_val 被修改 exchanged= ai.compare_exchange_strong( tst_val, new_val ); valsout(); // tst_val == ai ==> ai 被修改 exchanged= ai.compare_exchange_strong( tst_val, new_val ); valsout(); }
输出:
ai= 3 tst_val= 4 new_val= 5 exchanged= false ai= 3 tst_val= 3 new_val= 5 exchanged= false ai= 5 tst_val= 3 new_val= 5 exchanged= true
参阅
原子地比较原子对象和非原子实参的值,若相等则进行 atomic_exchange,若不相等则进行 atomic_load (函数模板) |