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)
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 могут быть обработаны с помощью изменяемых операций, таких как оператор= или 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_release или 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 в противном случае.

Примечания

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

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

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

(с C++20)

Пример

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

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

DR	Применено к	Поведение, как опубликовано	Правильное поведение
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/w/cpp/memory/shared_ptr/atomic