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

CKTIS / C++

std::memory_order — ordre des opérations atomiques

std::memory_order de <atomic> définit l’ordre et la synchronisation des opérations atomiques. Il distingue l’atomicité seule de la publication sûre de données entre threads ; un affaiblissement incorrect de l’ordre peut provoquer une course de données.

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

Syntaxe

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

std::memory_order est une énumération de <atomic> passée aux opérations atomiques. L’atomicité concerne l’objet en question ; l’ordre mémoire précise des garanties supplémentaires sur les autres lectures et écritures. relaxed préserve l’atomicité et l’ordre de modification de cet objet, mais ne synchronise pas à lui seul l’accès aux autres données.

release publie les écritures antérieures, et acquire permet de les observer en toute sécurité : une lecture acquire se synchronise avec une écriture release lorsqu’elle lit la valeur de cette écriture ou lit dans la séquence release correspondante. acq_rel combine les deux directions dans une opération de lecture-modification-écriture. seq_cst, valeur par défaut de nombreuses opérations atomiques, participe en plus à un ordre total unique des opérations seq_cst ; il n’ordonne pas automatiquement toutes les actions du programme.

En C++23, consume décrit un ordre plus faible, fondé sur les dépendances de données, et non un ordre acquire complet. Précision sur la version : le projet évolutif lié n’est pas le texte figé de C++23 — il décrit actuellement consume comme un équivalent obsolète de acquire. Pour publier des données de façon courante, utilisez release/acquire plutôt que de vous fier aux subtilités de consume.

Pour store, les ordres autorisés sont relaxed, release, seq_cst ; pour load en C++23 : relaxed, consume, acquire, seq_cst. acq_rel n’est pas valide pour un simple load ou store. Un ordre invalide enfreint les exigences de l’opération ; volatile ne remplace pas la synchronisation.

Dans l’exemple, wait avec acquire ne revient qu’après avoir observé une valeur différente de false. Il lit le true publié par release ; l’écriture de payload précède donc sa lecture dans la relation happens-before et la sortie vaut 42. notify_one() ne publie pas de données à lui seul. Remplacer les deux ordres par relaxed supprimerait cette garantie et autoriserait une course de données sur payload.

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

    ready.wait(false, 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