std::atomic(std::weak_ptr)

Определено в заголовке `<memory>`
template< class T > struct std::atomic<std::weak_ptr<T>>;		(с C++20)

Частичная шаблонная специализация std::atomic для std::weak_ptr<T> позволяет пользователям атомарно манипулировать объектами weak_ptr.

Если несколько потоков обращаются к одному и тому же объекту std::weak_ptr без синхронизации, и любое из этих обращений использует не-константный член-функции weak_ptr, то произойдёт гонка данных, если все такие обращения не выполняются через экземпляр std::atomic<std::weak_ptr>.

Связанные use_count инкременты гарантированы как часть атомарной операции. Связанные use_count декременты упорядочены после атомарной операции, но не обязаны быть частью её, за исключением изменения use_count, при переопределении expected в случае неудачного CAS. Любые связанные удаления и выделение памяти упорядочены после атомарного шага обновления и не являются частью атомарной операции.

Обратите внимание, что управляющий блок, используемый std::weak_ptr и std::shared_ptr является потокобезопасным: к различным не-атомарным объектам std::weak_ptr можно получить доступ с помощью изменяемых операций, таких как operator= или reset, одновременно несколькими потоками, даже если эти экземпляры являются копиями или каким-либо иным образом совместно используют тот же управляющий блок внутри.

Тип T может быть неполным типом.

Типы членов

Тип члена	Определение
`value_type`	`std::weak_ptr<T>`

Член-функции

Все неспециализированные std::atomic функции также предоставляются этой специализацией, и никаких дополнительных член-функций.

atomic<weak_ptr<T>>::atomic

constexpr atomic() noexcept = default;	(1)
atomic(std::weak_ptr<T> desired) noexcept;	(2)
atomic(const atomic&) = delete;	(3)

1) Инициализирует базовый weak_ptr<T> значением по умолчанию.

2) Инициализирует базовый weak_ptr<T> копией desired. Как и для любого типа std::atomic, инициализация не является атомарной операцией.

3) Атомарные типы не поддерживают копирование/перемещение.

atomic<weak_ptr<T>>::operator=

void operator=(const atomic&) = delete;	(1)
void operator=(std::weak_ptr<T> desired) noexcept;	(2)

1) Атомарные типы не поддерживают копирование/перемещение.

2) Присваивание значения, эквивалентно store(desired).

atomic<weak_ptr<T>>::is_lock_free

bool is_lock_free() const noexcept;

Возвращает true, если атомарные операции для всех объектов этого типа выполняются без блокировок, иначе false.

atomic<weak_ptr<T>>::store

void store(std::weak_ptr<T> desired,
           std::memory_order order = std::memory_order_seq_cst) noexcept;

Атомарно заменяет значение *this значением desired как если бы при помощи p.swap(desired), где p — базовый std::weak_ptr<T>. Порядок памяти соответствует order. Поведение не определено, если order — std::memory_order_consume, std::memory_order_acquire, или std::memory_order_acq_rel.

atomic<weak_ptr<T>>::load

std::weak_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const noexcept;

Атомарно возвращает копию базового std::weak_ptr<T>. Порядок памяти соответствует order. Поведение не определено, если order — std::memory_order_release или std::memory_order_acq_rel.

atomic<weak_ptr<T>>::operator std::weak_ptr<T>

operator std::weak_ptr<T>() const noexcept;

Эквивалентно return load();.

atomic<weak_ptr<T>>::exchange

std::weak_ptr<T> exchange(std::weak_ptr<T> desired,
                          std::memory_order order = std::memory_order_seq_cst) noexcept;

Атомарно заменяет базовый std::weak_ptr<T> на desired как если бы при помощи p.swap(desired), где p — базовый std::weak_ptr<T>, и возвращает копию значения, которое у p было непосредственно перед обменом. Порядок памяти соответствует order. Это атомарная операция «чтение-модификация-запись».

atomic<weak_ptr<T>>::compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept;	(1)
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept;	(2)
bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept;	(3)
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept;	(4)

1) Если базовый std::weak_ptr<T> хранит то же значение указателя, что и expected и совместно владеет им, или если оба базовое и expected пустые, присваивает из desired базовому std::weak_ptr<T>, возвращает true, и упорядочивает память согласно success, в противном случае присваивает из базового std::weak_ptr<T> в expected, возвращает false, и упорядочивает память согласно failure. Поведение не определено, если failure — std::memory_order_release или std::memory_order_acq_rel. При успехе операция является атомарной операцией «чтение-модификация-запись» над *this, и expected не обращается после атомарного обновления. При ошибке операция является атомарной операцией чтения из *this, и expected обновляется существующим значением, прочитанным из атомарного объекта. Это обновление счётчика ссылок expected является частью этой атомарной операции, хотя сама запись (и любые последующие удаления/уничтожения) не обязаны быть.

2) То же, что и (1), но может также ошибаться случайным образом.

3) Эквивалентно: return compare_exchange_strong(expected, desired, order, fail_order);, где fail_order такое же, как order за исключением того, что std::memory_order_acq_rel заменено на std::memory_order_acquire, а std::memory_order_release заменено на std::memory_order_relaxed.

4) Эквивалентно: return compare_exchange_weak(expected, desired, order, fail_order);, где fail_order такое же, как order за исключением того, что std::memory_order_acq_rel заменено на std::memory_order_acquire, а std::memory_order_release заменено на std::memory_order_relaxed.

atomic<weak_ptr<T>>::wait

void wait(std::weak_ptr<T> old
          std::memory_order order = std::memory_order_seq_cst) const noexcept;

Выполняет атомарную операцию ожидания.

Сравнивает load(order) с old и, если они эквивалентны, блокируется до тех пор, пока *this не уведомит notify_one() или notify_all(). Это повторяется до тех пор, пока load(order) не изменится. Эта функция гарантирует возвращение только при изменении значения, даже если базовая реализация разблокирует её ошибочно.

Порядок памяти соответствует order. Поведение не определено, если order — std::memory_order_release или std::memory_order_acq_rel.

Примечания: два std::weak_ptr эквивалентны, если они хранят один и тот же указатель и либо совместно владеют им, либо оба пусты.

atomic<weak_ptr<T>>::notify_one

void notify_one() noexcept;

Выполняет атомарную операцию уведомления.

Если есть поток, заблокированный в операциях атомарного ожидания (т.е. wait()) по *this, то разблокируется, по крайней мере, один такой поток; в противном случае ничего не происходит.

atomic<weak_ptr<T>>::notify_all

void notify_all() noexcept;

Выполняет атомарную операцию уведомления.

Разблокирует все потоки, заблокированные в операциях атомарного ожидания (т.е. wait()) по *this, если таковые имеются; в противном случае ничего не происходит.

Член-константы

Единственная стандартная std::atomic член-константа is_always_lock_free также предоставляется этой специализацией.

atomic<weak_ptr<T>>::is_always_lock_free

static constexpr bool is_always_lock_free = /*implementation-defined*/;

Пример

См. также

atomic

(C++11)

шаблон класса atomic и специализации для bool, целых, чисел с плавающей точкой,(с C++20) и указателей
(шаблон класса)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/memory/weak_ptr/atomic2