std::shared_lock<Mutex>:: shared_lock

From cppreference.com
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)
(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) (since C++14)
shared_lock ( shared_lock && other ) noexcept ;
(2) (since C++14)
explicit shared_lock ( mutex_type & m ) ;
(3) (since C++14)
shared_lock ( mutex_type & m, std:: defer_lock_t t ) noexcept ;
(4) (since C++14)
shared_lock ( mutex_type & m, std:: try_to_lock_t t ) ;
(5) (since C++14)
shared_lock ( mutex_type & m, std:: adopt_lock_t t ) ;
(6) (since C++14)
template < class Rep, class Period >

shared_lock ( mutex_type & m,

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

shared_lock ( mutex_type & m,

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

Constructs a shared_lock , optionally locking the supplied mutex.

1) Constructs a shared_lock with no associated mutex.
2) Move constructor. Initializes the shared_lock with the contents of other . Leaves other with no associated mutex.
3-8) Constructs a shared_lock with m as the associated mutex. Additionally:
3) Locks the associated mutex in shared mode by calling m. lock_shared ( ) .
4) Does not lock the associated mutex.
5) Tries to lock the associated mutex in shared mode without blocking by calling m. try_lock_shared ( ) .
6) Assumes the calling thread already holds a shared lock (i.e., a lock acquired by lock_shared , try_lock_shared , try_lock_shared_for , or try_lock_shared_until ) on m . The behavior is undefined if not so.
7) Tries to lock the associated mutex in shared mode by calling m. try_lock_shared_for ( timeout_duration ) , which blocks until specified timeout_duration has elapsed or the lock is acquired, whichever comes first. May block for longer than timeout_duration . The behavior is undefined if Mutex does not meet the SharedTimedLockable requirements.
8) Tries to lock the associated mutex in shared mode by calling m. try_lock_shared_until ( timeout_time ) , which blocks until specified timeout_time has been reached or the lock is acquired, whichever comes first. May block for longer than until timeout_time has been reached. The behavior is undefined if Mutex does not meet the SharedTimedLockable requirements.

Parameters

other - another shared_lock to initialize the state with
m - mutex to associate with the lock and optionally acquire ownership of
t - tag parameter used to select constructors with different locking strategies
timeout_duration - maximum duration to block for
timeout_time - maximum time point to block until

Example

Run this 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)
{
     // both the threads get access to the integer i
     std::shared_lock<std::shared_timed_mutex> slk(m);
     const int ii = i; // reads global i
 
     std::osyncstream(std::cout) << '#' << id << " read i as " << ii << "...\n";
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
     std::osyncstream(std::cout) << '#' << id << " woke up..." << std::endl;
}
 
int main()
{
     std::thread r1{read_shared_var, 1};
     std::thread r2{read_shared_var, 2};
 
     r1.join();
     r2.join();
}

Possible output: 

#2 read i as 10...
#1 read i as 10...
#2 woke up...
#1 woke up...
Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/thread/shared_lock/shared_lock&oldid=161226 "