std::atomic_...<std::shared_ptr> — cppreference.com

Определено в заголовочном файле `<memory>`
`template< class T > bool atomic_is_lock_free( const std::shared_ptr<T>* p );`	(1)	(начиная с C++11) (устарело в C++20)
`template< class T > std::shared_ptr<T> atomic_load( const std::shared_ptr<T>* p );`	(2)	(начиная с C++11) (устарело в C++20)
`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)
`template< class T > void atomic_store( std::shared_ptr<T>* p, std::shared_ptr<T> r );`	(4)	(начиная с C++11) (устарело в C++20)
`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)
`template< class T > std::shared_ptr<T> atomic_exchange( std::shared_ptr<T>* p, std::shared_ptr<T> r);`	(6)	(начиная с C++11) (устарело в C++20)
`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)
`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)
`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)
`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)
`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)

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

Обратите внимание, что блок управления shared_ptr является потокобезопасным: доступ к различным объектам std::shared_ptr можно получить с помощью mutable операций, таких как 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, 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, 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) Сравнивает общие указатели, на которые указывают p и expected. Если они эквивалентны (хранят одно и то же значение указателя и либо совместно владеют одним и тем же объектом, либо оба пусты), присваивает desired в *p с использованием ограничений упорядочивания памяти, указанных success, и возвращает true. Если они не эквивалентны, присваивает *p в *expected с использованием ограничений упорядочивания памяти, заданных failure, и возвращает false.

11) То же, что и (10), но может быть ложным сбоем.

Все эти функции вызывают неопределённое поведение, если 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,9,10,11) true, если общие указатели были эквивалентны и был выполнен обмен, false иначе.

Примечание

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

Чтобы избежать гонок данных, после передачи общего указателя любой из этих функций доступ к нему неатомарным образом становится невозможен. В частности, вы не можете разыменовать такой объект shared_ptr, не загрузив его сначала атомарно в другой объект shared_ptr, а затем разыменовав второй объект.

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

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

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

Пример

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

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 2980	C++11	пустые `shared_ptr` никогда не эквивалентны	эквивалентны, если они хранят одно и то же значение указателя