Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::atomic_thread_fence — synchronisation à l’aide de fences mémoire

std::atomic_thread_fence établit des contraintes d’ordre mémoire sans lire ni écrire un objet particulier. La synchronisation entre threads exige des opérations atomiques reliées de façon appropriée ; les fences seules ne suffisent pas.

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

Syntaxe

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

std::atomic_thread_fence(order) de <atomic> renvoie void et ne lance pas d’exceptions. Un fence n’agit pas sur un objet atomique particulier. Ce n’est ni un verrou ni une commande inconditionnelle pour « vider le cache ».

En C++23, std::memory_order_relaxed n’a aucun effet. std::memory_order_consume et std::memory_order_acquire créent tous deux un fence acquire. std::memory_order_release crée un fence release et std::memory_order_acq_rel crée un fence doté des deux propriétés. std::memory_order_seq_cst crée un fence acquire et release séquentiellement cohérent.

Dans l’exemple, l’écriture dans payload précède le fence release, après lequel vient l’écriture atomique dans ready. La lecture de ready qui observe true provenant de cette écriture précède le fence acquire. Cette chaîne synchronise les fences et fait en sorte que l’écriture dans payload se produise avant sa lecture : le résultat est 42, sans course de données. Ajouter des fences sans cette connexion atomique ne protège pas les données ordinaires.

Un fence release peut aussi être relié à une lecture acquire, ou une écriture release à un fence acquire, si la relation reads-from requise existe. std::atomic_signal_fence ne contraint l’ordre qu’entre un thread et un gestionnaire de signal exécuté dans ce même thread. La source fournie est un projet de norme en évolution, et non le texte figé de C++23.

Exemples

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

Résultat

42

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources