WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Speicherreihenfolgen bei atomaren Operationen

Konstanten vom Typ std::memory_order legen die Synchronisierung und Reihenfolge atomarer Operationen fest. Erfahre, worin sich relaxed, release, acquire, acq_rel und seq_cst unterscheiden und wie ein atomares Flag gewöhnliche Daten sicher veröffentlichen kann.

Version: C++23; repository compiler flag, production runtime not attested

Syntax

#include <atomic>
a.load(std::memory_order_acquire);
a.store(value, std::memory_order_release);
a.fetch_add(1, std::memory_order_relaxed);
a.exchange(value, std::memory_order_acq_rel);
a.load(std::memory_order_seq_cst);

Konstanten aus <atomic> vom Typ std::memory_order wählen Regeln für die Reihenfolge aus; sie machen gewöhnliche Variablen nicht atomar. Namen wie std::memory_order_relaxed entsprechen Werten wie std::memory_order::relaxed. Diese Regeln gelten für C++23; eel.is enthält einen fortlaufend überarbeiteten Entwurf, keine unveränderliche C++23-Veröffentlichung.

std::memory_order_relaxed erhält die Atomizität, synchronisiert aber für sich genommen den Zugriff auf andere Daten zwischen Threads nicht. std::memory_order_release kann frühere Schreibzugriffe veröffentlichen. std::memory_order_acquire synchronisiert mit einer Release-Operation auf demselben atomaren Objekt, wenn sie deren Wert oder einen Wert aus deren Release-Sequenz liest. Nur beide Namen zu verwenden, reicht nicht aus.

std::memory_order_acq_rel verbindet Acquire und Release in einer Read-Modify-Write-Operation, etwa exchange. std::memory_order_seq_cst bietet die jeweils geltenden Acquire-/Release-Eigenschaften sowie eine einzige totale Ordnung der seq_cst-Operationen. Es behebt weder Datenrennen noch nimmt es schwächere Operationen automatisch in diese Ordnung auf.

Für load sind unter diesen fünf Konstanten relaxed, acquire und seq_cst zulässig; für store relaxed, release und seq_cst. acq_rel ist für ein einfaches load oder store nicht zulässig. Diese Methoden verwenden standardmäßig seq_cst. Eine schwächere Ordnung erfordert eine Begründung ihrer Korrektheit, nicht nur eine Geschwindigkeitsmessung.

Im Beispiel synchronisiert der acquire-Lesezugriff auf true mit dem release-Schreibzugriff. Daher geschieht payload = 42 vor dem Lesen von payload im Sinne von happens-before. Würde man beide Ordnungen durch relaxed ersetzen, entfiele diese Garantie und es entstünde ein Datenrennen auf payload. Die Schleife wartet aktiv; die Ausgabe nach Abschluss ist festgelegt, die Wartezeit hat jedoch keine feste Obergrenze.

Beispiele

#include <atomic>
#include <iostream>
#include <thread>

int main() {
    int payload = 0;
    std::atomic<bool> ready{false};

    std::thread producer([&] {
        payload = 42;
        ready.store(true, std::memory_order_release);
    });

    while (!ready.load(std::memory_order_acquire)) {
        std::this_thread::yield();
    }
    std::cout << payload << '\n';
    producer.join();
}

Ergebnis

42

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen