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

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;

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;

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;

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;

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;

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;

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;

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;

Атомарно сравнивает представление объекта(до C++20)представление значения(начиная с C++20) объекта, на который указывает obj, с представлением объекта, на который указывает expected, и, если они побитово равны, заменяет первое значение на desired (выполняет операцию чтения-модификации-записи). В противном случае загружает фактическое значение, на которое указывает obj, в *expected (выполняет операцию загрузки).

Эти функции определены через функции-члены std::atomic:

Если failure сильнее, чем success, или(до C++17) имеет одно из значений std::memory_order_release и std::memory_order_acq_rel, поведение не определено.

Параметры

Возвращаемое значение

Результат сравнения: true, если *obj было равно *expected, и false в противном случае.

Примечания

Операциям std::atomic_compare_exchange_weak и std::atomic_compare_exchange_weak_explicit (слабым версиям) разрешено завершаться ложной неудачей, то есть вести себя так, как если бы *obj != *expected, даже если значения равны. При использовании compare-and-exchange в цикле они могут обеспечивать более высокую производительность на некоторых платформах.

Если для слабой операции compare-and-exchange потребуется цикл, а для сильной — нет, предпочтительна сильная операция, если только представление объекта T не может включать биты заполнения,(до C++20) биты-ловушки или несколько представлений объекта для одного и того же значения (например, NaN с плавающей точкой). В таких случаях слабая операция compare-and-exchange обычно работает, поскольку быстро сходится к некоторому устойчивому представлению объекта.

Для объединения, в котором биты участвуют в представлении значения одних членов, но не других, операция compare-and-exchange может всегда завершаться неудачей, поскольку такие биты заполнения имеют неопределённые значения, когда они не участвуют в представлении значения активного члена.

Пример

#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);
        
        // put the current value of head into new_node->next
        new_node->next = head.load(std::memory_order_relaxed);
        
        // now make new_node the new head, but if the head
        // is no longer what's stored in new_node->next
        // (some other thread must have inserted a node just now)
        // then put that new head into new_node->next and try again
        while (!std::atomic_compare_exchange_weak_explicit(
                   &head, &new_node->next, new_node,
                   std::memory_order_release, std::memory_order_relaxed))
            ; // the body of the loop is empty
// note: the above loop is not thread-safe in at least
// GCC prior to 4.8.3 (bug 60272), clang prior to 2014-05-05 (bug 18899)
// MSVC prior to 2014-03-17 (bug 819819). See member function version for workaround
    }
};

int main()
{
    stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
}

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

См. также