Namespaces
Variants

std:: atomic <std::shared_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::shared_ptr
Member functions
Modifiers
Observers
(C++17)
( until C++20* )
(C++26)
(C++26)
Non-member functions
(C++20)
(C++20)
(C++17)
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
functions ( until C++26* )
Helper classes
atomic <std::shared_ptr>
(C++20)
Deduction guides (C++17)
Определено в заголовке <memory>
template < class T >
struct std:: atomic < std:: shared_ptr < T >> ;
(начиная с C++20)

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

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

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

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

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

Содержание

Типы членов

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

Функции-члены

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

atomic<shared_ptr<T>>:: atomic

constexpr atomic ( ) noexcept = default ;
(1)
constexpr atomic ( std:: nullptr_t ) noexcept : atomic ( ) { }
(2)
atomic ( std:: shared_ptr < T > desired ) noexcept ;
(3)
atomic ( const atomic & ) = delete ;
(4)
1,2) Инициализирует базовый shared_ptr < T > нулевым значением.
3) Инициализирует базовый shared_ptr < T > копией desired . Как и для любого типа std::atomic , инициализация не является атомарной операцией.
4) Атомарные типы не поддерживают копирование/перемещение.

atomic<shared_ptr<T>>:: operator=

void operator = ( const atomic & ) = delete ;
(1)
void operator = ( std:: shared_ptr < T > desired ) noexcept ;
(2)
void operator = ( std:: nullptr_t ) noexcept ;
(3)
1) Атомарные типы не поддерживают копирующее/перемещающее присваивание.
2) Присваивание значения, эквивалентно store ( desired ) .
3) Сбрасывает атомарный умный указатель в значение нулевого указателя. Эквивалентно store ( nullptr ) ; .

atomic<shared_ptr<T>>:: is_lock_free

bool is_lock_free ( ) const noexcept ;

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

atomic<shared_ptr<T>>:: store

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

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

atomic<shared_ptr<T>>:: load

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

atomic<shared_ptr<T>>:: operator std::shared_ptr<T>

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

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

atomic<shared_ptr<T>>:: exchange

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

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

bool compare_exchange_strong ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(1)
bool compare_exchange_weak ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(2)
bool compare_exchange_strong ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(3)
bool compare_exchange_weak ( std:: shared_ptr < T > & expected, std:: shared_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(4)
1) Если базовый std:: shared_ptr < T > хранит тот же T * что и expected и разделяет владение с ним, или если оба базовый и expected пусты, присваивает desired базовому std:: shared_ptr < T > , возвращает true и упорядочивает память согласно success , иначе присваивает из базового std:: shared_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<shared_ptr<T>>:: wait

void wait ( std:: shared_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 .

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

atomic<shared_ptr<T>>:: notify_one

void notify_one ( ) noexcept ;

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

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

atomic<shared_ptr<T>>:: notify_all

void notify_all ( ) noexcept ;

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

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

Константы-члены

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

atomic<shared_ptr<T>>:: is_always_lock_free

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

Примечания

Макрос тестирования возможностей Значение Стандарт Возможность
__cpp_lib_atomic_shared_ptr 201711L (C++20) std::atomic<std::shared_ptr>

Пример

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

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Applied to Behavior as published Correct behavior
LWG 3661 C++20 atomic<shared_ptr<T>> was not constant-initializable from nullptr made constant-initializable
LWG 3893 C++20 LWG3661 made atomic<shared_ptr<T>> not assignable from nullptr_t assignability restored

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

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