| Defined in header <mutex> | ||
|---|---|---|
template< class Mutex > class lock_guard; | (since C++11) (until C++17) | |
template< class... MutexTypes > class lock_guard; | (since C++17) |
The class lock_guard is a mutex wrapper that provides a convenient RAII-style mechanism for owning a mutex or several mutexes (since C++17) 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.
| If several mutexes are given, deadlock avoidance algorithm is used as if by | (since C++17) |
The lock_guard class is non-copyable.
Template parameters
| (since C++11) (until C++17) | |||
| (since C++17) |
Member types
| Member type | Definition |
|---|---|
mutex_type | Mutex |
Member functions
| constructs a lock_guard, optionally locking the given mutex (public member function) | |
| (destructor)
| destructs the lock_guard object, unlocks the underlying mutex (public member function) |
| operator= [deleted] | not copy-assignable (public member function) |
Example
#include <thread>
#include <mutex>
#include <iostream>
int g_i = 0;
std::mutex g_i_mutex; // protects g_i
void safe_increment()
{
std::lock_guard<std::mutex> lock(g_i_mutex);
++g_i;
std::cout << std::this_thread::get_id() << ": " << g_i << '\n';
// g_i_mutex is automatically released when lock
// goes out of scope
}
int main()
{
std::cout << __func__ << ": " << g_i << '\n';
std::thread t1(safe_increment);
std::thread t2(safe_increment);
t1.join();
t2.join();
std::cout << __func__ << ": " << g_i << '\n';
}Possible output:
main: 0 140641306900224: 1 140641298507520: 2 main: 2
See also
| (C++11) | implements movable mutex ownership wrapper (class template) |
Please login to continue.