CKTIS / C++
std::memory_order — Reihenfolge atomarer Operationen
std::memory_order aus <atomic> legt Reihenfolge und Synchronisierung atomarer Operationen fest. Es unterscheidet reine Atomizität von der sicheren Veröffentlichung von Daten zwischen Threads; eine unzulässige Abschwächung der Reihenfolge kann eine Datenrace verursachen.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
#include <atomic>
// Examples of explicit ordering:
flag.store(true, std::memory_order::release);
bool value = flag.load(std::memory_order::acquire);std::memory_order ist ein Aufzählungstyp aus <atomic>, der an atomare Operationen übergeben wird. Atomizität betrifft das jeweilige Objekt; die Speicherreihenfolge legt zusätzliche Garantien für andere Lese- und Schreibzugriffe fest. relaxed erhält die Atomizität und die Änderungsreihenfolge dieses Objekts, synchronisiert aber für sich allein keinen Zugriff auf andere Daten.
release veröffentlicht vorherige Schreibzugriffe, und acquire ermöglicht deren sicheres Beobachten: Ein acquire-Lesezugriff synchronisiert mit einem release-Schreibzugriff, wenn er dessen Wert oder aus der zugehörigen release-Sequenz liest. acq_rel verbindet beide Richtungen bei einer Read-Modify-Write-Operation. seq_cst, die Standardeinstellung vieler atomarer Operationen, nimmt zusätzlich an einer einzigen totalen Reihenfolge der seq_cst-Operationen teil; es ordnet nicht automatisch jede Aktion im Programm.
In C++23 beschreibt consume eine schwächere, auf Datenabhängigkeiten beruhende Reihenfolge statt einer vollständigen acquire-Reihenfolge. Versionshinweis: Der verlinkte, fortgeschriebene Entwurf ist nicht der eingefrorene Wortlaut von C++23 – er beschreibt consume derzeit als veraltetes Äquivalent von acquire. Für die gewöhnliche Datenveröffentlichung sollte release/acquire verwendet werden, statt sich auf die Feinheiten von consume zu verlassen.
Für store sind relaxed, release und seq_cst zulässig; für load in C++23: relaxed, consume, acquire, seq_cst. acq_rel ist für ein einfaches load oder store nicht zulässig. Eine ungültige Reihenfolge verletzt die Anforderungen der Operation; volatile ersetzt keine Synchronisierung.
Im Beispiel kehrt wait mit acquire erst zurück, nachdem ein anderer Wert als false beobachtet wurde. Es liest das mit release veröffentlichte true; daher geht der Schreibzugriff auf payload seinem Lesezugriff in der happens-before-Beziehung voraus und die Ausgabe ist 42. notify_one() allein veröffentlicht keine Daten. Würden beide Reihenfolgen durch relaxed ersetzt, entfiele diese Garantie und eine Datenrace auf payload wäre möglich.
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);
ready.notify_one();
});
ready.wait(false, std::memory_order::acquire);
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.