Энтони Уильямс - Параллельное программирование на С++ в действии. Практика разработки многопоточных программ

Атомарно сравнивает значение с ожидаемым и, если они равны, сохраняет новое значение. Если значения не равны, то заменяет ожидаемое значение прочитанным.

Объявление

template

bool atomic_compare_exchange_strong_explicit(

volatile atomic* p,

BaseType * old_value, BaseType new_value,

memory_order success_order, memory_order failure_order)

noexcept;

template

bool atomic_compare_exchange_strong_explicit(

atomic* p,

BaseType * old_value, BaseType new_value,

memory_order success_order, memory_order failure_order)

noexcept;

Результат

return p->compare_exchange_strong(

*old_value, new_value, success_order, failure_order) noexcept;

STD::ATOMIC::COMPARE_EXCHANGE_WEAK , ФУНКЦИЯ-ЧЛЕН

Атомарно сравнивает значение с ожидаемым и, если они равны и обновление может быть произведено атомарно, то сохраняет новое значение. Если значения не равны или обновление не может быть произведено атомарно, то заменяет ожидаемое значение прочитанным.

Объявление

bool compare_exchange_weak(

BaseType& expected, BaseType new_value,

memory_order order = std::memory_order_seq_cst)

volatile noexcept;

bool compare_exchange_weak(

BaseType& expected, BaseType new_value,

memory_order order = std::memory_order_seq_cst) noexcept;

bool compare_exchange_weak(

BaseType& expected, BaseType new_value,

memory_order success_order, memory_order failure_order)

volatile noexcept;

bool compare_exchange_weak(

BaseType& expected, BaseType new_value,

memory_order success_order,

memory_order failure_order) noexcept;

Предусловия

Параметр failure_orderне должен быть равен std::memory_order_releaseили std::memory_order_acq_rel.

Результат

Атомарно сравнивает expectedсо значением, хранящимся в *this, применяя побитовое сравнение, и сохраняет new_valueв *this, если значения равны. Если значения не равны или обновление не может быть произведено атомарно, записывает в expectedпрочитанное значение.

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

true, если значение, хранящееся в *this, совпало с expectedи new_valueуспешно сохранено в *this. В противном случае false.

Исключения

Нет.

Примечание. Этот перегруженный вариант функции с тремя параметрами эквивалентен перегруженному варианту с четырьмя параметрами, где success_order == orderи failure_order == order, с тем отличием, что если orderравно std::memory_order_acq_rel, то failure_orderравно std::memory_order_acquire, а если order равно std::memory_order_release, то failure_orderравно std::memory_order_relaxed.

Примечание. Если результат равен true, то это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this, с упорядочением доступа к памяти success_order; в противном случае это атомарная операция загрузки для ячейки памяти, содержащей *this, с упорядочением доступа к памяти failure_order.

STD::ATOMIC_COMPARE_EXCHANGE_WEAK , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно сравнивает значение с ожидаемым и, если они равны и обновление может быть произведено атомарно, то сохраняет новое значение. Если значения не равны или обновление не может быть произведено атомарно, то заменяет ожидаемое значение прочитанным.

Объявление

template

bool atomic_compare_exchange_weak(

volatile atomic* p,

BaseType * old_value, BaseType new_value) noexcept;

template

bool atomic_compare_exchange_weak(

atomic* p,

BaseType * old_value, BaseType new_value) noexcept;

Результат

return p->compare_exchange_weak(*old_value, new_value);

STD::ATOMIC_COMPARE_EXCHANGE_WEAK_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно сравнивает значение с ожидаемым и, если они равны и обновление может быть произведено атомарно, то сохраняет новое значение. Если значения не равны или обновление не может быть произведено атомарно, то заменяет ожидаемое значение прочитанным.

template

bool atomic_compare_exchange_weak_explicit(

volatile atomic* p,

BaseType * old_value, BaseType new_value,

memory_order success_order,

memory_order failure_order) noexcept;

template

bool atomic_compare_exchange_weak_explicit(

atomic* p,

BaseType * old_value, BaseType new_value,

memory_order success_order,

memory_order failure_order) noexcept;

Результат

return p->compare_exchange_weak(

*old_value, new_value, success_order, failure_order);

Предоставляются специализации шаблона std::atomicдля целочисленных и указательных типов. Для целочисленных типов специализации обеспечивают атомарные операции сложения, вычитания и поразрядные в дополнение к имеющимся в основном шаблоне. Для указательных типов в дополнение к основному шаблону предоставляются арифметические операции над указателями.

Имеются специализации для следующих целочисленных типов:

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

а также для типа std::atomicпри любом типе T.

Специализации std::atomic< integral-type >шаблона класса std::atomicдают атомарный целочисленный тип для каждого фундаментального целочисленного типа, с полным набором операций.

Ниже перечислены все такие специализации шаблона std::atomic<>:

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

std::atomic

Экземпляры этих специализаций не удовлетворяют требованиям концепций CopyConstructibleи CopyAssignable, поскольку такие операции невозможно выполнить атомарно.

Определение класса

template<>

struct atomic< integral-type > {

atomic() noexcept = default;

constexpr atomic(integral-type) noexcept;

bool operator=(integral-type) volatile noexcept;

atomic(const atomic&) = delete;

atomic& operator=(const atomic&) = delete;

atomic& operator=(const atomic&) volatile = delete;

bool is_lock_free() const volatile noexcept;

bool is_lock_free() const noexcept;

void store(

integral-type , memory_order = memory_order_seq_cst)

volatile noexcept;

void store(

integral-type , memory_order = memory_order_seq_cst) noexcept;

integral-type load(memory_order = memory_order_seq_cst)

const volatile noexcept;

integral-type load(

memory_order = memory_order_seq_cst) const noexcept;

integral-type exchange(

integral-type ,

memory_order = memory_order_seq_cst) volatile noexcept;

integral-type exchange(

integral-type , memory_order = memory_order_seq_cst) noexcept;

bool compare_exchange_strong(

integral-type & old_value, integral-type new_value,

memory_order order = memory_order_seq_cst)

volatile noexcept;

bool compare_exchange_strong(