FreeBSD Manual Pages
std::shared...:shared_lock(3) C++ Standard Libarystd::shared...:shared_lock(3) NAME std::shared_lock::shared_lock - std::shared_lock::shared_lock Synopsis 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) const std::chrono::duration<Rep,Period>& timeout_duration ); template< class Clock, class Duration > shared_lock( mutex_type& m, (8) (since C++14) const std::chrono::time_point<Clock,Duration>& timeout_time ); 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. Addi- tionally: 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 block- ing 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 speci- fied 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 <shared_mutex> #include <syncstream> #include <iostream> #include <thread> #include <chrono> 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... http://cppreference.com 2022.07.31 std::shared...:shared_lock(3)
NAME | Synopsis | Parameters | Example | Possible output:
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::shared_lock::shared_lock&sektion=3&manpath=FreeBSD+Ports+15.0>