Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::atomic_thread_fence — sincronizzazione tramite fence di memoria

std::atomic_thread_fence stabilisce vincoli sull’ordine di memoria senza leggere o scrivere un oggetto specifico. La sincronizzazione tra thread richiede operazioni atomiche collegate in modo appropriato; i fence da soli non bastano.

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

Sintassi

#include <atomic>
std::atomic_thread_fence(order); // order: std::memory_order; returns void

std::atomic_thread_fence(order) di <atomic> restituisce void e non genera eccezioni. Un fence non opera su uno specifico oggetto atomico. Non è un blocco né un comando incondizionato per «svuotare la cache».

In C++23, std::memory_order_relaxed non ha effetto. Sia std::memory_order_consume sia std::memory_order_acquire creano un fence acquire. std::memory_order_release crea un fence release e std::memory_order_acq_rel crea un fence con entrambe le proprietà. std::memory_order_seq_cst crea un fence acquire e release sequenzialmente consistente.

Nell’esempio, la scrittura in payload precede il fence release, dopo il quale avviene la scrittura atomica in ready. La lettura di ready che osserva true proveniente da quella scrittura precede il fence acquire. Questa catena sincronizza i fence e fa sì che la scrittura in payload avvenga prima della sua lettura: il risultato è 42, senza data race. Aggiungere fence senza questa connessione atomica non protegge i dati ordinari.

Un fence release può anche collegarsi a una lettura acquire, oppure una scrittura release a un fence acquire, se è presente la relazione reads-from richiesta. std::atomic_signal_fence vincola l’ordine solo tra un thread e un gestore di segnali eseguito nello stesso thread. La fonte fornita è una bozza di standard in evoluzione, non il testo definitivo di C++23.

Esempi

#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();
}

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