C++ 参考手册

位置：首页 > C++ 参考手册 >动态内存管理 >std::shared_ptr > std::atomic_...<std::shared_ptr>

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

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 的非 const 成员函数，则发生数据竞争，除非所有这种访问都通过这些作为对应原子访问函数（ 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, 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 。若它们等价（存储同一指针值，并且共享同一对象的所有权或均为空），则用 success 所指定的内存定序制约赋值 desired 给 *p 并返回 true 。若它们不等价，则用 failure 所指定的内存定序制约赋值 *p 给 *expected 并返回 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 对象中，再通过第二对象解引用，就不能解引用它。

并发 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 决不等价 若它们存储同一指针值则等价

参阅

(C++11)
 检查对该原子类型的操作是否是无锁的
(函数模板)
(C++11)(C++11)
 原子地以非原子实参替换原子对象的值
(函数模板)
(C++11)(C++11)
 原子地获得存储于原子对象的值
(函数模板)
(C++11)(C++11)
 原子地以非原子实参的值替换原子对象的值，并返回该原子对象的旧值
(函数模板)
(C++11)(C++11)(C++11)(C++11)
 原子地比较原子对象和非原子实参的值，若相等则进行 atomic_exchange，若不相等则进行 atomic_load
(函数模板)