std::atomic_is_lock_free<std::shared_ptr>, std::atomic_load<std::shared_ptr>, std::atomic_store<std::shared_ptr>, std::atomic_...<std::shared_ptr>

来自cppreference.com
< cpp‎ | memory‎ | shared ptr

 
 
 
 
std::shared_ptr
成员函数
修改器
观察器
非成员函数
atomic_is_lock_freeatomic_loadatomic_load_explicitatomic_storeatomic_store_explicitatomic_exchangeatomic_exchange_explicitatomic_compare_exchange_weakatomic_compare_exchange_strongatomic_compare_exchange_weak_explicitatomic_compare_exchange_strong_explicit
推导指引(C++17)
 
template< class T >
bool atomic_is_lock_free( const std::shared_ptr<T>* p );
(1) (C++11 起)
template< class T >
std::shared_ptr<T> atomic_load( const std::shared_ptr<T>* p );
(2) (C++11 起)
template< class T >

std::shared_ptr<T> atomic_load_explicit( const shared_ptr<T>* p,

                                         std::memory_order mo );
(3) (C++11 起)
template< class T >

void atomic_store( std::shared_ptr<T>* p,

                   std::shared_ptr<T> r );
(4) (C++11 起)
template< class T >

void atomic_store_explicit( std::shared_ptr<T>* p,
                            shared_ptr<T> r,

                            std::memory_order mo);
(5) (C++11 起)
template< class T >

std::shared_ptr<T> atomic_exchange( std::shared_ptr<T>* p,

                                    std::shared_ptr<T> r);
(6) (C++11 起)
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 起)
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 起)
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 起)
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 起)
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 起)
如果执行的多个线程访问该对象所引用的相同std::shared_ptr不同步,数据争用可能发生,除非所有这些访问都是通过这些功能,相应的原子访问函数的偏特化(std::atomic_loadstd::atomic_store等)
原文:
If multiple threads of execution access the object referenced by the same std::shared_ptr without synchronization, a data race may occur, unless all such access is performed through these functions, which are partial specializations of the corresponding atomic access functions (std::atomic_load, std::atomic_store, etc)
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
{{{1}}}
原文:
{{{2}}}
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
1)
确定原子访问的共享指针指向的p是无锁的
原文:
Determines whether atomic access to the shared pointer pointed-to by p is lock-free.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
2)
相当于atomic_load_explicit(p, std::memory_order_seq_cst)
原文:
Equivalent to atomic_load_explicit(p, std::memory_order_seq_cst)
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
3)
返回的共享指针指向的p。至于与非专门std::atomic_load_explicitmo不能是std::memory_order_releasestd::memory_order_acq_rel
原文:
Returns the shared pointer pointed-to by p. As with the non-specialized std::atomic_load_explicit, mo cannot be std::memory_order_release or std::memory_order_acq_rel
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
4)
相当于atomic_store_explicit(p, r, memory_order_seq_cst)
原文:
Equivalent to atomic_store_explicit(p, r, memory_order_seq_cst)
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
5)
交换共享指针pr,有效地执行p->swap(r)。至于与非专门std::atomic_store_explicitmo不能是std::memory_order_acquirestd::memory_order_acq_rel
原文:
Swaps the shared pointers p and r, effectively executing p->swap(r). As with the non-specialized std::atomic_store_explicit, mo cannot be std::memory_order_acquire or std::memory_order_acq_rel
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
6)
相当于atomic_exchange_explicit(p, r, memory_order_seq_cst)
原文:
Equivalent to atomic_exchange_explicit(p, r, memory_order_seq_cst)
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
7)
交换共享的指针prp->swap(r),有效地执行,并返回一个副本的共享指针前身为指向的p
原文:
Swaps the shared pointers p and r, effectively executing p->swap(r) and returns a copy of the shared pointer formerly pointed-to by p
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
8)
相当于atomic_compare_exchange_weak_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)
原文:
Equivalent to 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)
原文:
Equivalent to atomic_compare_exchange_strong_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
10)
比较的共享指针指向的pexpected。如果他们是等价的(股份拥有权相同的指针,是指在同一个指针),分配desired*p使用的内存success,并返回true指定顺序的约束。如果他们是不等价的,分配*p*expected使用内存排序failure返回指定约束false.
原文:
Compares the shared pointers pointed-to by p and expected. If they are equivalent (share ownership of the same pointer and refer to the same pointer), assigns desired into *p using the memory ordering constraints specified by success and returns true. If they are not equivalent, assigns *p into *expected using the memory ordering constraints specified by failure and returns false.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
11)
一样的10),但可能意外失败.
原文:
Same as 10), but may fail spuriously.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
所有这些函数调用未定义的行为,如果p是一个空指针.
原文:
All these functions invoke undefined behavior if p is a null pointer.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

目录

[编辑] 参数

p, expected -
一个指针到std::shared_ptr
原文:
a pointer to a std::shared_ptr
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
r, desired - a std::shared_ptr
mo, success, failure -
内存排序类型std::memory_order的选择
原文:
memory ordering selectors of type std::memory_order
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

[编辑] 例外

这些功能不会抛出异常.
原文:
These functions do not throw exceptions.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

[编辑] 返回

1)
true如果使用无锁的指令来实现的原子访问
原文:
true if atomic access is implemented using lock-free instructions
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
@ 2,3 @指向的共享指针的副本.
原文:
@2,3@ A copy of the pointed-to shared pointer.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
@ 4,5 @没有
原文:
@4,5@ nothing
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
@ 6,7 @ A的前身为指向的共享指针的副本
原文:
@6,7@ A copy of the formerly pointed-to shared pointer
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。
@ 8,9,10,11 @true如果共享指针,相当于进行交流,false否则.
原文:
@8,9,10,11@ true if the shared pointers were equivalent and the exchange was performed, false otherwise.
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

[编辑] 另请参阅

检查对该原子类型的操作是否是无锁的
(函数模板) [编辑]
以原子方式将原子对象的值替换为非原子对象的值
原文:
atomically replaces the value of the atomic object with a non-atomic argument
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

(函数模板) [编辑]
以原子方式获取原子对象中的值
原文:
atomically obtains the value stored in an atomic object
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

(函数模板) [编辑]
以原子方式将原子对象的值替换为非原子对象的值,并返回原子对象的旧值
原文:
atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

(函数模板) [编辑]
以原子方式比较原子对象和非原子对象的值,如果相等则执行原子交换,如果不相等则执行原子加载
原文:
atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not
文本通过谷歌翻译机器翻译。
你可以帮忙校正和验证翻译。点击此处查看指示。

(函数模板) [编辑]