Namespaces
Variants

std:: atomic <std::weak_ptr>

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
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, если атомарные операции над всеми объектами данного типа являются lock-free, и 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 > . Память упорядочивается в соответствии с 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 > на 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 обновляется существующим значением, прочитанным из атомарного объекта. Это обновление use_count для 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 = /*определяется реализацией*/ ;

Пример

Этот раздел не завершён
Причина: отсутствует пример

Смотрите также

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