std::atomic_...<std::shared_ptr>

Определён в заголовочном файле `<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) Определяет, выполняется ли атомарный доступ к разделяемому указателю, на который указывает p, без блокировок.

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).

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	Применено к	Поведение в опубликованном стандарте	Исправленное поведение
LWG 2172	C++11	`expected` мог быть нулевым указателем	в этом случае поведение не определено
LWG 2980	C++11	пустые `shared_ptr` никогда не были эквивалентны	эквивалентны, если хранят одно и то же значение указателя

См. также

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

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