Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::memory_order — ordinamento delle operazioni atomiche

std::memory_order di <atomic> specifica l’ordinamento e la sincronizzazione delle operazioni atomiche. Distingue la sola atomicità dalla pubblicazione sicura dei dati tra thread; indebolire l’ordinamento in modo errato può causare una data race.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <atomic>
// Examples of explicit ordering:
flag.store(true, std::memory_order::release);
bool value = flag.load(std::memory_order::acquire);

std::memory_order è un’enumerazione di <atomic> passata alle operazioni atomiche. L’atomicità riguarda l’oggetto specifico; l’ordinamento della memoria definisce garanzie aggiuntive riguardo alle altre letture e scritture. relaxed mantiene l’atomicità e l’ordine di modifica di quell’oggetto, ma da solo non sincronizza l’accesso ad altri dati.

release pubblica le scritture precedenti e acquire ne consente l’osservazione sicura: una lettura acquire si sincronizza con una scrittura release quando legge il valore di quella scrittura o legge dalla sequenza release corrispondente. acq_rel combina entrambe le direzioni in un’operazione di lettura-modifica-scrittura. seq_cst, predefinito per molte operazioni atomiche, partecipa inoltre a un unico ordine totale delle operazioni seq_cst; non ordina automaticamente ogni azione del programma.

In C++23, consume descrive un ordinamento più debole, basato sulle dipendenze dei dati, anziché un ordinamento acquire completo. Nota sulla versione: la bozza in evoluzione collegata non è il testo definitivo di C++23 — attualmente descrive consume come equivalente deprecato di acquire. Per la normale pubblicazione dei dati, usa release/acquire invece di affidarti alle sottigliezze di consume.

Per store sono ammessi relaxed, release, seq_cst; per load in C++23: relaxed, consume, acquire, seq_cst. acq_rel non è valido per un semplice load o store. Un ordinamento non valido viola i requisiti dell’operazione; volatile non sostituisce la sincronizzazione.

Nell’esempio, wait con acquire ritorna solo dopo aver osservato un valore diverso da false. Legge il true pubblicato da release, quindi la scrittura di payload precede la sua lettura nella relazione happens-before e l’output è 42. notify_one() da solo non pubblica dati. Sostituire entrambi gli ordinamenti con relaxed eliminerebbe questa garanzia e consentirebbe una data race su payload.

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);
        ready.notify_one();
    });

    ready.wait(false, std::memory_order::acquire);
    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.

Fonti