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

来自cppreference.com
< cpp‎ | memory‎ | shared ptr
 
 
工具库
通用工具
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中弃用)
整数比较函数
(C++20)(C++20)(C++20)
(C++20)
swap 与类型运算
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
常用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
初等字符串转换
(C++17)
(C++17)
 
动态内存管理
未初始化内存算法
受约束的未初始化内存算法
分配器
垃圾收集支持
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)



 
 
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_loadstd::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_explicitmo 不能是 std::memory_order_releasestd::memory_order_acq_rel
4) 等价于 atomic_store_explicit(p, r, memory_order_seq_cst)
5) 原子地存储共享指针 rp 所指向的共享指针,等效地执行 p->swap(r) 。同非特化的 std::atomic_store_explicitmo 不能是 std::memory_order_acquirestd::memory_order_acq_rel
6) 等价于 atomic_exchange_explicit(p, r, memory_order_seq_cst)
7) 原子地存储共享指针 rp 所指向的共享指针,并返回 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_ptratomic_weak_ptr ,以替换这些函数的使用。

这些函数被弃用,取代者是 std::atomic 模板的特化: std::atomic<std::shared_ptr>std::atomic<std::weak_ptr>

(C++20 起)

示例

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 2980 C++11 空的 shared_ptr 决不等价 若它们存储同一指针值则等价

参阅

检查对该原子类型的操作是否是无锁的
(函数模板)
原子地以非原子实参替换原子对象的值
(函数模板)
原子地获得存储于原子对象的值
(函数模板)
原子地以非原子实参的值替换原子对象的值,并返回该原子对象的旧值
(函数模板)
原子地比较原子对象和非原子实参的值,相等时进行原子交换,不相等时进行原子加载
(函数模板)