SysTutorials

Linux Manual Pages › Section 3

stdlock_guard(3)

std::lock_guard - std::lock_guard

Synopsis

Defined in header <mutex>
template< class Mutex >
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

              constructs a lock_guard, optionally locking the given mutex constructor (public member function)               destructs the lock_guard object, unlocks the underlying mutex destructor (public member function)

operator= not copy-assignable               (public member function) [deleted]

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()
{
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 << "main: " << g_i << ‘\n’;
std::thread t1(safe_increment);
std::thread t2(safe_increment);
t1.join();
t2.join();
std::cout << "main: " << g_i << ‘\n’;
}

Possible output:

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

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

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