std::lock_guard (3) - Linux Man Pages

std::lock_guard: std::lock_guard

NAME

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)