std::shared_lock (3) - Linux Man Pages

std::shared_lock: std::shared_lock


std::shared_lock - std::shared_lock


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.
In order to wait in a shared mutex in shared ownership mode, std::condition_variable_any can be used (std::condition_variable requires 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 SharedMutex requirements

Member types

Type Definition
mutex_type Mutex

Member functions

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

Shared locking

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


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


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

Non-member functions

                            specialization of std::swap for shared_lock
std::swap(std::shared_lock) (function template)

Defect reports

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

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