close

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

来自cppreference.com
 
C++
 
并发支持库
线程
(C++11)
(C++20)
(C++17)(C++17)
this_thread 命名空间
(C++11)
(C++11)
(C++11)
(C++11)
协作式取消
互斥
(C++11)
(C++11)
(C++17)
通用锁管理
(C++11)
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
条件变量
(C++11)
(C++11)
(C++11)
(C++11)
信号量
(C++20)(C++20)
闩与屏障
(C++20)
(C++20)
未来体
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
安全回收
(C++26)
(C++26)
(C++26)
风险指针
(C++26)
(C++26)
(C++26)
原子类型
(C++11)
(C++20)
(C++11)
原子类型的初始化
(C++11)(C++20 弃用)
(C++11)(C++20 弃用)
(C++11)
内存定序
(C++11)
(C++11)(C++26 弃用)
(C++11)
(C++11)
原子操作的自由函数
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++26)(C++26)
(C++26)(C++26)
(C++11)
(C++20)(C++20)
(C++20)
(C++20)
原子标志的自由函数
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
在标头 <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(
                   &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

参阅

 原子地比较原子对象与非原子实参的值，相等时进行原子交换，不相等时进行原子加载
(std::atomic<T> 的公开成员函数) [编辑]
(C++11)(C++11)
 原子地以非原子实参的值替换原子对象的值，并返回该原子对象的旧值
(函数模板) [编辑]
(C++20 弃用)(C++26 移除)
 为 std::shared_ptr 特化原子操作
(函数模板)
atomic_compare_exchange, atomic_compare_exchange_explicit 的 C 文档