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

CKTIS / C++

Ordres mémoire des opérations atomiques

Les constantes de type std::memory_order définissent la synchronisation et l’ordre des opérations atomiques. Découvrez les différences entre relaxed, release, acquire, acq_rel et seq_cst, et comment un indicateur atomique peut publier des données ordinaires en toute sécurité.

Version : 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);

Les constantes de <atomic> de type std::memory_order sélectionnent des règles d’ordre ; elles ne rendent pas atomiques les variables ordinaires. Les noms tels que std::memory_order_relaxed correspondent à des valeurs telles que std::memory_order::relaxed. Ces règles s’appliquent à C++23 ; eel.is héberge un projet en évolution, et non une publication C++23 figée.

std::memory_order_relaxed préserve l’atomicité, mais ne synchronise pas à lui seul les accès à d’autres données entre les threads. std::memory_order_release peut publier des écritures antérieures. std::memory_order_acquire se synchronise avec une opération release sur le même objet atomique lorsqu’elle lit la valeur de cette opération ou une valeur de sa séquence release. Employer simplement les deux noms ne suffit pas.

std::memory_order_acq_rel combine acquire et release dans une opération de lecture-modification-écriture, telle que exchange. std::memory_order_seq_cst fournit les propriétés acquire/release applicables ainsi qu’un ordre total unique des opérations seq_cst. Il ne corrige pas les courses de données et n’inclut pas automatiquement les opérations plus faibles dans cet ordre.

Pour load, parmi ces cinq constantes, les choix valides sont relaxed, acquire et seq_cst ; pour store, ce sont relaxed, release et seq_cst. acq_rel ne convient pas à un simple load ou store. Ces méthodes utilisent seq_cst par défaut. Affaiblir un ordre exige de justifier la correction du programme, pas seulement de mesurer sa vitesse.

Dans l’exemple, la lecture acquire de true se synchronise avec l’écriture release ; payload = 42 précède donc sa lecture selon la relation happens-before. Remplacer les deux ordres par relaxed supprimerait cette garantie et provoquerait une course de données sur payload. La boucle attend activement ; la sortie à la fin est déterminée, mais le temps d’attente n’a pas de limite fixe.

Exemples

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

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