std::unique_lock<Mutex>:: unique_lock

From cppreference.com
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe Reclamation
Hazard Pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::unique_lock
unique_lock ( ) noexcept ;
(1) (since C++11)
unique_lock ( unique_lock && other ) noexcept ;
(2) (since C++11)
explicit unique_lock ( mutex_type & m ) ;
(3) (since C++11)
unique_lock ( mutex_type & m, std:: defer_lock_t t ) noexcept ;
(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 Duration >

unique_lock ( mutex_type & m,

const std:: chrono :: time_point < Clock, Duration > & timeout_time ) ;
(8) (since C++11)

Constructs a unique_lock , optionally locking the supplied mutex.

1) Constructs a unique_lock with no associated mutex.
2) Move constructor. Initializes the unique_lock with the contents of other . Leaves other with no associated mutex.
3-8) Constructs a unique_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. try_lock ( ) . The behavior is undefined if Mutex does not satisfy Lockable .
6) Assumes the calling thread already holds a non-shared lock (i.e., a lock acquired by lock , try_lock , try_lock_for , or try_lock_until ) on m . The behavior is undefined if not so.
7) Tries to lock the associated mutex by calling m. try_lock_for ( timeout_duration ) . Blocks until specified timeout_duration has elapsed or the lock is acquired, whichever comes first. May block for longer than timeout_duration . The behavior is undefined if Mutex does not satisfy TimedLockable .
8) Tries to lock the associated mutex by calling m. try_lock_until ( timeout_time ) . 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. The behavior is undefined if Mutex does not satisfy TimedLockable .

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

Example

Run this code 
#include <iostream>
#include <mutex>
#include <thread>
#include <utility>
#include <vector>
 
std::mutex m_a, m_b, m_c;
int a, b, c = 1;
 
void update()
{
    {   // Note: std::lock_guard or atomic<int> can be used instead
        std::unique_lock<std::mutex> lk(m_a);
        ++a;
    }
 
    {   // Note: see std::lock and std::scoped_lock for details and alternatives
        std::unique_lock<std::mutex> lk_b(m_b, std::defer_lock);
        std::unique_lock<std::mutex> lk_c(m_c, std::defer_lock);
        std::lock(lk_b, lk_c);
        b = std::exchange(c, b + c);
    }
}
 
int main()
{
    std::vector<std::thread> threads;
    for (unsigned i = 0; i < 12; ++i)
        threads.emplace_back(update);
 
    for (auto& i : threads)
        i.join();
 
    std::cout << a << "'th and " << a + 1 << "'th Fibonacci numbers: "
              << b << " and " << c << '\n';
}

Output: 

12'th and 13'th Fibonacci numbers: 144 and 233
Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/thread/unique_lock/unique_lock&oldid=161298 "