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

Предусловия

Параметр order должен принимать одно из значений std::memory_order_relaxed, std::memory_order_releaseили std::memory_order_seq_cst.

Результат

Атомарно сбрасывает флаг.

Исключения

Нет.

Примечание. Это атомарная операция сохранения для ячейки памяти, содержащей *this.

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

Атомарно сбрасывает флаг.

Объявление

void atomic_flag_clear(volatile atomic_flag* flag) noexcept;

void atomic_flag_clear(atomic_flag* flag) noexcept;

Результат

flag->clear();

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

Атомарно сбрасывает флаг.

Объявление

void atomic_flag_clear_explicit(

volatile atomic_flag* flag, memory_order order) noexcept;

void atomic_flag_clear_explicit(

atomic_flag* flag, memory_order order) noexcept;

Результат

return flag->clear(order);

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

Параметр шаблона BaseТуредолжен:

• иметь тривиальный конструктор по умолчанию;

• иметь тривиальный копирующий оператор присваивания;

• иметь тривиальный деструктор;

• допускать побитовое сравнение на равенство.

По существу, это означает, что конкретизация std::atomic<���некоторый-встроенный-тип>допустима, как и конкретизация std::atomic<���некоторая-простая-структура>, но такие вещи, как std::atomic, недопустимы.

Помимо основного шаблона, имеются специализации для встроенных целочисленных типов и указателей, которые предоставляют дополнительные операции, например x++.

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

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

template

struct atomic {

atomic() noexcept = default;

constexpr atomic(BaseType) noexcept;

BaseType operator=(BaseType) volatile noexcept;

BaseType operator=(BaseType) 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(BaseType, memory_order = memory_order_seq_cst)

volatile noexcept;

void store(BaseType, memory_order = memory_order_seq_cst)

noexcept;

BaseType load(memory_order = memory_order_seq_cst)

const volatile noexcept;

BaseType load(memory_order = memory_order_seq_cst)

const noexcept;

BaseType exchange(BaseType, memory_order = memory_order_seq_cst)

volatile noexcept;

BaseType exchange(BaseType, memory_order = memory_order_seq_cst)

noexcept;

bool compare_exchange_strong(

BaseType & old_value, BaseType new_value,

memory_order order = memory_order_seq_cst) volatile noexcept;

bool compare_exchange_strong(

BaseType & old_value, BaseType new_value,

memory_order order = memory_order_seq_cst) noexcept;

bool compare_exchange_strong(

BaseType & old_value, BaseType new_value,

memory_order success_order,

memory_order failure_order) volatile noexcept;

bool compare_exchange_strong(

BaseType & old_value, BaseType new_value,

memory_order success_order,

memory_order failure_order) noexcept;

bool compare_exchange_weak(

BaseType & old_value, BaseType new_value,

memory_order order = memory_order_seq_cst)

volatile noexcept;

bool compare_exchange_weak(

BaseType & old_value, BaseType new_value,

memory_order order = memory_order_seq_cst) noexcept;

bool compare_exchange_weak(

BaseType & old_value, BaseType new_value,

memory_order success_order,

memory_order failure_order) volatile noexcept;

bool compare_exchange_weak(

BaseType & old_value, BaseType new_value,

memory_order success_order,

memory_order failure_order) noexcept;

operator BaseType() const volatile noexcept;

operator BaseType() const noexcept;

};

template

bool atomic_is_lock_free(

volatile const atomic*) noexcept;

template

bool atomic_is_lock_free(const atomic*)

noexcept;

template

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

template

void atomic_init(atomic*, void*) noexcept;

template

BaseType atomic_exchange(

volatile atomic*, memory_order) noexcept;

template

BaseType atomic_exchange(

atomic*, memory_order) noexcept;

template

BaseType atomic_exchange_explicit(

volatile atomic*, memory_order) noexcept;

template

BaseType atomic_exchange_explicit(

atomic*, memory_order) noexcept;

template

void atomic_store(volatile atomic*, BaseType) noexcept;

template

void atomic_store(atomic*, BaseType) noexcept;

template

void atomic_store_explicit(

volatile atomic*, BaseType, memory_order) noexcept;

template

void atomic_store_explicit(

atomic*, BaseType, memory_order) noexcept;

template

BaseType atomic_load(volatile const atomic*) noexcept;