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
- C++23 final working draft (N4950) — shared_ptr atomic access [depr.util.smartptr.shared.atomic]
- WG21 P2869R0 — Remove Deprecated shared_ptr Atomic Access APIs From C++26
- C++ working draft — Annex D compatibility changes from ISO C++ 2023 [diff.cpp23.depr]
- C++ working draft — Order and consistency [atomics.order]
- C++ working draft — Fences [atomics.fences]
- C++ working draft — Partial specialization for shared_ptr [util.smartptr.atomic.shared]