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.