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

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;

bool compare_exchange_strong(

T* & old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order order = memory_order_seq_cst) volatile noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order order = memory_order_seq_cst) noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order success_order, memory_order failure_order)

volatile noexcept;

bool compare_exchange_weak(

T* & old_value, T* new_value,

memory_order success_order,

memory_order failure_order) noexcept;

operator T*() const volatile noexcept;

operator T*() const noexcept;

T* fetch_add(

ptrdiff_t, memory_order = memory_order_seq_cst)

volatile noexcept;

T* fetch_add(

ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;

T* fetch_sub(

ptrdiff_t, memory_order = memory_order_seq_cst)

volatile noexcept;

T* fetch_sub(

ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;

T* operator++() volatile noexcept;

T* operator++() noexcept;

T* operator++(int) volatile noexcept;

T* operator++(int) noexcept;

T* operator--() volatile noexcept;

T* operator--() noexcept;

T* operator--(int) volatile noexcept;

T* operator--(int) noexcept;

T* operator+=(ptrdiff_t) volatile noexcept;

T* operator+=(ptrdiff_t) noexcept;

T* operator-=(ptrdiff_t) volatile noexcept;

T* operator-=(ptrdiff_t) noexcept;

};

bool atomic_is_lock_free(volatile const atomic*) noexcept;

bool atomic_is_lock_free(const atomic*) noexcept;

void atomic_init(volatile atomic*, T*) noexcept;

void atomic_init(atomic*, T*) noexcept;

T* atomic_exchange(volatile atomic*, T*) noexcept;

T* atomic_exchange(atomic*, T*) noexcept;

T* atomic_exchange_explicit(

volatile atomic*, T*, memory_order) noexcept;

T* atomic_exchange_explicit(

atomic*, T*, memory_order) noexcept;

void atomic_store(volatile atomic*, T*) noexcept;

void atomic_store(atomic*, T*) noexcept;

void atomic_store_explicit(

volatile atomic*, T*, memory_order) noexcept;

void atomic_store_explicit(

atomic*, T*, memory_order) noexcept;

T* atomic_load(volatile const atomic*) noexcept;

T* atomic_load(const atomic*) noexcept;