CKTIS / C++
Pořadí paměti u atomických operací
Konstanty typu std::memory_order určují synchronizaci a řazení atomických operací. Zjistěte, jak se liší relaxed, release, acquire, acq_rel a seq_cst a jak může atomický příznak bezpečně zpřístupnit běžná data.
Verze: C++23; repository compiler flag, production runtime not attested
Syntaxe
#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);Konstanty z <atomic> typu std::memory_order vybírají pravidla řazení; běžné proměnné nedělají atomickými. Názvy jako std::memory_order_relaxed odpovídají hodnotám jako std::memory_order::relaxed. Tato pravidla platí pro C++23; eel.is nabízí průběžně se měnící návrh, nikoli neměnné vydání C++23.
std::memory_order_relaxed zachovává atomicitu, ale samo o sobě nesynchronizuje přístup k jiným datům mezi vlákny. std::memory_order_release může zpřístupnit dřívější zápisy. std::memory_order_acquire se synchronizuje s operací release nad stejným atomickým objektem, pokud čte její hodnotu nebo hodnotu z její release sekvence. Pouhé použití obou názvů nestačí.
std::memory_order_acq_rel spojuje acquire a release v operaci čtení–modifikace–zápis, například exchange. std::memory_order_seq_cst poskytuje příslušné vlastnosti acquire/release a také jediné úplné pořadí operací seq_cst. Neodstraňuje datové závody ani do tohoto pořadí automaticky nezařazuje slabší operace.
Pro load jsou z těchto pěti konstant platné relaxed, acquire a seq_cst; pro store relaxed, release a seq_cst. acq_rel není platné pro samotné load ani store. Výchozím pořadím těchto metod je seq_cst. Oslabení pořadí vyžaduje zdůvodnění správnosti, nejen měření rychlosti.
V příkladu se čtení true s pořadím acquire synchronizuje se zápisem release, takže payload = 42 předchází jeho čtení ve vztahu happens-before. Nahrazení obou pořadí hodnotou relaxed by tuto záruku odstranilo a způsobilo datový závod na payload. Smyčka aktivně čeká; výstup po dokončení je daný, ale doba čekání nemá pevnou horní mez.
Příklady
#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();
}
Výsledek
42
Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.