0Pricing
C++ Academy · Leçon

std::mutex, lock_guard et unique_lock

Protéger un état partagé avec des mutex et des assistants de verrouillage fondés sur RAII

std::mutex, lock_guard et unique_lock est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Pourquoi un mutex ?

Plusieurs threads qui accèdent aux mêmes données se les disputent. Un mutex garantit l'exclusion mutuelle : un seul thread détient le verrou à la fois.

Bases de std::mutex

Construire, verrouiller, déverrouiller. Le verrouillage manuel est source d'erreurs : utilisez toujours les outils RAII.

#include <mutex>
std::mutex mtx;

mtx.lock();
// critical section
mtx.unlock();

std::lock_guard : verrou RAII

Le verrou RAII le plus simple. Il verrouille dans le constructeur et déverrouille dans le destructeur. Il convient parfaitement aux sections critiques qui ne lèvent pas d'exception.

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

std::scoped_lock (C++17)

Comme lock_guard, mais peut verrouiller plusieurs mutex à la fois sans interblocage. Préférez-le dans le code moderne.

#include <mutex>
std::scoped_lock lock(mtx1, mtx2, mtx3);  // locks all atomically

std::unique_lock : verrou flexible

Plus de fonctionnalités que lock_guard :

  • Peut être déverrouillé puis reverrouillé au cours de la portée
  • Peut être déplacé (propriété transférable)
  • S'utilise avec les variables de condition
std::unique_lock<std::mutex> lock(mtx);
lock.unlock();        // release temporarily
// ... do something without the lock ...
lock.lock();           // reacquire

Éviter les interblocages

Deux threads peuvent entrer en interblocage s'ils acquièrent les verrous dans des ordres différents. Acquérez-les toujours dans un ordre global cohérent, ou utilisez std::scoped_lock avec plusieurs mutex.

std::lock pour plusieurs mutex

Avant C++17, utilisez std::lock pour acquérir plusieurs mutex de manière atomique. En C++17, std::scoped_lock est plus clair.

Mutex récursif

std::recursive_mutex permet à un thread de le verrouiller plusieurs fois. C'est généralement le signe de problèmes de conception : refactorez plutôt votre code.

try_lock et timed_mutex

try_lock retourne immédiatement si le verrou est détenu. std::timed_mutex permet de limiter dans le temps les tentatives de verrouillage.

Verrou lecteur-rédacteur

std::shared_mutex (C++17) autorise plusieurs lecteurs simultanés ou un seul rédacteur exclusif. Utilisez-le pour les charges de travail principalement constituées de lectures.

std::shared_mutex sm;
void read()  { std::shared_lock lk(sm);   /* read */ }
void write() { std::unique_lock lk(sm);   /* write */ }

Compromis de granularité

Un verrouillage trop grossier nuit à la concurrence. Un verrouillage trop fin ajoute du surcoût. Mesurez les performances et ajustez.

Alternatives sans verrou

Pour les situations à forte contention, envisagez des structures de données sans verrou (atomiques, files sans verrou). Elles sont beaucoup plus difficiles à écrire correctement : utilisez-les uniquement lorsque c'est nécessaire et vérifié.

Vérification rapide

Quel verrou RAII faut-il préférer lorsque vous verrouillez plusieurs mutex à la fois ?

Récapitulatif

Utilisez std::lock_guard pour les sections critiques simples, std::scoped_lock pour plusieurs mutex et std::unique_lock lorsque vous avez besoin de flexibilité (variables de condition, déverrouillage manuel). Utilisez toujours RAII : n'appelez jamais lock/unlock manuellement.

Questions Fréquemment Posées

La leçon « std::mutex, lock_guard et unique_lock » est-elle gratuite ?

Oui — le texte complet de « std::mutex, lock_guard et unique_lock » 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::mutex, lock_guard et unique_lock » ?

Protéger un état partagé avec des mutex et des assistants de verrouillage fondés sur RAII 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 2 sur 4.

Combien de temps prend la leçon « std::mutex, lock_guard et unique_lock » ?

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

  1. std::thread : jonction et détachement
  2. std::mutex, lock_guard et unique_lock
  3. Variables de condition et schémas de travailleurs
  4. Bases de std::async et std::future
← Retour à C++ Academy