CKTIS / C++
std::memory_order — volgorde van atomaire bewerkingen
std::memory_order uit <atomic> bepaalt de volgorde en synchronisatie van atomaire bewerkingen. Het onderscheidt alleen atomiciteit van het veilig publiceren van gegevens tussen threads; een onjuiste verzwakking van de volgorde kan een data race veroorzaken.
Versie: 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 is een enumeratie uit <atomic> die aan atomaire bewerkingen wordt doorgegeven. Atomiciteit betreft het betreffende object; de geheugenvolgorde bepaalt aanvullende garanties voor andere lees- en schrijfoperaties. relaxed behoudt de atomiciteit en wijzigingsvolgorde van dat object, maar synchroniseert op zichzelf geen toegang tot andere gegevens.
release publiceert eerdere schrijfbewerkingen en acquire maakt het veilig waarnemen daarvan mogelijk: een acquire-load synchroniseert met een release-store wanneer deze de waarde ervan leest of uit de bijbehorende release-sequence leest. acq_rel combineert beide richtingen in een read-modify-write-bewerking. seq_cst, de standaardinstelling voor veel atomaire bewerkingen, neemt bovendien deel aan één totale volgorde van seq_cst-bewerkingen; het ordent niet automatisch elke actie in het programma.
In C++23 beschrijft consume een zwakkere volgorde op basis van data-afhankelijkheden, niet een volledige acquire-volgorde. Versieopmerking: het gekoppelde, doorontwikkelde concept is niet de vastgestelde tekst van C++23 — momenteel beschrijft het consume als een verouderd equivalent van acquire. Gebruik voor gewone gegevenspublicatie release/acquire in plaats van te vertrouwen op de nuances van consume.
Voor store zijn relaxed, release, seq_cst toegestaan; voor load in C++23: relaxed, consume, acquire, seq_cst. acq_rel is niet geldig voor een gewone load of store. Een ongeldige volgorde schendt de vereisten van de bewerking; volatile vervangt synchronisatie niet.
In het voorbeeld keert wait met acquire pas terug nadat een andere waarde dan false is waargenomen. Het leest de true die met release is gepubliceerd, dus de schrijfoperatie op payload gebeurt vóór de leesoperatie in de happens-before-relatie en de uitvoer is 42. notify_one() publiceert op zichzelf geen gegevens. Beide volgordes vervangen door relaxed zou deze garantie wegnemen en een data race op payload mogelijk maken.
Voorbeelden
#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();
}
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.