Namespaces
Variants

std::shared_lock<Mutex>:: shared_lock

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::shared_lock
shared_lock ( ) noexcept ;
(1) (depuis C++14)
shared_lock ( shared_lock && other ) noexcept ;
(2) (depuis C++14)
explicit shared_lock ( mutex_type & m ) ;
(3) (depuis C++14)
shared_lock ( mutex_type & m, std:: defer_lock_t t ) noexcept ;
(4) (depuis C++14)
shared_lock ( mutex_type & m, std:: try_to_lock_t t ) ;
(5) (depuis C++14)
shared_lock ( mutex_type & m, std:: adopt_lock_t t ) ;
(6) (depuis C++14)
template < class Rep, class Period >

shared_lock ( mutex_type & m,

const std:: chrono :: duration < Rep,Period > & timeout_duration ) ;
(7) (depuis C++14)
template < class Clock, class Duration >

shared_lock ( mutex_type & m,

const std:: chrono :: time_point < Clock,Duration > & timeout_time ) ;
(8) (depuis C++14)

Construit un shared_lock , verrouillant optionnellement le mutex fourni.

1) Construit un shared_lock sans mutex associé.
2) Constructeur de déplacement. Initialise le shared_lock avec le contenu de other . Laisse other sans mutex associé.
3-8) Construit un shared_lock avec m comme mutex associé. De plus :
3) Verrouille le mutex associé en mode partagé en appelant m. lock_shared ( ) .
4) Ne verrouille pas le mutex associé.
5) Tente de verrouiller le mutex associé en mode partagé sans bloquer en appelant m. try_lock_shared ( ) .
6) Suppose que le thread appelant détient déjà un verrou partagé (c'est-à-dire un verrou acquis par lock_shared , try_lock_shared , try_lock_shared_for , ou try_lock_shared_until ) sur m . Le comportement est indéfini si ce n'est pas le cas.
7) Tente de verrouiller le mutex associé en mode partagé en appelant m. try_lock_shared_for ( timeout_duration ) , ce qui bloque jusqu'à ce que la durée spécifiée timeout_duration se soit écoulée ou que le verrou soit acquis, selon la première éventualité. Peut bloquer plus longtemps que timeout_duration . Le comportement est indéfini si Mutex ne satisfait pas aux exigences SharedTimedLockable .
8) Tente de verrouiller le mutex associé en mode partagé en appelant m. try_lock_shared_until ( timeout_time ) , ce qui bloque jusqu'à ce que le timeout_time spécifié soit atteint ou que le verrou soit acquis, selon la première éventualité. Peut bloquer plus longtemps que jusqu'à ce que timeout_time soit atteint. Le comportement est indéfini si Mutex ne satisfait pas aux exigences SharedTimedLockable .

Paramètres

other - un autre shared_lock pour initialiser l'état
m - mutex à associer au verrou et optionnellement en acquérir la propriété
t - paramètre de balise utilisé pour sélectionner les constructeurs avec différentes stratégies de verrouillage
timeout_duration - durée maximale de blocage
timeout_time - point temporel maximum jusqu'auquel bloquer

Exemple

Exécuter ce code 
#include <chrono>
#include <iostream>
#include <shared_mutex>
#include <syncstream>
#include <thread>
std::shared_timed_mutex m;
int i = 10;
void read_shared_var(int id)
{
     // les deux threads obtiennent l'accès à l'entier i
     std::shared_lock<std::shared_timed_mutex> slk(m);
     const int ii = i; // lit i global
     std::osyncstream(std::cout) << '#' << id << " a lu i comme " << ii << "...\n";
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
     std::osyncstream(std::cout) << '#' << id << " s'est réveillé..." << std::endl;
}
int main()
{
     std::thread r1{read_shared_var, 1};
     std::thread r2{read_shared_var, 2};
     r1.join();
     r2.join();
}

Sortie possible : 

#2 read i as 10...
#1 read i as 10...
#2 woke up...
#1 woke up...