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 wrap-
     per 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 a it meets the re-
     quirements of
	MoveConstructible and MoveAssignable but  not  of  CopyConstructible  or
     CopyAssignable.

	shared_lock  meets the Lockable requirements. If Mutex meets the Shared-
     TimedLockable
	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 supplied
     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 du-
     ration
		       (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		    Cor-
     rect behavior
	LWG  2981 C++17      redundant deduction guide from		     re-
     moved
			    shared_lock<Mutex> was provided

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