std::lock_guard - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# 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.

### [edit] Template parameters

Mutex | - | the type of the mutex to lock. The type must meet the `BasicLockable` requirements

### [edit] Member types

Member type | Definition
`mutex_type` | Mutex

### [edit] Member functions

(constructor) | constructs a lock_guard, optionally locking the given mutex (public member function) [edit]
(destructor) | destructs the lock_guard object, unlocks the underlying mutex (public member function) [edit]
operator= [deleted] | not copy-assignable (public member function) [edit]

### [edit] 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 << __func__ << ": " << g_i << '\n';

        std::thread t1(safe_increment);
        std::thread t2(safe_increment);

        t1.join();
        t2.join();

        std::cout << __func__ << ": " << g_i << '\n';
    }

Possible output:

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

### [edit] See also

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

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