std::shared_lock<Mutex>::shared_lock
< cpp | thread | 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, |
(7) | (since C++14) |
template< class Clock, class Duration > shared_lock( mutex_type& m, |
(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(). The behavior is undefined if this thread already owns the mutex in any mode.
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(). The behavior is undefined if this thread already owns the mutex in any mode.
6) Assumes the calling thread already owns
m
in shared mode.7) Tries to lock the associated mutex in shared mode by calling m.try_lock_shared_until(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 this thread already owns the mutex in any mode.8) Tries to lock the associated mutex in shared mode by calling m.try_lock_shared_for(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 this thread already owns the mutex in any mode.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 <shared_mutex> #include <iostream> #include <thread> #include <chrono> std::shared_timed_mutex m; int i = 10; void read() { // both the threads get access to the integer i std::shared_lock<std::shared_timed_mutex> slk(m); std::cout << "read i as " << i << "...\n"; // this is not synchronized std::this_thread::sleep_for(std::chrono::milliseconds(10)); std::cout << "woke up...\n"; } int main() { std::thread r1(read); std::thread r2(read); r1.join(); r2.join(); return 0; }