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

CKTIS / C++

std::shared_lock — gérer la possession d’un verrou partagé

std::shared_lock de <shared_mutex> gère la possession partagée d’un verrou grâce à RAII. Il permet à plusieurs threads de lire simultanément, mais ne fournit pas la possession exclusive nécessaire pour modifier des données partagées.

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

Syntaxe

#include <mutex>
#include <shared_mutex>

// Acquire shared ownership immediately:
std::shared_lock<Mutex> guard(m);

// Alternatively, defer acquisition:
// std::shared_lock<Mutex> guard(m, std::defer_lock);

std::shared_lock<Mutex> gère la possession partagée d’un verrou ; ce n’est pas le mutex lui-même. Mutex doit satisfaire aux exigences de Cpp17SharedLockable. L’objet est déplaçable, mais non copiable. Le mutex associé doit exister pendant toute la durée de vie restante du garde, même lorsque celui-ci ne possède pas le verrou.

La construction avec un mutex seul appelle lock_shared() et peut bloquer. Le destructeur appelle unlock_shared() si le garde possède le verrou. std::defer_lock diffère l’acquisition, std::try_to_lock tente de l’acquérir sans attendre, et std::adopt_lock exige que le thread courant possède déjà le verrou partagé. Utilisez owns_lock() ou la conversion en bool pour vérifier le résultat d’une tentative d’acquisition.

Avec std::shared_mutex, plusieurs threads peuvent posséder simultanément le verrou partagé ; une possession exclusive ne peut pas coexister avec elle. Suivez un protocole cohérent : lectures sous std::shared_lock, écritures sous un verrou exclusif tel que std::unique_lock. La possession partagée n’impose pas l’immutabilité et ne protège pas à elle seule contre les écritures simultanées des lecteurs.

unlock() libère un verrou possédé, tandis que release() détache simplement le mutex du garde — il ne le déverrouille pas. Les opérations temporisées exigent un mutex satisfaisant à Cpp17SharedTimedLockable ; std::shared_mutex ne suffit pas. L’exemple utilise volontairement un seul thread : l’écriture se termine avant la lecture, et les deux blocs illustrent la libération automatique du verrou.

Exemples

#include <iostream>
#include <mutex>
#include <shared_mutex>

int main() {
    std::shared_mutex mutex;
    int value = 0;
    {
        std::unique_lock<std::shared_mutex> writer(mutex);
        value = 42;
    }
    {
        std::shared_lock<std::shared_mutex> reader(mutex);
        std::cout << std::boolalpha
                  << reader.owns_lock() << ' ' << value << '\n';
    }
}

Résultat

true 42

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