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.