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

CKTIS / C++

std::lock_guard — possession d’un verrou liée à la portée

std::lock_guard de <mutex> gère un verrou selon le principe RAII. Le constructeur qui ne prend que le mutex le verrouille. La surcharge avec std::adopt_lock prend en charge un verrou exclusif déjà détenu par le thread courant, sans appeler lock(). Dans les deux cas, le destructeur déverrouille le mutex. Un objet nommé protège une section critique pendant toute sa durée de vie.

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

Syntaxe

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

std::lock_guard<Mutex> lie la possession du verrou à la durée de vie de l’objet (RAII). Le constructeur qui reçoit m appelle m.lock(), et le destructeur appelle m.unlock(). À la sortie de la portée, y compris avec return ou lors du déroulement de la pile après une exception, un verrou acquis avec succès est libéré.

Le type Mutex doit satisfaire aux exigences de Cpp17BasicLockable. Le mutex doit exister pendant toute la durée de vie du garde ; le non-respect de cette condition entraîne un comportement indéfini. Le garde ne peut être ni copié ni déplacé et ne permet pas de déverrouiller plus tôt.

La variante avec std::adopt_lock prend en charge un verrou déjà détenu sans appeler lock(). Elle exige que le thread courant détienne déjà un verrou exclusif sur ce mutex. Donnez un nom au garde : un objet temporaire est détruit à la fin de l’expression complète et ne protège donc pas les instructions suivantes.

Dans l’exemple, les deux threads protègent chaque incrément de counter avec le même mutex. La lecture n’a lieu qu’après les deux appels à join() ; le résultat attendu est donc 2000, quel que soit l’ordonnancement des threads.

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