std::lock_guard(3)

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)