std::unique_lock::unique_lock

(1) default constructor

The object manages no mutex object.

(2) locking initialization

The object manages m, and locks it (blocking, if necessary) by calling m.lock().

(3) try-locking initialization

The object manages m, and attempts to lock it (without blocking) by calling m.try_lock().

(4) deferred initialization

The object manages m without locking it. m shall be a mutex object that is not currently locked by the constructing thread.

(5) adopting initialization

The object manages m, which is a mutex object currently locked by the constructing thread (the object acquires ownership over the lock).

(6) locking for duration

The object manages m, and attempts to lock it during rel_time by calling m.try_lock_for(rel_time).

(7) locking until time point

The object manages m, and attempts to lock it before abs_time by calling m.try_lock_until(abs_time).

(8) copy construction [deleted]

unique_lock objects cannot be copied (copy constructor deleted).

(9) move construction

The object acquires the mutex managed by x, including its current owning state.
x is left in the same state as if default-constructed (referring to no mutex object).

Parameters

m

mutex object to be managed by the unique_lock object.
mutex_type is unique_lock's template parameter (the type of the managed mutex object).

tag

This tag argument is merely used to select a specific constructor (values of these types have no state).
It is one of the following values:

value	description
(no tag)	Lock on construction by calling member lock.
try_to_lock	Attempt to lock on construction by calling member try_lock
defer_lock	Do not lock on construction (and assume it is not already locked by thread)
adopt_lock	Adopt current lock (assume it is already locked by thread).

try_to_lock_t, defer_lock_t and adopt_lock_t are the types of objects try_to_lock, defer_lock and adopt_lock, respectively.

rel_time

The maximum time span during which the thread could block waiting to acquire a lock. If exhausted, the object is initialized not owning a lock.
duration is an object that represents a specific relative time.

abs_time

A point in time at which the thread will stop blocking waiting to acquire a lock. If reached, the object is initialized not owning a lock.
time_point is an object that represents a specific absolute time.

x

Another unique_lock object.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// unique_lock constructor example
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock, std::unique_lock
                          // std::adopt_lock, std::defer_lock
std::mutex foo,bar;

void task_a () {
  std::lock (foo,bar);         // simultaneous lock (prevents deadlock)
  std::unique_lock<std::mutex> lck1 (foo,std::adopt_lock);
  std::unique_lock<std::mutex> lck2 (bar,std::adopt_lock);
  std::cout << "task a\n";
  // (unlocked automatically on destruction of lck1 and lck2)
}

void task_b () {
  // foo.lock(); bar.lock(); // replaced by:
  std::unique_lock<std::mutex> lck1, lck2;
  lck1 = std::unique_lock<std::mutex>(bar,std::defer_lock);
  lck2 = std::unique_lock<std::mutex>(foo,std::defer_lock);
  std::lock (lck1,lck2);       // simultaneous lock (prevents deadlock)
  std::cout << "task b\n";
  // (unlocked automatically on destruction of lck1 and lck2)
}


int main ()
{
  std::thread th1 (task_a);
  std::thread th2 (task_b);

  th1.join();
  th2.join();

  return 0;
}

task a
task b

Data races

Exception safety

See also

unique_lock::lock

Lock mutex (public member function )

unique_lock::try_lock

Lock mutex if not locked (public member function )

unique_lock::try_lock_for

Try to lock mutex during time span (public member function )

unique_lock::try_lock_until

Try to lock mutex until time point (public member function )

unique_lock::~unique_lock

Destroy unique_lock (public member function )