WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Atomares Laden eines `std::shared_ptr` mit expliziter Speicherordnung

In C++23 kopiert diese veraltete Überladung einen `std::shared_ptr` atomar. Die Speicherordnung des Lesezugriffs lässt sich explizit angeben.

Version: 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);

Diese Überladung der freien Funktion std::atomic_load_explicit ist in <memory> deklariert. Übergib &slot, also die Adresse eines std::shared_ptr<T> innerhalb seiner Lebensdauer, nicht die Adresse des Objekts, auf das er zeigt, oder eines std::atomic<T>. Die Funktion gibt eine Kopie vom Typ std::shared_ptr<T> als Wert zurück und wirft keine Ausnahme. Hatte der geladene Zeiger einen Anteil am gemeinsamen Besitz, behält die Kopie diesen Besitz bei. Eine Nulladresse für slot führt zu undefiniertem Verhalten. Der in slot gespeicherte Zeiger darf dagegen null sein; prüfe in diesem Fall vor dem Dereferenzieren das Ergebnis.

In C++23 sind std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire und std::memory_order_seq_cst für das Laden zulässig. std::memory_order_release und std::memory_order_acq_rel führen zu undefiniertem Verhalten. Die Kurzform std::atomic_load(&slot) verwendet std::memory_order_seq_cst.

Liest ein Acquire-Ladevorgang den Wert, den std::atomic_store_explicit mit std::memory_order_release in denselben slot geschrieben hat, synchronisiert der Schreibvorgang mit dem Lesevorgang. Die Initialisierung vor dem Schreiben ist damit für Code nach dem Lesen sichtbar. Eine zusätzliche Barriere std::atomic_thread_fence(std::memory_order_release) vor diesem Schreibvorgang ist für diese Veröffentlichung überflüssig. Ein Lesezugriff mit std::memory_order_relaxed bleibt atomar, stellt diese Synchronisation aber nicht allein her.

Wenn mehrere Threads auf denselben slot zugreifen und mindestens einer ihn ändern kann, kombiniere diese API nicht mit gewöhnlichem Kopieren, Zuweisen oder einem Aufruf von reset() auf diesem Objekt, sofern die Zugriffe nicht separat synchronisiert sind. So kann eine gewöhnliche Zuweisung oder ein Aufruf von reset() in einem Thread zu einem Datenrennen mit einem atomaren Lesezugriff in einem anderen Thread führen. Atomares Laden schützt nicht vor späteren Änderungen am Objekt, auf das der Zeiger zeigt, und ist nicht garantiert sperrenfrei. Die Überladung wurde in C++11 eingeführt, in C++20 als veraltet eingestuft, in C++23 beibehalten und aus dem C++26-Standard entfernt. Verwende für neuen Code std::atomic<std::shared_ptr<T>> mit load(order) und store(value, order).

Beispiele

#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';
}

Ergebnis

42

Das Programm mit einem einzigen Thread gibt `42` aus, weil `snapshot` den gemeinsamen Besitz auch nach dem Leeren von `slot` beibehält. Es zeigt Syntax und Lebensdauer, nicht die Synchronisation zwischen Threads.

Zugehörige Lektionen

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

Quellen