# std::lock_guard

From cppreference.com
< cpp‎ | thread

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

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

### 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 (C++11) | implements movable mutex ownership wrapper (class template)
scoped_lock (C++17) | deadlock-avoiding RAII wrapper for multiple mutexes (class template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/thread/lock_guard&oldid=103479"