CKTIS / C++
Ordini di memoria delle operazioni atomiche
Le costanti di tipo std::memory_order controllano la sincronizzazione e l’ordine delle operazioni atomiche. Scopri le differenze tra relaxed, release, acquire, acq_rel e seq_cst e come un flag atomico può pubblicare in sicurezza dati normali.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#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);Le costanti di <atomic> di tipo std::memory_order selezionano le regole di ordinamento; non rendono atomiche le variabili normali. Nomi come std::memory_order_relaxed corrispondono a valori come std::memory_order::relaxed. Queste regole si applicano a C++23; eel.is ospita una bozza in evoluzione, non una pubblicazione C++23 definitiva.
std::memory_order_relaxed mantiene l’atomicità, ma da solo non sincronizza l’accesso ad altri dati tra i thread. std::memory_order_release può pubblicare scritture precedenti. std::memory_order_acquire si sincronizza con un’operazione release sullo stesso oggetto atomico quando legge il valore di quell’operazione o un valore della relativa sequenza release. Non basta usare semplicemente entrambi i nomi.
std::memory_order_acq_rel combina acquire e release in un’operazione di lettura-modifica-scrittura, come exchange. std::memory_order_seq_cst offre le proprietà acquire/release applicabili e un unico ordine totale delle operazioni seq_cst. Non elimina le data race e non include automaticamente in tale ordine le operazioni più deboli.
Per load, tra queste cinque costanti sono valide relaxed, acquire e seq_cst; per store, relaxed, release e seq_cst. acq_rel non è valido per un semplice load o store. Questi metodi usano seq_cst come ordine predefinito. Indebolire un ordine richiede una motivazione di correttezza, non soltanto una misura della velocità.
Nell’esempio, la lettura acquire di true si sincronizza con la scrittura release, quindi payload = 42 avviene prima della sua lettura secondo la relazione happens-before. Sostituire entrambi gli ordini con relaxed eliminerebbe questa garanzia e causerebbe una data race su payload. Il ciclo attende attivamente; il risultato al termine è determinato, ma il tempo di attesa non ha un limite fisso.
Esempi
#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();
}
Risultato
42
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.