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

CKTIS / C++

std::scoped_lock — propriété des verrous liée à la portée

std::scoped_lock possède les verrous des mutex pendant toute la durée de vie de l’objet. Son constructeur verrouille les mutex fournis et son destructeur les déverrouille. Pour plusieurs mutex, il utilise std::lock afin d’éviter les interblocages lors de leur acquisition simultanée.

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

Syntaxe

#include <mutex>

{
    std::scoped_lock guard(m1, m2);
}

{
    std::lock(m1, m2);
    std::scoped_lock adopted(std::adopt_lock, m1, m2);
}

std::scoped_lock, défini dans <mutex>, est un garde RAII : il lie la possession des verrous à la durée de vie d’un objet nommé. Son destructeur appelle unlock() sur chaque mutex, y compris lorsqu’une exception provoque la sortie de la portée. Le garde ne peut être ni copié ni déplacé ; les mutex doivent rester en vie pendant toute sa durée de vie.

Le constructeur ordinaire ne verrouille rien avec zéro mutex, appelle lock() avec un seul mutex et utilise std::lock avec plusieurs mutex. Un type de mutex unique doit satisfaire Cpp17BasicLockable ; plusieurs types de mutex doivent satisfaire Cpp17Lockable. L’algorithme évite les interblocages lors de l’acquisition simultanée de ces verrous, mais ne prévient pas tous les interblocages dans un programme. Si l’acquisition par std::lock lève une exception, cet appel libère les verrous qu’il a acquis avant de propager l’exception.

La surcharge avec std::adopt_lock ne verrouille pas les mutex : elle prend en charge leur déverrouillage. Le thread appelant doit déjà détenir un verrou exclusif sur chacun d’eux. N’utilisez pas le constructeur ordinaire pour reverrouiller un std::mutex déjà détenu. Donnez un nom au garde : l’objet temporaire dans std::scoped_lock{m1, m2}; est détruit à la fin de cette instruction.

L’exemple met à jour deux valeurs en détenant les deux verrous et affiche 7 23 après les avoir libérés. Il utilise volontairement un seul thread pour obtenir une sortie déterministe ; il ne montre pas de contention entre threads. Dans un programme concurrent, tous les accès aux mêmes données protégées doivent respecter un protocole de synchronisation cohérent.

Exemples

#include <iostream>
#include <mutex>

int main() {
    std::mutex left_mutex;
    std::mutex right_mutex;
    int left = 10;
    int right = 20;

    {
        std::scoped_lock guard(left_mutex, right_mutex);
        left -= 3;
        right += 3;
    }

    std::cout << left << ' ' << right << '\n';
}

Résultat

7 23

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