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)
atomic_xxx
functions ( until C++26* )
Helper classes
(C++20)
Deduction guides (C++17)
(Примечание: В данном фрагменте HTML отсутствует текстовое содержимое для перевода - присутствуют только HTML-теги и атрибуты, которые согласно инструкциям не подлежат переводу)
Определено в заголовке <memory>
template < class T >
bool atomic_is_lock_free ( const std:: shared_ptr < T > * p ) ;
(1) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >
std:: shared_ptr < T > atomic_load ( const std:: shared_ptr < T > * p ) ;
(2) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

std:: shared_ptr < T > atomic_load_explicit

( const std:: shared_ptr < T > * p, std:: memory_order mo ) ;
(3) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >
void atomic_store ( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(4) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

void atomic_store_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > r,

std:: memory_order mo ) ;
(5) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

std:: shared_ptr < T > atomic_exchange

( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(6) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

std:: shared_ptr < T > atomic_exchange_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > r,

std:: memory_order mo ) ;
(7) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

bool atomic_compare_exchange_weak
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,

std:: shared_ptr < T > desired ) ;
(8) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

bool atomic_compare_exchange_strong
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,

std:: shared_ptr < T > desired ) ;
(9) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

bool atomic_compare_exchange_strong_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,
std:: shared_ptr < T > desired,

std:: memory_order success, std:: memory_order failure ) ;
(10) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)
template < class T >

bool atomic_compare_exchange_weak_explicit
( std:: shared_ptr < T > * p, std:: shared_ptr < T > * expected,
std:: shared_ptr < T > desired,

std:: memory_order success, std:: memory_order failure ) ;
(11) (начиная с C++11)
(устарело в C++20)
(удалено в C++26)

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

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

1) Определяет, является ли атомарный доступ к shared pointer, на который указывает p , lock-free.
2) Эквивалентно atomic_load_explicit ( p, std:: memory_order_seq_cst ) .
3) Возвращает умный указатель, на который указывает p .
Как и в случае с неспециализированным std::atomic_load_explicit , если mo является std:: memory_order_release или std:: memory_order_acq_rel , поведение не определено.
4) Эквивалентно atomic_store_explicit ( p, r, std:: memory_order_seq_cst ) .
5) Атомарно сохраняет умный указатель r в умный указатель, на который указывает p , как если бы с помощью p - > swap ( r ) .
Как и в случае с неспециализированной std::atomic_store_explicit , если mo является std:: memory_order_acquire или std:: memory_order_acq_rel , поведение не определено.
6) Эквивалентно atomic_exchange_explicit ( p, r, std:: memory_order_seq_cst ) .
7) Сохраняет умный указатель r в умный указатель, на который указывает p и возвращает значение, ранее хранившееся в p , атомарно, как если бы было выполнено p - > swap ( r ) и возвращает копию r после обмена.
8) Эквивалентно
atomic_compare_exchange_weak_explicit
( p, expected, desired, std:: memory_order_seq_cst ,
std:: memory_order_seq_cst ) .
**Примечание:** Весь текст в данном фрагменте находится внутри тегов ` `, которые обозначают код на C++. Согласно вашим инструкциям, код на C++ (включая имена функций, переменные и специфические термины) не переводится. Поэтому весь представленный текст остается без изменений.
9) Эквивалентно
atomic_compare_exchange_strong_explicit
( p, expected, desired, std:: memory_order_seq_cst ,
std:: memory_order_seq_cst ) .
10,11) Сравнивает умные указатели, на которые указывают p и expected .
  • Если они эквивалентны (хранят одинаковое значение указателя и либо совместно владеют одним объектом, либо оба пусты), присваивает desired в * p с использованием ограничений упорядочения памяти, заданных success , и возвращает true .
  • Если они не эквивалентны, присваивает * p в * expected с использованием ограничений упорядочения памяти, заданных failure , и возвращает false .
atomic_compare_exchange_weak_explicit может ложно завершиться неудачей.
Если expected является нулевым указателем, или failure равен std:: memory_order_release или std:: memory_order_acq_rel , поведение не определено.

Если p является нулевым указателем, поведение всех этих функций не определено.

Содержание

Параметры

p, expected - указатель на std::shared_ptr
r, desired - указатель std::shared_ptr
mo, success, failure - селекторы порядка памяти типа std::memory_order

Исключения

Эти функции не вызывают исключений.

Возвращаемое значение

1) true если атомарный доступ реализован с использованием инструкций без блокировок.
2,3) Копия указанного умного указателя с подсчётом ссылок.
4,5) (нет)
6,7) Копия ранее указывавшего разделяемого указателя.
8-11) true если разделяемые указатели были эквивалентны и обмен был выполнен, false в противном случае.

Примечания

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

Concurrency TS предлагает классы атомарных умных указателей atomic_shared_ptr и atomic_weak_ptr в качестве замены использования этих функций.

Эти функции были объявлены устаревшими в пользу специализаций шаблона std::atomic : std:: atomic < std:: shared_ptr > и std:: atomic < std:: weak_ptr > .

(начиная с C++20)
(до C++26)

Эти функции были удалены в пользу специализаций шаблона std::atomic : std:: atomic < std:: shared_ptr > и std:: atomic < std:: weak_ptr > .

(начиная с C++26)

Пример

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

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

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

DR Applied to Behavior as published Correct behavior
LWG 2172 C++11 expected could be a null pointer the behavior is undefined in this case
LWG 2980 C++11 empty shared_ptr s were never equivalent equivalent if they store the same pointer value

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

(C++11)
проверяет, являются ли операции атомарного типа свободными от блокировок
(шаблон функции)
(C++11) (C++11)
атомарно заменяет значение атомарного объекта неатомарным аргументом
(шаблон функции)
(C++11) (C++11)
атомарно получает значение, хранящееся в атомарном объекте
(шаблон функции)
(C++11) (C++11)
атомарно заменяет значение атомарного объекта неатомарным аргументом и возвращает старое значение атомарного объекта
(шаблон функции)
(C++11) (C++11) (C++11) (C++11)
атомарно сравнивает значение атомарного объекта с неатомарным аргументом и выполняет атомарный обмен при равенстве или атомарную загрузку при неравенстве
(шаблон функции)