< cpp‎ | thread
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 std::lock.

(since C++17)

The lock_guard class is non-copyable.


[edit] Template parameters

Mutex - the type of the mutex to lock. The type must meet the BasicLockable requirements
(since C++11)
(until C++17)
MutexTypes - the types of the mutexes to lock. The types must meet the Lockable requirements unless sizeof...(MutexTypes)==1, in which case the only type must meet BasicLockable
(since C++17)

[edit] Member types

Member type Definition
mutex_type Mutex

[edit] 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)
not copy-assignable
(public member function)

[edit] 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);
    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);
    std::cout << __func__ << ": " << g_i << '\n';

Possible output:

main: 0
140641306900224: 1
140641298507520: 2
main: 2

[edit] See also

implements movable mutex ownership wrapper
(class template)