std::unique_lock - cppreference.com (original) (raw)

| | | | | -------------------------------------------- | | ------------- | | template< class Mutex > class unique_lock; | | (since C++11) |

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

The class unique_lock is movable, but not copyable -- it meets the requirements of MoveConstructible and MoveAssignable but not of CopyConstructible or CopyAssignable.

The class unique_lock meets the BasicLockable requirements. If Mutex meets the Lockable requirements, unique_lock also meets the Lockable requirements (ex.: can be used in std::lock); if Mutex meets the TimedLockable requirements, unique_lock also meets the TimedLockable requirements.

Contents

• 1 Template parameters
• 2 Nested types
• 3 Member functions
  • 3.1 Locking
  • 3.2 Modifiers
  • 3.3 Observers
• 4 Non-member functions
• 5 Notes
• 6 Example
• 7 Defect reports
• 8 See also

[edit] Template parameters

[edit] Nested types

[edit] Member functions

[edit] Non-member functions

[edit] Notes

A common beginner error is to "forget" to give a unique_lock variable a name, e.g. std::unique_lock(mtx); (which default constructs a unique_lock variable named mtx) or std::unique_lock{mtx}; (which constructs a prvalue object that is immediately destroyed), thereby not actually constructing a lock that holds a mutex for the rest of the scope.

[edit] Example

#include #include #include   struct Box { explicit Box(int num) : num_things{num} {}   int num_things; std::mutex m; };   void transfer(Box& from, Box& to, int num) { // 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.num_things -= num; to.num_things += num;   // “from.m” and “to.m” mutexes unlocked in unique_lock dtors }   int main() { Box acc1{100}; Box acc2{50};   std::thread t1{transfer, std::ref(acc1), std::ref(acc2), 10}; std::thread t2{transfer, std::ref(acc2), std::ref(acc1), 5};   t1.join(); t2.join();   std::cout << "acc1: " << acc1.num_things << "\n" "acc2: " << acc2.num_things << '\n'; }

Output:

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

| | locks specified mutexes, blocks if any are unavailable (function template) [edit] | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | implements a strictly scope-based mutex ownership wrapper (class template) [edit] | | | deadlock-avoiding RAII wrapper for multiple mutexes (class template) [edit] | | | provides basic mutual exclusion facility (class) [edit] |