Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../error/error_code/../../memory/weak_ptr/atomic2.html below:

std::atomic<std::weak_ptr> - cppreference.com

The partial template specialization of std::atomic for std::weak_ptr<T> allows users to manipulate weak_ptr objects atomically.

If multiple threads of execution access the same std::weak_ptr object without synchronization and any of those accesses uses a non-const member function of weak_ptr then a data race will occur unless all such access is performed through an instance of std::atomic<std::weak_ptr>.

Associated use_count increments are guaranteed to be part of the atomic operation. Associated use_count decrements are sequenced after the atomic operation, but are not required to be part of it, except for the use_count change when overriding expected in a failed CAS. Any associated deletion and deallocation are sequenced after the atomic update step and are not part of the atomic operation.

Note that the control block used by std::weak_ptr and std::shared_ptr is thread-safe: different non-atomic std::weak_ptr objects can be accessed using mutable operations, such as operator= or reset, simultaneously by multiple threads, even when these instances are copies or otherwise share the same control block internally.

The type T may be an incomplete type.

All non-specialized std::atomic functions are also provided by this specialization, and no additional member functions.

constexpr atomic() noexcept = default;

atomic(const atomic&) = delete;

1) Initializes the underlying weak_ptr<T> to default-constructed value.

Initializes the underlying

to a copy of

. As with any

type, initialization is not an atomic operation.

3) Atomic types are not copy/move constructible.

void operator=(const atomic&) = delete;

1) Atomic types are not copy/move assignable.

2) Value assignment, equivalent to store(desired).

bool is_lock_free() const noexcept;

Returns true if the atomic operations on all objects of this type are lock-free, false otherwise.

Equivalent to return load();.

Atomically replaces the underlying std::weak_ptr<T> with desired as if by p.swap(desired) where p is the underlying std::weak_ptr<T>, and returns a copy of the value that p had immediately before the swap. Memory is ordered according to order. This is an atomic read-modify-write operation.

If the underlying

stores the same pointer value as

and shares ownership with it, or if both underlying and

are empty, assigns from

to the underlying

, returns

, and orders memory according to

, otherwise assigns from the underlying

to

, returns

, and orders memory according to

. The behavior is undefined if

is

or

. On success, the operation is an atomic read-modify-write operation on

and

is not accessed after the atomic update. On failure, the operation is an atomic load operation on

and

is updated with the existing value read from the atomic object. This update to

's use_count is part of this atomic operation, although the write itself (and any subsequent deallocation/destruction) is not required to be.

2) Same as (1), but may also fail spuriously.

Performs an atomic waiting operation.

Compares load(order) with old and if they are equivalent then blocks until *this is notified by notify_one() or notify_all(). This is repeated until load(order) changes. This function is guaranteed to return only if value has changed, even if underlying implementation unblocks spuriously.

Memory is ordered according to order. The behavior is undefined if order is std::memory_order_release or std::memory_order_acq_rel.

Notes: two std::weak_ptrs are equivalent if they store the same pointer and either share ownership or are both empty.

void notify_one() noexcept;

Performs an atomic notifying operation.

If there is a thread blocked in atomic waiting operations (i.e. wait()) on *this, then unblocks at least one such thread; otherwise does nothing.

void notify_all() noexcept;

Performs an atomic notifying operation.

Unblocks all threads blocked in atomic waiting operations (i.e. wait()) on *this, if there are any; otherwise does nothing.

The only standard std::atomic member constant is_always_lock_free is also provided by this specialization.

static constexpr bool is_always_lock_free = /*implementation-defined*/;

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4