Difference between revisions of "cpp/thread/lock guard"
m (reorder) |
(copy "schoolboy error" note from std::scoped_lock page) |
||
| Line 30: | Line 30: | ||
{{dsc end}} | {{dsc end}} | ||
| − | |||
===Notes=== | ===Notes=== | ||
| + | A schoolboy error would be to "forget" to give a {{tt|lock_guard}} variable a name, e.g. {{c|std::lock_guard(mtx);}} (which default constructs a {{tt|lock_guard}} variable named {{tt|mtx}}) or {{c|std::lock_guard{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. | ||
| + | |||
| + | {{rrev|since=c++17| | ||
{{ltt|cpp/thread/scoped_lock|std::scoped_lock}} offers a replacement for {{tt|lock_guard}} that provides the ability to lock multiple mutexes using a deadlock avoidance algorithm. | {{ltt|cpp/thread/scoped_lock|std::scoped_lock}} offers a replacement for {{tt|lock_guard}} that provides the ability to lock multiple mutexes using a deadlock avoidance algorithm. | ||
}} | }} | ||
Revision as of 07:08, 15 May 2023
| Defined in header <mutex>
|
||
| template< class Mutex > class lock_guard; |
(since C++11) | |
The class lock_guard is a mutex wrapper that provides a convenient RAII-style mechanism for owning a mutex for the duration of a scoped block.
When a lock_guard object is created, it attempts to take ownership of the mutex it is given. When control leaves the scope in which the lock_guard object was created, the lock_guard is destructed and the mutex is released.
The lock_guard class is non-copyable.
Contents |
Template parameters
| Mutex | - | the type of the mutex to lock. The type must meet the BasicLockable requirements |
Member types
| Member type | Definition |
mutex_type
|
Mutex |
Member functions
constructs a lock_guard, optionally locking the given mutex (public member function) | |
destructs the lock_guard object, unlocks the underlying mutex (public member function) | |
| operator= [deleted] |
not copy-assignable (public member function) |
Notes
A schoolboy error would be to "forget" to give a lock_guard variable a name, e.g. std::lock_guard(mtx); (which default constructs a lock_guard variable named mtx) or std::lock_guard{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.
|
std::scoped_lock offers a replacement for |
(since C++17) |
Example
#include <thread> #include <mutex> #include <iostream> int g_i = 0; std::mutex g_i_mutex; // protects g_i void safe_increment() { const std::lock_guard<std::mutex> lock(g_i_mutex); ++g_i; std::cout << "g_i: " << g_i << "; in thread #" << std::this_thread::get_id() << '\n'; // g_i_mutex is automatically released when lock // goes out of scope } int main() { std::cout << "g_i: " << g_i << "; in main()\n"; std::thread t1(safe_increment); std::thread t2(safe_increment); t1.join(); t2.join(); std::cout << "g_i: " << g_i << "; in main()\n"; }
Possible output:
g_i: 0; in main() g_i: 1; in thread #140487981209344 g_i: 2; in thread #140487972816640 g_i: 2; in main()
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 2981 | C++17 | redundant deduction guide from lock_guard<Mutex> was provided
|
removed |
See also
| (C++11) |
implements movable mutex ownership wrapper (class template) |
| (C++17) |
deadlock-avoiding RAII wrapper for multiple mutexes (class template) |
