Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::shared_lock(3)	      C++ Standard Libary	   std::shared_lock(3)

NAME
       std::shared_lock	- std::shared_lock

Synopsis
	  Defined in header <shared_mutex>
	  template< class Mutex	>	    (since C++14)
	  class	shared_lock;

	  The  class  shared_lock  is a	general-purpose	shared mutex ownership
       wrapper allowing
	  deferred locking, timed locking  and	transfer  of  lock  ownership.
       Locking a
	  shared_lock  locks  the  associated  shared mutex in shared mode (to
       lock it in
	  exclusive mode, std::unique_lock can be used)

	  The shared_lock class	is movable, but	not copyable --	it  meets  the
       requirements of
	  MoveConstructible and	MoveAssignable but not of CopyConstructible or
       CopyAssignable.

	  shared_lock  meets  the  Lockable  requirements.  If Mutex meets the
       SharedTimedLockable
	  requirements,	shared_lock also meets TimedLockable requirements.

	  In order to wait in a	shared mutex in	shared ownership mode,
	  std::condition_variable_any can be used (std::condition_variable re-
       quires
	  std::unique_lock and so can only wait	in unique ownership mode)

Template parameters
	  Mutex	- the type of the shared mutex to lock.	The type must meet the
       SharedLockable
		  requirements

Member types
	  Type	     Definition
	  mutex_type Mutex

Member functions
	  constructor	 constructs a shared_lock, optionally locking the sup-
       plied mutex
			 (public member	function)
	  destructor	 unlocks the associated	mutex
			 (public member	function)
	  operator=	 unlocks the mutex, if owned, and  acquires  ownership
       of another
			 (public member	function)

Shared locking
	  lock		 locks the associated mutex
			 (public member	function)
	  try_lock	 tries to lock the associated mutex
			 (public member	function)
	  try_lock_for	 tries to lock the associated mutex, for the specified
       duration
			 (public member	function)
	  try_lock_until tries to lock the associated mutex, until a specified
       time point
			 (public member	function)
	  unlock	 unlocks the associated	mutex
			 (public member	function)

Modifiers
	  swap		 swaps the data	members	with another shared_lock
			 (public member	function)
	  release	 disassociates the mutex without unlocking
			 (public member	function)

Observers
	  mutex		 returns a pointer to the associated mutex
			 (public member	function)
	  owns_lock	 tests whether the lock	owns its associated mutex
			 (public member	function)
	  operator bool	 tests whether the lock	owns its associated mutex
			 (public member	function)

Non-member functions
	  std::swap(std::shared_lock)	 specialization	  of   std::swap   for
       shared_lock
	  (C++14)		      (function	template)

	 Defect	reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	     Applied	to		   Behavior    as    published
       Correct behavior
	  LWG	 2981	 C++17	       redundant    deduction	 guide	  from
       removed
			      shared_lock<Mutex> was provided

http://cppreference.com		  2022.07.31		   std::shared_lock(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::shared_lock&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help