std::atomic(std::weak_ptr)
| Определено в заголовочном файле <memory>
|
||
template< class T > struct std::atomic<std::weak_ptr<T>>; |
(начиная с C++20) | |
Частичная специализация шаблона std::atomic для std::weak_ptr<T> позволяет пользователям атомарно манипулировать объектами weak_ptr.
Если несколько потоков выполнения обращаются к одному и тому же объекту std::weak_ptr без синхронизации, и любой из этих доступов использует неконстантную функцию-элемент класса weak_ptr, тогда гонка данных не произойдёт, если все такие доступы будут осуществляться через экземпляр std::atomic<std::weak_ptr>.
Связанные инкременты use_count гарантированно являются частью атомарной операции. Связанные декременты use_count следуют за атомарной операцией, но не обязаны быть её частью, за исключением изменения use_count при переопределении expected в неудачном CAS. Любое связанное удаление и освобождение выполняются после шага атомарного обновления и не являются частью атомарной операции.
Обратите внимание, что блок управления, используемый std::weak_ptr и std::shared_ptr, является потокобезопасным: к различным неатомарным объектам std::weak_ptr можно получить доступ с использованием mutable операций, таких как operator= или reset, одновременно нескольким потоками, даже если эти экземпляры являются копиями или иным образом совместно используют один и тот же внутренний блок управления.
Тип T может быть неполным типом.
Типы элементы
| Тип элемент | Определение |
value_type
|
std::weak_ptr<T>
|
Функции-элементы
Все неспециализированные функции std::atomic также предоставляются этой специализацией и не содержат дополнительных функций-элементов.
atomic<weak_ptr<T>>::atomic
<tbody> </tbody> constexpr atomic() noexcept = default; |
(1) | |
atomic(std::weak_ptr<T> desired) noexcept; |
(2) | |
atomic(const atomic&) = delete; |
(3) | |
weak_ptr<T> значением, созданным по умолчанию.weak_ptr<T> копией desired. Как и в случае любого типа std::atomic, инициализация не является атомарной операцией.atomic<weak_ptr<T>>::operator=
<tbody> </tbody> void operator=(const atomic&) = delete; |
(1) | |
void operator=(std::weak_ptr<T> desired) noexcept; |
(2) | |
store(desired).
atomic<weak_ptr<T>>::is_lock_free
<tbody> </tbody> bool is_lock_free() const noexcept; |
||
Возвращает true, если атомарные операции над всеми объектами этого типа не блокируются, иначе false.
atomic<weak_ptr<T>>::store
<tbody> </tbody> void store(std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
||
Атомарно заменяет значение *this значением desired как если бы это было p.swap(desired), где p базовый std::weak_ptr<T>. Память упорядочена в соответствии с order. Поведение не определено, если order равно std::memory_order_consume, std::memory_order_acquire или std::memory_order_acq_rel.
atomic<weak_ptr<T>>::load
<tbody> </tbody> std::weak_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const noexcept; |
||
Атомарно возвращает копию базового std::weak_ptr<T>. Память упорядочена в соответствии с order. Поведение не определено, если order равно std::memory_order_release или std::memory_order_acq_rel.
atomic<weak_ptr<T>>::operator std::weak_ptr<T>
<tbody> </tbody> operator std::weak_ptr<T>() const noexcept; |
||
Эквивалентно return load();.
atomic<weak_ptr<T>>::exchange
<tbody> </tbody> std::weak_ptr<T> exchange(std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
||
Атомарно заменяет базовый std::weak_ptr<T> на desired, как будто p.swap(desired), где p это базовый std::weak_ptr<T>, и возвращает копию значения, которое p имело непосредственно перед обменом. Память упорядочена в соответствии с order. Это атомарная операция чтения-изменения-записи.
atomic<weak_ptr<T>>::compare_exchange_weak, compare_exchange_strong
<tbody> </tbody> bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept; |
(1) | |
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept; |
(2) | |
bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
(3) | |
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
(4) | |
std::weak_ptr<T> хранит то же значение указателя, что и expected, и разделяет с ним владение, или если и базовый, и expected пусты, присваивает из desired базовому std::weak_ptr<T>, возвращает true и упорядочивает память в соответствии с success, иначе присваивает из базового std::weak_ptr<T> в expected, возвращает false и упорядочивает память в соответствии с failure. Поведение не определено, если failure равно std::memory_order_release или std::memory_order_acq_rel. В случае успеха операция является атомарной операцией чтения-изменения-записи для *this, а доступ к expected после атомарного обновления невозможен. В случае сбоя операция представляет собой атомарную операцию загрузки в *this, а expected обновляется существующим значением, считанным из атомарного объекта. Это обновление для use_count объекта expected является частью этой атомарной операции, хотя сама запись (и любое последующее освобождение/уничтожение) не требуется.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.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<weak_ptr<T>>::wait
<tbody> </tbody> void wait(std::weak_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.
Примечание: два std::weak_ptr эквивалентны, если они хранят один и тот же указатель и либо совместно владеют, либо оба пусты.
atomic<weak_ptr<T>>::notify_one
<tbody> </tbody> void notify_one() noexcept; |
||
Выполняет атомарную операцию уведомления.
Если есть поток, заблокированный в атомарных операциях ожидания (т.е. wait()) для *this, то разблокирует по крайней мере один такой поток; иначе ничего не делает.
atomic<weak_ptr<T>>::notify_all
<tbody> </tbody> void notify_all() noexcept; |
||
Выполняет атомарную операцию уведомления.
Разблокирует все потоки, заблокированные в атомарных операциях ожидания (т.е. wait()) для *this, если таковые имеются; иначе ничего не делает.
Константы элементы
Единственная стандартная константа-элемент is_always_lock_free класса std::atomic также предоставляется этой специализацией.
atomic<weak_ptr<T>>::is_always_lock_free
<tbody> </tbody> static constexpr bool is_always_lock_free = /*определено-реализацией*/; |
||
Пример
| Этот раздел не завершён Причина: нет примера |
Смотрите также
(C++11) |
шаблон класса atomic и его специализации для bool, целочисленных типов и указателей (шаблон класса) |
