Namespaces
Variants
Actions

std::unique_lock<Mutex>::unique_lock

From cppreference.com
< cpp‎ | thread‎ | unique lock
 
 
Concurrency support library
(C++11)
(C++20)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++17)
(C++11)
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)
(C++20)
(C++20)
(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++11)
(C++11)(deprecated in C++20)
(C++11)(deprecated in C++20)
(C++11)
(C++11)(deprecated in C++26)
 
 
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.

[edit] 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

[edit] 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"

AltStyle によって変換されたページ (->オリジナル) /