CKTIS / C++
std::atomic_thread_fence — Synchronisierung mit Speicherzäunen
std::atomic_thread_fence legt Einschränkungen für die Speicherreihenfolge fest, ohne ein bestimmtes Objekt zu lesen oder zu schreiben. Für die Synchronisierung zwischen Threads sind passend verknüpfte atomare Operationen erforderlich; Zäune allein reichen nicht aus.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
#include <atomic>
std::atomic_thread_fence(order); // order: std::memory_order; returns voidstd::atomic_thread_fence(order) aus <atomic> gibt void zurück und löst keine Ausnahmen aus. Ein Fence wirkt nicht auf ein bestimmtes atomares Objekt. Er ist weder eine Sperre noch ein bedingungsloser Befehl zum „Leeren des Caches“.
In C++23 hat std::memory_order_relaxed keine Wirkung. Sowohl std::memory_order_consume als auch std::memory_order_acquire erzeugen einen Acquire-Fence. std::memory_order_release erzeugt einen Release-Fence und std::memory_order_acq_rel einen Fence mit Acquire- und Release-Semantik. std::memory_order_seq_cst erzeugt einen sequenziell konsistenten Acquire- und Release-Fence.
Im Beispiel erfolgt der Schreibzugriff auf payload vor dem Release-Fence, danach folgt der atomare Schreibzugriff auf ready. Der Lesezugriff auf ready, der true aus diesem Schreibzugriff sieht, erfolgt vor dem Acquire-Fence. Diese Kette synchronisiert die Fences und bewirkt, dass der Schreibzugriff auf payload vor dessen Lesezugriff stattfindet: Das Ergebnis ist 42, ohne Datenrennen. Fences ohne diese atomare Verbindung schützen gewöhnliche Daten nicht.
Ein Release-Fence kann auch mit einem Acquire-Lesezugriff oder ein Release-Schreibzugriff mit einem Acquire-Fence verbunden werden, sofern die erforderliche Reads-from-Verbindung besteht. std::atomic_signal_fence schränkt die Reihenfolge nur zwischen einem Thread und einem Signal-Handler ein, der in demselben Thread ausgeführt wird. Die bereitgestellte Quelle ist ein fortlaufend überarbeiteter Standardentwurf, kein festgeschriebener C++23-Text.
Beispiele
#include <atomic>
#include <iostream>
#include <thread>
int main() {
int payload = 0;
std::atomic<bool> ready{false};
std::thread producer([&] {
payload = 42;
std::atomic_thread_fence(std::memory_order_release);
ready.store(true, std::memory_order_relaxed);
});
while (!ready.load(std::memory_order_relaxed)) {
std::this_thread::yield();
}
std::atomic_thread_fence(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.