home | help 
std::shared...:shared_lock(3)  C++ Standard Libary std::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.  Addition-
     ally:
	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 Mu-
     tex 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 ac-
     quire ownership
			   of
	t		 - tag parameter used to select constructors  with  dif-
     ferent 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...

http://cppreference.com 	   2024.06.10	   std::shared...:shared_lock(3)
home | help