NAME¶

std::lock_guard - std::lock_guard

Synopsis¶

Defined in header <mutex>
template< class Mutex > (since C++11)
class lock_guard;

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.

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¶

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

Notes¶

(since C++17)
std::scoped_lock offers a replacement for lock_guard that provides the
ability to lock multiple mutexes using a deadlock avoidance algorithm.

Example¶

// Run this code

#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 removed
lock_guard<Mutex> was provided

See also¶

unique_lock implements movable mutex ownership wrapper
(C++11) (class template)
scoped_lock deadlock-avoiding RAII wrapper for multiple mutexes
(C++17) (class template)