WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::shared_ptr atomar mit expliziter Speicherordnung speichern

Die ältere Überladung veröffentlicht einen std::shared_ptr per Release-Store für einen Acquire-Load. Sie gehört noch zu C++23; in neuem Code ist std::atomic<std::shared_ptr<T>> vorzuziehen.

Version: 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) bezeichnet die freie Überladung aus <memory>, die die Adresse eines gewöhnlichen std::shared_ptr<T> erhält, nicht die eines std::atomic<T>. Sie ersetzt *p atomar durch den Wertparameter desired, wie bei p->swap(desired), und gibt void zurück. p muss auf ein lebendes Objekt zeigen; der zu speichernde shared_ptr darf leer sein. Die Operation ist nicht garantiert lock-frei.

Greife bei nebenläufiger Nutzung auf dieselbe gemeinsam genutzte Instanz nicht teils über diese Funktionen und teils durch direktes Lesen, Zuweisen oder reset() zu. std::atomic_load_explicit liefert einen separaten shared_ptr als Wert zurück. Kopien können denselben Kontrollblock teilen und das verwaltete Objekt am Leben halten, verhindern aber keine Datenrennen auf veränderlichen Inhalten.

Liest ein Load mit std::memory_order_acquire den durch einen Store mit std::memory_order_release geschriebenen Wert, synchronisiert der Store mit dem Load. Die Initialisierung vor dem Store ist damit für Code nach dem Load sichtbar. Ein std::atomic_thread_fence(std::memory_order_release) direkt vor diesem Store ist in diesem Muster überflüssig. std::memory_order_relaxed erhält die Atomarität, garantiert für sich allein aber keine solche Veröffentlichung. In C++23 verbietet der ältere Store ausdrücklich acquire und acq_rel, der ältere Load release und acq_rel; ein Verstoß gegen diese Vorbedingungen führt zu undefiniertem Verhalten.

Die freien Überladungen wurden in C++11 eingeführt, in C++20 als veraltet markiert und in C++26 entfernt. Sie gehören noch zu C++23; die Unterstützung kann je nach Implementierung variieren. Verwende in neuem Code std::atomic<std::shared_ptr<T>> mit den Methoden store und load.

Beispiele

#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();
}

Ergebnis

42

Der Hauptthread wiederholt den Acquire-Load, bis er eine nicht leere Kopie erhält. Er gibt `42` vor `join()` aus; die Konfiguration wird durch das Release/Acquire-Paar veröffentlicht, nicht durch `join()`.

Zugehörige Lektionen

  • C++ · Lektion 37 · Fortgeschritten · Version: 3

Quellen