CKTIS / C++
std::shared_mutex — verrouillage partagé et exclusif
std::shared_mutex permet à plusieurs threads de détenir simultanément un verrou partagé, ou à un seul thread de détenir un verrou exclusif. Utilisez std::shared_lock pour lire et std::unique_lock pour écrire, en suivant le même protocole pour chaque accès aux données protégées.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <shared_mutex>
#include <mutex>
std::shared_mutex m;
// In separate scopes:
{ std::shared_lock<std::shared_mutex> read_lock(m); }
{ std::unique_lock<std::shared_mutex> write_lock(m); }std::shared_mutex, déclaré dans <shared_mutex>, est un mutex non récursif. Le mode partagé permet à plusieurs détenteurs d’être présents à la fois ; le mode exclusif exclut tous les autres détenteurs. Le protocole habituel consiste à lire en mode partagé et à modifier en mode exclusif. Le mutex ne contrôle pas à lui seul l’accès aux variables : votre code doit respecter ce protocole de façon cohérente.
lock() et unlock() gèrent la détention exclusive, tandis que lock_shared() et unlock_shared() gèrent la détention partagée. Les opérations bloquantes attendent que la détention puisse être obtenue. try_lock() et try_lock_shared() tentent de l’obtenir sans attendre et renvoient bool ; elles peuvent échouer de manière intempestive. Ainsi, false ne prouve pas qu’un autre thread détient le mutex.
Préférez RAII au déverrouillage manuel : utilisez std::shared_lock<std::shared_mutex> de <shared_mutex> pour les lecteurs et std::unique_lock<std::shared_mutex> de <mutex> pour les rédacteurs. Ces objets libèrent un verrou détenu à la sortie de leur portée, y compris lors de la propagation d’une exception. La détention partagée ne fournit pas l’exclusivité nécessaire à la modification ordinaire de données partagées.
Ne tentez pas d’acquérir à nouveau l’un ou l’autre type de détention dans un thread qui détient déjà le même mutex : le comportement est indéfini. Cela inclut toute tentative d’acquisition exclusive sans libérer la détention partagée. Déverrouiller puis reverrouiller ne constitue pas un changement de mode atomique : les données peuvent changer entre les deux. Ne détruisez pas un mutex détenu et ne laissez pas un thread se terminer tant qu’il détient encore le mutex.
L’exemple sépare l’écriture de la lecture au moyen de join() et protège chaque accès à value avec le verrou approprié. Les lecteurs peuvent s’exécuter en parallèle, mais ce n’est pas obligatoire ; ils enregistrent leurs résultats dans des variables distinctes. L’affichage après les deux appels à join() produit le résultat déterministe 42 42.
Exemples
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
int main() {
std::shared_mutex mutex;
int value = 0;
std::thread writer([&] {
std::unique_lock<std::shared_mutex> lock(mutex);
value = 42;
});
writer.join();
int first = 0;
int second = 0;
std::thread reader1([&] {
std::shared_lock<std::shared_mutex> lock(mutex);
first = value;
});
std::thread reader2([&] {
std::shared_lock<std::shared_mutex> lock(mutex);
second = value;
});
reader1.join();
reader2.join();
std::cout << first << ' ' << second << '\n';
}
Résultat
42 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
- C++ working draft — Concurrency support library [thread]
- C++ working draft — Class shared_mutex [thread.sharedmutex.class]
- C++ working draft — Shared mutex types [thread.sharedmutex.requirements]
- C++ working draft — Class template shared_lock [thread.lock.shared]
- C++ working draft — Class template unique_lock [thread.lock.unique]