C++ Academy · Leçon

std::atomic et ordres mémoire

Utiliser std::atomic avec l’ordre mémoire approprié pour garantir la correction et la rapidité

std::atomic et ordres mémoire est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Au-delà des verrous mutex

Les verrous sérialisent les accès : ils sont simples et corrects, mais limitent le débit. std::atomic fournit des composants de base sans verrou pour le code concurrent à haut débit.

Principes de base de std::atomic

Un std::atomic<T> encapsule une valeur et prend en charge les opérations atomiques de lecture-modification-écriture.

#include <atomic>
std::atomic<int> counter{0};
counter.fetch_add(1);    // atomic increment
int v = counter.load();
counter.store(0);

Opérateurs pratiques

Pour les types arithmétiques, les opérateurs habituels sont atomiques.

std::atomic<int> n{0};
++n;          // atomic increment
n += 5;        // atomic add
int v = n;     // atomic load

Pourquoi les opérations atomiques sont délicates

Le CPU peut réordonner les opérations mémoire entre les cœurs. L’ordre mémoire précise quels réordonnancements sont autorisés.

Ordres mémoire

Cinq ordres courants :

memory_order_relaxed — atomique, mais sans ordre
memory_order_acquire — à associer à release ; aucun réordonnancement après
memory_order_release — à associer à acquire ; aucun réordonnancement avant
memory_order_acq_rel — les deux
memory_order_seq_cst — cohérence séquentielle (par défaut)

Cohérence séquentielle : une valeur sûre par défaut

Par défaut, seq_cst se comporte de manière intuitive : toutes les opérations atomiques semblent s’exécuter dans un ordre global unique. C’est plus lent que les ordres relaxed, mais plus facile à raisonner.

Association acquire-release

Utilisez release dans le producteur et acquire dans le consommateur. Après acquire, toutes les écritures effectuées avant le release correspondant sont visibles.

std::atomic<bool> ready{false};
int data = 0;

// producer
data = 42;
ready.store(true, std::memory_order_release);

// consumer
while (!ready.load(std::memory_order_acquire));
std::cout << data;    // sees 42

Ordre relaxed

Les opérations atomiques relaxed garantissent l’atomicité, c’est-à-dire l’absence de lectures partielles, mais autorisent tout réordonnancement. Utilisez-les pour les compteurs simples lorsque l’ordre n’a pas d’importance.

Comparaison-échange

La base de la plupart des algorithmes sans verrou. compare_exchange_strong(expected, desired) met à jour la valeur de manière atomique uniquement si la valeur actuelle est égale à expected.

std::atomic<int> a{10};
int expected = 10;
bool ok = a.compare_exchange_strong(expected, 20);
// if true, a is now 20; otherwise expected holds the actual current value

CAS faible ou fort

compare_exchange_weak peut échouer à tort, même lorsque les valeurs correspondent. Utilisez-le dans les boucles, car il est moins coûteux sur certaines plateformes ; utilisez la forme forte en dehors des boucles.

Sans verrou ou sans attente

Deux garanties de progression :

Sans verrou — au moins un thread progresse à tout moment
Sans attente — chaque thread progresse dans un délai borné

Quand utiliser les opérations atomiques

Les opérations atomiques ne sont pas toujours plus rapides que les verrous mutex. Utilisez-les lorsque vous pouvez garder le chemin critique simple : compteurs, indicateurs ou état simple. Pour un état partagé complexe, les verrous mutex sont généralement plus sûrs et plus clairs.

Vérification rapide

Quel ordre mémoire offre les garanties les plus fortes, mais est également le plus lent ?

Récapitulatif

std::atomic fournit des primitives sans verrou avec un ordre mémoire explicite. Utilisez par défaut memory_order_seq_cst ; utilisez des paires acquire/release pour les modèles producteur-consommateur ; utilisez relaxed uniquement pour les opérations atomiques sans ordre, comme les compteurs.

Questions Fréquemment Posées

La leçon « std::atomic et ordres mémoire » est-elle gratuite ?

Oui — le texte complet de « std::atomic et ordres mémoire » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « std::atomic et ordres mémoire » ?

Utiliser std::atomic avec l’ordre mémoire approprié pour garantir la correction et la rapidité Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « std::atomic et ordres mémoire » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy