CKTIS / C++
Een std::shared_ptr atomair opslaan met expliciete geheugenordening
De oudere overload publiceert een std::shared_ptr met een release-store voor een acquire-load. Hij zit nog in C++23; gebruik voor nieuwe code bij voorkeur std::atomic<std::shared_ptr<T>>.
Versie: ISO C++23; implementation support may vary
Syntax
#include <atomic>
#include <memory>
namespace std {
template<class T>
void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> desired,
memory_order order);
}std::atomic_store_explicit(shared_ptr) is de overload van de vrije functie uit <memory> die het adres van een gewone std::shared_ptr<T> aanneemt, niet dat van een std::atomic<T>. De functie vervangt *p atomair door de waardeparameter desired, alsof p->swap(desired) wordt uitgevoerd, en retourneert void. p moet naar een levend object wijzen, maar de op te slaan shared_ptr mag leeg zijn. De operatie is niet gegarandeerd lockvrij.
Combineer deze functies bij gelijktijdig gebruik niet met rechtstreeks lezen, toewijzen of reset() op dezelfde gedeelde instantie. std::atomic_load_explicit retourneert een afzonderlijke shared_ptr als waarde. Kopieën kunnen hetzelfde controleblok delen en het beheerde object in leven houden, maar voorkomen geen dataraces op wijzigbare inhoud.
Als een load met std::memory_order_acquire de waarde leest die een store met std::memory_order_release heeft geschreven, synchroniseert de store met de load. Initialisatie vóór de store is dan zichtbaar voor code na de load. Een std::atomic_thread_fence(std::memory_order_release) direct vóór die store is in dit patroon overbodig. std::memory_order_relaxed behoudt atomiciteit, maar biedt op zichzelf die publicatiegarantie niet. In C++23 verbiedt de oudere store expliciet acquire en acq_rel, en de oudere load verbiedt release en acq_rel; schending van deze precondities geeft ongedefinieerd gedrag.
Deze vrije overloads zijn ingevoerd in C++11, verouderd verklaard in C++20 en verwijderd in C++26. In C++23 maken ze nog deel uit van de standaard; ondersteuning kan per implementatie verschillen. Gebruik in nieuwe code std::atomic<std::shared_ptr<T>> met de lidfuncties store en load.
Voorbeelden
#include <atomic>
#include <iostream>
#include <memory>
#include <thread>
struct Config {
int limit;
};
int main() {
std::shared_ptr<const Config> published;
std::thread publisher([&] {
auto next = std::make_shared<const Config>(Config{42});
std::atomic_store_explicit(&published, next, std::memory_order_release);
});
std::shared_ptr<const Config> snapshot;
while (!(snapshot = std::atomic_load_explicit(
&published, std::memory_order_acquire))) {
std::this_thread::yield();
}
std::cout << snapshot->limit << '\n';
publisher.join();
}Resultaat
42
De hoofdthread herhaalt de acquire-load totdat die een niet-lege kopie krijgt. Hij drukt `42` af vóór `join()`; het release/acquire-paar publiceert de configuratie, niet `join()`.
Gerelateerde lessen
- C++ · Les 37 · Gevorderd · Versie: 3
Bronnen
- P2869R0 — Remove Deprecated Atomic Access APIs From C++26 (includes the legacy wording)
- C++23 working draft N4950 — Deprecated shared_ptr atomic access [depr.util.smartptr.shared.atomic]
- 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]