std::unique_lock

 

C++

Language

Standard library headers

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

 

Defined in header <mutex>
template< class Mutex > class unique_lock;		(since C++11)

The class unique_lock is a general-purpose mutex ownership wrapper allowing deferred locking, timed locking, recursive locking, transfer of lock ownership, and use with condition variables.

The unique_lock class is non-copyable, but it is movable. The supplied Mutex type shall implement the BasicLockable concept.

Member types

Type	Definition
mutex_type	Mutex

Member functions

(constructor)	constructs a unique_lock, optionally locking the supplied mutex (public member function)
(destructor)	unlocks the associated mutex, if owned (public member function)
operator=	unlocks the mutex, if owned, and acquires ownership of another (public member function)
Locking
lock	locks the associated mutex (public member function)
try_lock	tries to lock the associated mutex, returns if the mutex is not available (public member function)
try_lock_for	attempts to lock the associated TimedLockable mutex, returns if the mutex has been unavailable for the specified time duration (public member function)
try_lock_until	tries to lock the associated TimedLockable mutex, returns if the mutex has been unavailable until specified time point has been reached (public member function)
unlock	unlocks the associated mutex (public member function)
Modifiers
swap	swaps state with another std::unique_lock (public member function)
release	disassociates the associated mutex without unlocking it (public member function)
Observers
mutex	returns a pointer to the associated mutex (public member function)
owns_lock	tests whether the lock owns its associated mutex (public member function)
operator bool	tests whether the lock owns its associated mutex (public member function)

Non-member functions

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

Example

run this code

#include <mutex>
#include <thread>
#include <chrono>
 
struct bank_account {
    explicit bank_account(int balance) : balance(balance) {}
    int balance;
    std::mutex m;
};
 
void slow_log(bank_account &from, bank_account &to, int amount)
{
    // simulate a very slow logging operation
    std::this_thread::sleep_for(std::chrono::seconds(10));
}
 
void transfer(bank_account &from, bank_account &to, int amount)
{
    // don't actually take the locks yet
    std::unique_lock lock1(from.m, std::defer_lock);
    std::unique_lock lock2(to.m, std::defer_lock);
 
    // lock both unique_locks without deadlock
    std::lock(lock1, lock2);
 
    from.balance -= amount;
    to.balance += amount;
 
    // unlock the locks so the slow logging calls won't block eachother
    int from_copy = from.balance;
    int to_copy = to.balance;
 
    lock1.unlock();
    lock2.unlock();
 
    slow_log(from_copy, to_copy, amount);
}
 
int main()
{
    bank_account my_account(100);
    bank_account your_account(50);
 
    std::thread t1(transfer, my_account, your_account, 10);
    std::thread t2(transfer, your_account, my_account, 5);
 
    t1.join();
    t2.join();
}