std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit

在标头 `<atomic>` 定义
template< class T > bool atomic_compare_exchange_weak ( std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired ) noexcept;	(1)	(C++11 起)
template< class T > bool atomic_compare_exchange_weak ( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired ) noexcept;	(2)	(C++11 起)
template< class T > bool atomic_compare_exchange_strong ( std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired ) noexcept;	(3)	(C++11 起)
template< class T > bool atomic_compare_exchange_strong ( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired ) noexcept;	(4)	(C++11 起)
template< class T > bool atomic_compare_exchange_weak_explicit ( std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired, std::memory_order success, std::memory_order failure ) noexcept;	(5)	(C++11 起)
template< class T > bool atomic_compare_exchange_weak_explicit ( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired, std::memory_order success, std::memory_order failure ) noexcept;	(6)	(C++11 起)
template< class T > bool atomic_compare_exchange_strong_explicit ( std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired, std::memory_order success, std::memory_order failure ) noexcept;	(7)	(C++11 起)
template< class T > bool atomic_compare_exchange_strong_explicit ( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired, std::memory_order success, std::memory_order failure ) noexcept;	(8)	(C++11 起)

原子地比较 obj 指向的对象与 expected 指向的对象的对象表示 (C++20 前)值表示 (C++20 起)，如果它们逐位相等，那么以 desired 替换前者（进行读修改写操作）。否则，将 obj 指向的对象的实际值加载到 *expected 中（进行加载操作）。

重载	读修改写操作的内存模型	加载操作的内存模型
(1-4)	std::memory_order_seq_cst	std::memory_order_seq_cst
(5-8)	success	failure

这些函数用 std::atomic 的成员函数定义：

1,2) obj->compare_exchange_weak(*expected, desired)

3,4) obj->compare_exchange_strong(*expected, desired)

5,6) obj->compare_exchange_weak(*expected, desired, success, failure)

7,8) obj->compare_exchange_strong(*expected, desired, success, failure)

如果 failure 强于 success 或者 (C++17 前)是 std::memory_order_release 和 std::memory_order_acq_rel 之一，那么行为未定义。

参数

obj	-	指向要测试和修改的原子对象的指针
expected	-	指向期待在原子对象中找到的值的指针
desired	-	在符合期待时存储到原子对象的值
success	-	读修改写操作所用的内存同步顺序
failure	-	加载操作所用的内存同步顺序

返回值

比较结果：如果 *obj 等于 *expected，那么返回 true，否则返回 false。

注意

std::atomic_compare_exchange_weak 和 std::atomic_compare_exchange_weak_explicit（即弱版本）允许虚假地失败，即表现为如同 *obj != *expected，即使它们相等。当比较并交换在循环中时，弱版本在某些平台上会生成更好的性能。

在弱版本会要求循环而强版本不要求时，更偏好强版本，除非 T 的对象表示可能包含填充位、 (C++20 前)陷阱位，或者为一个值提供多个对象表示（例如浮点 NaN）。这些情况下，弱的比较并交换经常有用，因为它在某些稳定对象表示上快速收敛。

对于联合体，如果它持有某些只有部分成员的值表示有参与的位，那么比较和交换可能总会失败，因为这种填充位在不参与活跃成员的值表示时拥有不确定值。

忽略决不参与对象值表示的填充位。

(C++20 起)

示例

比较和交换操作通常用作无锁数据结构的基本组成部分。

运行此代码

#include <atomic>
 
template<class T>
struct node
{
    T data;
    node* next;
    node(const T& data) : data(data), next(nullptr) {}
};
 
template<class 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(!std::atomic_compare_exchange_weak_explicit
        while (!std::atomic_compare_exchange_weak_explicit(
                   &head, &new_node->next, new_node,
                   std::memory_order_release, std::memory_order_relaxed))
            ; // 循环体为空
// 注意：上述循环非线程安全，至少在
// 早于 4.8.3 的 GCC（bug 60272），早于 2014-05-05 的 clang（bug 18899）
// 早于 2014-03-17 的 MSVC（bug 819819）是这样。变通方法见成员函数版本。
    }
};
 
int main()
{
    stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	出版时的行为	正确行为
P0558R1	C++11	要求准确类型匹配，因为会从多个参数推导 `T`	只会从 obj 推导 `T`

参阅

compare_exchange_weakcompare_exchange_strong	原子地比较原子对象与非原子参数的值，相等时进行交换，不相等时进行加载 (`std::atomic<T>` 的公开成员函数)
atomic_exchangeatomic_exchange_explicit (C++11)(C++11)	原子地以非原子实参的值替换原子对象的值，并返回该原子对象的旧值 (函数模板)

std::atomic_compare_exchange_weak(std::shared_ptr) std::atomic_compare_exchange_strong(std::shared_ptr)

(C++20 中弃用)

为 std::shared_ptr 特化原子操作
(函数模板)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit

参数

返回值

注意

示例

缺陷报告

参阅

导航