std::lock_guard - cppreference.com (original) (raw)

| | | | | ------------------------------------------- | | ------------- | | template< class Mutex > class lock_guard; | | (since C++11) |

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.

Contents

• 1 Template parameters
• 2 Member types
• 3 Member functions
• 4 Notes
• 5 Example
• 6 Defect reports
• 7 See also

[edit] Template parameters

[edit] Member types

[edit] Member functions

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

[edit] Notes

A common beginner error is to forget to give a lock_guard variable a name, such as by std::lock_guard{mtx}. This constructs a prvalue object that is immediately destroyed, thereby not actually constructing a lock that holds a mutex for the rest of the scope.

[edit] Example

Demonstrates safe and unsafe increments of a volatile variable by two threads.

#include #include #include #include #include   volatile int g_i = 0; std::mutex g_i_mutex; // protects g_i   void safe_increment(int iterations) { const std::lock_guard<std::mutex> lock(g_i_mutex); while (iterations-- > 0) g_i = g_i + 1; std::cout << "thread #" << std::this_thread::get_id() << ", g_i: " << g_i << '\n';   // g_i_mutex is automatically released when lock goes out of scope }   void unsafe_increment(int iterations) { while (iterations-- > 0) g_i = g_i + 1; std::osyncstream(std::cout) << "thread #" << std::this_thread::get_id() << ", g_i: " << g_i << '\n'; }   int main() { auto test = fun_name, auto fun) { g_i = 0; std::cout << fun_name << ":\nbefore, g_i: " << g_i << '\n'; { std::jthread t1(fun, 1'000'000); std::jthread t2(fun, 1'000'000); } std::cout << "after, g_i: " << g_i << "\n\n"; }; test("safe_increment", safe_increment); test("unsafe_increment", unsafe_increment); }

Possible output:

safe_increment: before, g_i: 0 thread #140121493231360, g_i: 1000000 thread #140121484838656, g_i: 2000000 after, g_i: 2000000   unsafe_increment: before, g_i: 0 thread #140121484838656, g_i: 1028945 thread #140121493231360, g_i: 1034337 after, g_i: 1034337

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

| | implements movable mutex ownership wrapper (class template) [edit] | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | deadlock-avoiding RAII wrapper for multiple mutexes (class template) [edit] |