CKTIS / C++
`std::shared_ptr` atomair laden met expliciete geheugenordening
In C++23 kopieert deze verouderde overload een `std::shared_ptr` atomair en kun je de geheugenordening van de leesbewerking kiezen.
Versie: 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);Deze overload van de vrije functie std::atomic_load_explicit is gedeclareerd in <memory>. Geef &slot door: het adres van een std::shared_ptr<T> waarvan de levensduur nog niet is afgelopen, niet het adres van het aangewezen object of van een std::atomic<T>. De functie geeft een kopie van het type std::shared_ptr<T> terug als waarde en werpt geen uitzonderingen op. Als de geladen waarde mede-eigenaar was, blijft de kopie mede-eigenaar. Een nuladres voor slot leidt tot ongedefinieerd gedrag. De pointer in slot mag wel null zijn; controleer bij die mogelijkheid het resultaat voordat je het dereferentieert.
In C++23 zijn std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire en std::memory_order_seq_cst geldige geheugenordeningen voor het laden. Met std::memory_order_release of std::memory_order_acq_rel is het gedrag ongedefinieerd. De verkorte vorm std::atomic_load(&slot) gebruikt std::memory_order_seq_cst.
Als een acquire-load de waarde leest die std::atomic_store_explicit met std::memory_order_release in dezelfde slot heeft geschreven, synchroniseert de schrijfbewerking met de leesbewerking. Initialisatie vóór de schrijfbewerking is dan zichtbaar voor code na de leesbewerking. Een aparte barrière std::atomic_thread_fence(std::memory_order_release) vóór die schrijfbewerking is voor deze publicatie overbodig. Laden met std::memory_order_relaxed blijft atomair, maar zorgt op zichzelf niet voor die synchronisatie.
Als meerdere threads dezelfde slot benaderen en minstens één thread die kan wijzigen, combineer deze API dan niet met gewoon kopiëren, toewijzen of aanroepen van reset() op die slot, tenzij de toegangen apart worden gesynchroniseerd. Zo kan een gewone toewijzing of een aanroep van reset() in de ene thread een datarace veroorzaken met een atomaire leesbewerking in een andere thread. Atomair laden beschermt latere wijzigingen aan het aangewezen object niet en is niet gegarandeerd lockvrij. Deze overload is ingevoerd in C++11, als verouderd aangemerkt in C++20, behouden in C++23 en verwijderd uit de C++26-standaard. Gebruik voor nieuwe code std::atomic<std::shared_ptr<T>> met load(order) en store(value, order).
Voorbeelden
#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';
}Resultaat
42
Het programma met één thread toont `42`, omdat `snapshot` mede-eigenaar blijft nadat `slot` is leeggemaakt. Het toont syntaxis en levensduur, geen synchronisatie tussen threads.
Gerelateerde lessen
- C++ · Les 37 · Gevorderd · Versie: 3
Bronnen
- 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]