CKTIS / C++
Atomsko branje `std::shared_ptr` z izrecnim pomnilniškim vrstnim redom
V C++23 ta zastarela preobremenitev atomsko kopira `std::shared_ptr` in omogoča izbiro pomnilniškega vrstnega reda pri branju.
Različica: ISO C++23; implementation support may vary
Sintaksa
// 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);Ta preobremenitev proste funkcije std::atomic_load_explicit je deklarirana v <memory>. Podaj &slot, naslov objekta std::shared_ptr<T>, ki je še živ, ne pa naslova objekta, na katerega kaže, ali naslova objekta std::atomic<T>. Funkcija po vrednosti vrne kopijo tipa std::shared_ptr<T> in ne sproži izjem. Če je prebrana vrednost imela delež v skupnem lastništvu, ga kopija ohrani. Ničelni naslov za slot povzroči nedefinirano obnašanje. Kazalec, shranjen v slot, pa je lahko ničeln; če je to mogoče, pred dereferenciranjem preveri rezultat.
V C++23 so za branje dovoljeni std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire in std::memory_order_seq_cst. Uporaba std::memory_order_release ali std::memory_order_acq_rel povzroči nedefinirano obnašanje. Krajši zapis std::atomic_load(&slot) uporabi std::memory_order_seq_cst.
Če branje z vrstnim redom acquire prebere vrednost, ki jo je std::atomic_store_explicit z std::memory_order_release zapisala v isti slot, se zapis sinhronizira z branjem. Inicializacija pred zapisom je tako vidna kodi po branju. Dodatna pregrada std::atomic_thread_fence(std::memory_order_release) pred tem zapisom je pri taki objavi odveč. Branje z std::memory_order_relaxed je še vedno atomsko, vendar samo po sebi ne zagotavlja te sinhronizacije.
Če več niti dostopa do istega slot in ga lahko vsaj ena od njih spremeni, ne mešaj tega API-ja z navadnim kopiranjem, prirejanjem ali klici reset() na tem objektu, razen če so dostopi posebej sinhronizirani. Navadno prirejanje ali klic reset() v eni niti lahko na primer povzroči podatkovno tekmo z atomskim branjem v drugi niti. Atomsko branje ne varuje poznejših sprememb objekta, na katerega kaže kazalec, in ni nujno izvedeno brez zaklepanja. Preobremenitev je bila uvedena v C++11, označena kot zastarela v C++20, ohranjena v C++23 in odstranjena iz standarda C++26. V novi kodi uporabi std::atomic<std::shared_ptr<T>> z metodama load(order) in store(value, order).
Primeri
#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';
}Rezultat
42
Enonitni program izpiše `42`, ker `snapshot` obdrži delež v skupnem lastništvu tudi po izpraznitvi `slot`. Prikaže sintakso in življenjsko dobo, ne sinhronizacije med nitmi.
Povezane lekcije
- C++ · Lekcija 37 · Napredna · Različica: 3
Viri
- 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]