KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

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