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

CKTIS / C++

std::mutex — exclusion mutuelle entre threads

std::mutex, défini dans <mutex>, permet à un seul thread à la fois de posséder le verrou. Il protège les données partagées lorsque tous les accès concurrents respectent le même protocole de verrouillage. std::lock_guard gère la libération du verrou à la sortie d’une portée.

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

Syntaxe

#include <mutex>
std::mutex m;
std::lock_guard<std::mutex> guard(m);

std::mutex, défini dans <mutex>, assure la possession exclusive et non récursive d’un verrou. Une section critique est du code exécuté pendant que ce verrou est détenu. Un mutex ne protège pas automatiquement les données : tous les accès susceptibles d’entrer en conflit doivent respecter le même protocole de synchronisation.

lock() attend de pouvoir acquérir le verrou. try_lock() n’attend pas et indique si l’opération a réussi ; il peut renvoyer false même si le mutex est disponible. unlock() libère le verrou et ne peut être appelé que par son propriétaire. La libération se synchronise avec une acquisition ultérieure réussie du même mutex, ce qui rend visibles les écritures antérieures.

Privilégiez un objet nommé std::lock_guard<std::mutex> : son constructeur verrouille le mutex et son destructeur le déverrouille, y compris lorsqu’une exception entraîne la sortie de la portée. Le mutex doit vivre plus longtemps que le garde. N’essayez pas de reprendre un std::mutex que vous possédez déjà : la récursion n’est pas prise en charge. Il ne peut être ni copié ni déplacé, et détruire un mutex détenu entraîne un comportement indéfini.

Dans l’exemple, deux threads incrémentent counter sous le même verrou. Chaque appel à join() attend uniquement la fin du thread représenté par l’objet sur lequel il est appelé. Avant de lire le compteur, l’exemple attend la fin de chaque thread séparément avec first.join() et second.join() ; le résultat est donc 2000, quel que soit leur ordre d’exécution. L’exemple utilise des fonctionnalités disponibles en C++23 ; la norme de compilation indiquée ne certifie pas un environnement d’exécution de production. La source référencée est un projet de norme en évolution, et non une édition C++23 figée.

Exemples

#include <iostream>
#include <mutex>
#include <thread>

int main() {
    std::mutex m;
    int counter = 0;

    auto increment = [&] {
        for (int i = 0; i < 1000; ++i) {
            std::lock_guard<std::mutex> guard(m);
            ++counter;
        }
    };

    std::thread first(increment);
    std::thread second(increment);
    first.join();
    second.join();

    std::cout << counter << '\n';
}

Résultat

2000

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