Параллельное программирование на С++ в действии

Атомарно вычитает значение аргумента из значения, хранящегося в *this, и возвращает новое значение.

Объявление

integral-type operator-=(integral-type i) volatile noexcept;

integral-type operator-=(integral-type i) noexcept;

Результат

return this->fetch_sub(i, std::memory_order_seq_cst) - i;

STD::ATOMIC::OPERATOR&=, СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно заменяет значение, хранящееся в *this, результатом операции поразрядное-и между этим значением и значением аргумента и возвращает новое значение.

Объявление

integral-type operator&=(integral-type i) volatile noexcept;

integral-type operator&=(

integral-type i) noexcept;

Результат

return this->fetch_and(i) & i;

STD::ATOMIC::OPERATOR|=, СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно заменяет значение, хранящееся в *this, результатом операции поразрядное-или между этим значением и значением аргумента и возвращает новое значение.

Объявление

integral-type operator|=(integral-type i) volatile noexcept;

integral-type operator|=(integral-type i) noexcept;

Результат

return this->fetch_or(i, std::memory_order_seq_cst) | i;

STD::ATOMIC::OPERATOR^=, СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно заменяет значение, хранящееся в *this

, результатом операции поразрядное исключающее-или между этим значением и значением аргумента и возвращает новое значение.

Объявление

integral-type operator^=(integral-type i) volatile noexcept;

integral-type operator^=(integral-type i) noexcept;

Результат

return this->fetch_xor(i, std::memory_order_seq_cst) ^ i;

STD::ATOMIC, ЧАСТИЧНАЯ СПЕЦИАЛИЗАЦИЯ

Частичная специализация std::atomic шаблона std::atomic предоставляет атомарный тип для любого указательного типа, с полным набором операций.

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

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

template

struct atomic {

 atomic() noexcept = default;

 constexpr atomic(T*) noexcept;

 bool operator=(T*) volatile;

 bool operator=(T*);

 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(T*, memory_order = memory_order_seq_cst)

  volatile noexcept;

 void store(T*, memory_order = memory_order_seq_cst) noexcept;

 T* load(memory_order = memory_order_seq_cst)

  const volatile noexcept;

 T* load(memory_order = memory_order_seq_cst) const noexcept;

 T* exchange(T*, memory_order = memory_order_seq_cst)

  volatile noexcept;

 T* exchange(T*, memory_order = memory_order_seq_cst) noexcept;

 bool compare_exchange_strong(

  T* & old_value, T* new_value,

  memory_order order = memory_order_seq_cst)

  volatile noexcept;

 bool compare_exchange_strong(

  T* & old_value, T* new_value,

  memory_order order = memory_order_seq_cst) noexcept;

 bool compare_exchange_strong(

  T* & old_value, T* new_value,

  memory_order success_order, memory_order failure_order)

  volatile noexcept;