CKTIS / C++
Atómové načítanie `std::shared_ptr` s explicitným usporiadaním pamäte
V C++23 tento zastaraný variant funkcie atómovo kopíruje `std::shared_ptr` a umožňuje zvoliť usporiadanie pamäte pri načítaní.
Verzia: ISO C++23; implementation support may vary
Syntax
// 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);Tento variant voľnej funkcie std::atomic_load_explicit je deklarovaný v <memory>. Odovzdaj &slot, teda adresu objektu std::shared_ptr<T>, ktorého životnosť ešte trvá, nie adresu objektu, na ktorý ukazuje, ani adresu std::atomic<T>. Funkcia vracia kópiu typu std::shared_ptr<T> hodnotou a nevyhadzuje výnimky. Ak načítaná hodnota mala podiel na zdieľanom vlastníctve, kópia si ho zachová. Odovzdanie nulovej adresy pre slot spôsobí nedefinované správanie. Ukazovateľ uložený v slot však môže byť nulový; ak to prichádza do úvahy, pred dereferencovaním skontroluj výsledok.
V C++23 možno pri načítaní použiť std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire a std::memory_order_seq_cst. Použitie std::memory_order_release alebo std::memory_order_acq_rel vedie k nedefinovanému správaniu. Skrátený zápis std::atomic_load(&slot) používa std::memory_order_seq_cst.
Ak načítanie s poradím acquire prečíta hodnotu zapísanú do toho istého slot volaním std::atomic_store_explicit s std::memory_order_release, zápis sa synchronizuje s načítaním. Inicializácia pred zápisom je potom viditeľná pre kód po načítaní. Samostatná bariéra std::atomic_thread_fence(std::memory_order_release) pred týmto zápisom je pri takomto zverejnení nadbytočná. Načítanie s std::memory_order_relaxed je stále atómové, ale samo osebe túto synchronizáciu nezabezpečuje.
Ak k tomu istému slot pristupuje viac vlákien a aspoň jedno ho môže meniť, nekombinuj toto API s obyčajným kopírovaním, priraďovaním ani volaním reset() na tomto objekte, pokiaľ prístupy nesynchronizuješ samostatne. Napríklad obyčajné priradenie alebo volanie reset() v jednom vlákne môže viesť k dátovým pretekom s atómovým načítaním v inom vlákne. Atómové načítanie nechráni neskoršie zmeny objektu, na ktorý ukazovateľ ukazuje, a nie je zaručené, že prebehne bez zámkov. Tento variant bol zavedený v C++11, označený za zastaraný v C++20, ponechaný v C++23 a odstránený zo štandardu C++26. V novom kóde použi std::atomic<std::shared_ptr<T>> s metódami load(order) a store(value, order).
Prí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ýsledok
42
Jednovláknový program vypíše `42`, pretože `snapshot` si zachová podiel na zdieľanom vlastníctve aj po vyprázdnení `slot`. Ukazuje syntax a životnosť, nie synchronizáciu medzi vláknami.
Súvisiace lekcie
- C++ · Lekcia 37 · Pokročilá · Verzia: 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]