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:: shared_ptr < T > 的 std::atomic 部分模板特化允许用户以原子方式操作 shared_ptr 对象。

若多个执行线程在无同步的情况下访问同一 std::shared_ptr 对象，且任一访问操作使用了 shared_ptr 的非 const 成员函数，则会出现数据竞争，除非所有此类访问均通过 std:: atomic < std:: shared_ptr > 实例（或自 C++20 起已弃用的 独立函数 ）进行。

关联的 use_count 递增保证是原子操作的一部分。关联的 use_count 递减在原子操作之后按序发生，但不要求作为其组成部分，除非在失败的CAS操作中覆盖 expected 时引发的 use_count 变更。所有关联的删除和释放操作都在原子更新步骤之后按序执行，且不属于原子操作组成部分。

请注意， 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 ，否则返回 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 会更新为从原子对象读取的现有值。对 expected 的 use_count 的更新属于此原子操作的一部分，但实际的写入操作（及后续的任何释放/销毁操作）不要求是原子的。
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 ;

执行原子通知操作。

如果在 * this 上存在因原子等待操作（即 wait() ）而阻塞的线程，则解除至少一个此类线程的阻塞；否则不执行任何操作。

atomic<shared_ptr<T>>:: notify_all

void notify_all ( ) noexcept ;

执行原子通知操作。

解除所有在 * this 上原子等待操作（即 wait() ）中被阻塞的线程（如果存在）；否则不执行任何操作。

成员常量

唯一的标准 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++ 标准。

缺陷报告 适用范围 发布时行为 正确行为
LWG 3661 C++20 atomic<shared_ptr<T>> 无法通过 nullptr 进行常量初始化 改为支持常量初始化
LWG 3893 C++20 LWG3661 导致 atomic<shared_ptr<T>> 无法从 nullptr_t 赋值 恢复赋值能力

参阅

(C++11)
原子类模板及其针对布尔型、整型、 浮点型 (C++20 起) 和指针类型的特化
(类模板)