std::unique_lock::unique_lock

 

C++

Language

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Thread support library

Threads
thread (C++11)
this_thread namespace
get_id (C++11) yield (C++11)	sleep_for (C++11) sleep_until (C++11)
Mutual exclusion
mutex (C++11) timed_mutex (C++11)	recursive_mutex (C++11) recursive_timed_mutex (C++11)
Generic lock management
lock_guard (C++11) unique_lock (C++11) defer_lock_t try_to_lock_t adopt_lock_t (C++11) (C++11) (C++11)	lock (C++11) try_lock (C++11) defer_lock try_to_lock adopt_lock (C++11) (C++11) (C++11)
Condition variables
condition_variable (C++11)
condition_variable_any (C++11)
notify_all_at_thread_exit (C++11)
cv_status (C++11)
Futures
promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11)	launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11)

 

std::unique_lock

Member functions

unique_lock::unique_lock

unique_lock::~unique_lock

unique_lock::operator=

Locking

unique_lock::lock

unique_lock::try_lock

unique_lock::try_lock_for

unique_lock::try_lock_until

unique_lock::unlock

Modifiers

unique_lock::swap

unique_lock::release

Observers

unique_lock::mutex

unique_lock::owns_lock

unique_lock::operator bool

Non-member functions

std::swap

 

unique_lock();	(1)	(since C++11)
unique_lock( unique_lock&& other );	(2)	(since C++11)
explicit unique_lock( mutex_type& m );	(3)	(since C++11)
unique_lock( mutex_type& m, std::defer_lock_t t );	(4)	(since C++11)
unique_lock( mutex_type& m, std::try_to_lock_t t );	(5)	(since C++11)
unique_lock( mutex_type& m, std::adopt_lock_t t );	(6)	(since C++11)
template< class Rep, class Period > unique_lock( mutex_type& m,              const std::chrono::duration<Rep,Period>& timeout_duration );	(7)	(since C++11)
template< class Clock, class Period > unique_lock( mutex_type& m,              const std::chrono::time_point<Clock,Duration>& timeout_time );	(8)	(since C++11)

Constructs the lock optionally locking the supplied mutex.

1) Constructs the lock with no associated mutex.

2) Move constructor. Initializes the state with the contents of other.

3-8) Constructs the lock with m as the associated mutex. Additionally:

3) Locks the associated mutex by calling m.lock().

4) Does not lock the associated mutex.

5) Tries to lock the associated mutex without blocking by calling m.trylock().

6) Assumes the calling thread already owns m.

7) Tries to lock the associated mutex. Blocks until specified timeout_duration has elapsed or the lock is acquired, whichever comes first. May block for longer than timeout_duration.

8) Tries to lock the associated mutex. 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.

Parameters

other	-	another unique_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

Exceptions

1-2)

noexcept specification:  

noexcept

  (since C++11)

3) 4)

noexcept specification:  

noexcept

  (since C++11)

5-8)