CKTIS / C++
std::atomic_thread_fence — synchronisatie met geheugenfences
std::atomic_thread_fence stelt beperkingen aan de geheugenvolgorde in zonder een specifiek object te lezen of te schrijven. Synchronisatie tussen threads vereist passend gekoppelde atomaire bewerkingen; fences alleen zijn niet voldoende.
Versie: 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) uit <atomic> retourneert void en werpt geen uitzonderingen. Een fence werkt niet op een specifiek atomair object. Het is geen vergrendeling en ook geen onvoorwaardelijke opdracht om „de cache leeg te maken“.
In C++23 heeft std::memory_order_relaxed geen effect. Zowel std::memory_order_consume als std::memory_order_acquire levert een acquire-fence op. std::memory_order_release levert een release-fence op en std::memory_order_acq_rel een fence met zowel acquire- als release-semantiek. std::memory_order_seq_cst maakt een sequentieel consistente acquire- en release-fence.
In het voorbeeld gaat de schrijfoperatie naar payload vooraf aan de release-fence, gevolgd door de atomaire schrijfoperatie naar ready. De leesoperatie van ready die true uit die schrijfoperatie waarneemt, gaat vooraf aan de acquire-fence. Deze keten synchroniseert de fences en zorgt ervoor dat de schrijfoperatie naar payload plaatsvindt vóór het lezen ervan: het resultaat is 42, zonder datarace. Fences toevoegen zonder deze atomaire verbinding beschermt gewone gegevens niet.
Een release-fence kan ook worden verbonden met een acquire-leesbewerking, of een release-schrijfoperatie met een acquire-fence, mits de vereiste reads-from-relatie bestaat. std::atomic_signal_fence beperkt de volgorde alleen tussen een thread en een signaalhandler die in diezelfde thread wordt uitgevoerd. De aangeleverde bron is een evoluerend normontwerp, geen vastgestelde C++23-tekst.
Voorbeelden
#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();
}
Resultaat
42
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.