Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Atomické načtení `std::shared_ptr` s explicitním uspořádáním paměti

V C++23 tato zastaralá varianta funkce atomicky kopíruje `std::shared_ptr` a umožňuje zvolit uspořádání paměti při načítání.

Verze: ISO C++23; implementation support may vary

Syntaxe

// ISO C++23 — declared in <memory>
namespace std {
    template<class T>
    shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order order);
}

// For std::shared_ptr<T> slot:
auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);

Tato varianta volné funkce std::atomic_load_explicit je deklarována v <memory>. Předej &slot, tedy adresu objektu std::shared_ptr<T>, jehož životnost trvá, nikoli adresu odkazovaného objektu ani adresu std::atomic<T>. Funkce vrací kopii typu std::shared_ptr<T> hodnotou a nevyhazuje výjimky. Pokud se načtená hodnota podílela na sdíleném vlastnictví, kopie si tento podíl zachová. Předání nulové adresy pro slot způsobí nedefinované chování. Ukazatel uložený v slot však může být nulový; pokud to připadá v úvahu, zkontroluj výsledek před dereferencováním.

V C++23 lze při načítání použít std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire a std::memory_order_seq_cst. Použití std::memory_order_release nebo std::memory_order_acq_rel vede k nedefinovanému chování. Zkrácený zápis std::atomic_load(&slot) používá std::memory_order_seq_cst.

Pokud načtení s pořadím acquire přečte hodnotu zapsanou do téhož slot voláním std::atomic_store_explicit s std::memory_order_release, zápis se synchronizuje s načtením. Inicializace před zápisem je pak viditelná pro kód po načtení. Samostatná bariéra std::atomic_thread_fence(std::memory_order_release) před tímto zápisem je pro takové zveřejnění nadbytečná. Načtení s std::memory_order_relaxed je stále atomické, ale samo tuto synchronizaci nezajišťuje.

Pokud k témuž slot přistupuje více vláken a alespoň jedno ho může měnit, nekombinuj toto API s běžným kopírováním, přiřazením či voláním reset() nad tímto objektem, pokud přístupy nesynchronizuješ samostatně. Například běžné přiřazení nebo volání reset() v jednom vlákně může vést k datovému závodu s atomickým načtením v jiném vlákně. Atomické načtení nechrání pozdější změny odkazovaného objektu a není zaručeno, že proběhne bez zámků. Tato varianta byla zavedena v C++11, označena za zastaralou v C++20, ponechána v C++23 a odstraněna ze standardu C++26. V novém kódu použij std::atomic<std::shared_ptr<T>> s metodami load(order) a store(value, order).

Příklady

#include <atomic>
#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<const int> slot;
    std::atomic_store_explicit(&slot, std::make_shared<const int>(42),
                               std::memory_order_release);

    const auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);

    std::atomic_store_explicit(&slot, std::shared_ptr<const int>{},
                               std::memory_order_relaxed);
    std::cout << *snapshot << '\n';
}

Výsledek

42

Jednovláknový program vypíše `42`, protože `snapshot` si ponechá podíl na sdíleném vlastnictví i po vyprázdnění `slot`. Ukazuje syntaxi a životnost, nikoli synchronizaci mezi vlákny.

Související lekce

  • C++ · Lekce 37 · Pokročilá · Verze: 3

Zdroje