[try Beta version]
Not logged in
public member function
<mutex>

std::unique_lock::lock

void lock();
Lock mutex
Calls member lock of the managed mutex object.

Calling lock on a mutex object that has already been locked by other threads causes the current thread to block (wait) until it can own a lock to it.

When the function returns, the object owns a lock on the mutex.

If the call to lock fails, a system_error exception is thrown.

Parameters

none

Return value

none

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
// unique_lock::lock/unlock
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock, std::defer_lock

std::mutex mtx;           // mutex for critical section

void print_thread_id (int id) {
  std::unique_lock<std::mutex> lck (mtx,std::defer_lock);
  // critical section (exclusive access to std::cout signaled by locking lck):
  lck.lock();
  std::cout << "thread #" << id << '\n';
  lck.unlock();
}

int main ()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i=0; i<10; ++i)
    threads[i] = std::thread(print_thread_id,i+1);

  for (auto& th : threads) th.join();

  return 0;
}


Possible output (order of lines may vary, but they are never intermingled):
thread #1
thread #2
thread #3
thread #4
thread #5
thread #6
thread #7
thread #8
thread #9
thread #10

Data races

The unique_lock object is modified.
The managed mutex object is accessed and modified (as an atomic operation, causing no data races).

Exception safety

Basic guarantee: if an exception is thrown by this member function, the unique_lock object is left in a valid state.

If the call fails, a system_error exception is thrown:
exception typeerror conditiondescription
system_errorerrc::resource_deadlock_would_occurThe unique_lock object already owns a lock
system_errorerrc::operation_not_permittedThe unique_lock object currently manages no mutex object (because it was default-constructed, moved, or released)
An exception is also thrown if the call to lock on the managed mutex object fails, and on any other condition reported with such mechanism by the library implementation.

See also

Reference