std::atomic<std::shared_ptr>

atomic<shared_ptr<T>>::atomic

constexpr atomic() noexcept = default;

constexpr atomic( std::nullptr_t ) noexcept : atomic() {}

atomic( std::shared_ptr<T> desired ) noexcept;

atomic( const atomic& ) = delete;

atomic<shared_ptr<T>>::operator=

void operator=( const atomic& ) = delete;

void operator=( std::shared_ptr<T> desired ) noexcept;

void operator=( std::nullptr_t ) noexcept;

atomic<shared_ptr<T>>::is_lock_free

bool is_lock_free() const noexcept;

Возвращает true, если атомарные операции над всеми объектами этого типа выполняются без блокировок, и false в противном случае.

atomic<shared_ptr<T>>::store

void store( std::shared_ptr<T> desired,
            std::memory_order order = std::memory_order_seq_cst ) noexcept;

Атомарно заменяет значение *this значением desired, как если бы выполнялось p.swap(desired), где p — базовый std::shared_ptr<T>. Порядок операций с памятью определяется согласно order.

Если order имеет значение std::memory_order_consume, std::memory_order_acquire или std::memory_order_acq_rel, поведение не определено.

atomic<shared_ptr<T>>::load

std::shared_ptr<T> load( std::memory_order order =
                             std::memory_order_seq_cst ) const noexcept;

Атомарно возвращает копию базового shared-указателя. Порядок операций с памятью определяется согласно order.

Если order имеет значение std::memory_order_release или std::memory_order_acq_rel, поведение не определено.

atomic<shared_ptr<T>>::operator std::shared_ptr<T>

operator std::shared_ptr<T>() const noexcept;

Эквивалентно return load();.

atomic<shared_ptr<T>>::exchange

std::shared_ptr<T> exchange( std::shared_ptr<T> desired,
                             std::memory_order order =
                                 std::memory_order_seq_cst ) noexcept;

Атомарно заменяет базовый std::shared_ptr<T> значением desired, как если бы выполнялось p.swap(desired), где p — базовый std::shared_ptr<T>, и возвращает копию значения, которое p имел непосредственно перед обменом. Порядок операций с памятью определяется согласно order. Это атомарная операция чтения-модификации-записи.

atomic<shared_ptr<T>>::compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong
    ( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,
      std::memory_order success, std::memory_order failure ) noexcept;

bool compare_exchange_weak
    ( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,
      std::memory_order success, std::memory_order failure ) noexcept;

bool compare_exchange_strong
    ( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,
      std::memory_order order = std::memory_order_seq_cst ) noexcept;

bool compare_exchange_weak
    ( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,
      std::memory_order order = std::memory_order_seq_cst ) noexcept;

• В случае успеха операция является атомарной операцией чтения-модификации-записи над *this, а к expected после атомарного обновления не обращаются.
• В случае неудачи операция является атомарной операцией загрузки из *this, а expected обновляется значением, прочитанным из атомарного объекта. Это обновление expected's use_count является частью атомарной операции, хотя сама запись (и любое последующее освобождение памяти или уничтожение) не обязана быть её частью.

atomic<shared_ptr<T>>::wait

void wait( std::shared_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, поведение не определено.

Примечание: два объекта shared_ptr эквивалентны, если они хранят один и тот же указатель и либо разделяют владение, либо оба пусты.

atomic<shared_ptr<T>>::notify_one

void notify_one() noexcept;

Выполняет атомарное уведомление.

Если какой-либо поток заблокирован в ожидании атомарной операции (то есть выполняет wait()) на *this, разблокирует как минимум один такой поток; в противном случае ничего не делает.

atomic<shared_ptr<T>>::notify_all

void notify_all() noexcept;

Выполняет атомарное уведомление.

Разблокирует все потоки, заблокированные в ожидании атомарной операции (то есть выполняющие wait()) на *this, если такие есть.

atomic<shared_ptr<T>>::is_always_lock_free

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