< cpp‎ | thread
Defined in header <mutex>
template< class... MutexTypes >
class scoped_lock;
(since C++17)

The class scoped_lock is a mutex wrapper that provides a convenient RAII-style mechanism for owning one or more mutexes for the duration of a scoped block.

When a scoped_lock object is created, it attempts to take ownership of the mutexes it is given. When control leaves the scope in which the scoped_lock object was created, the scoped_lock is destructed and the mutexes are released, in reverse order. If several mutexes are given, deadlock avoidance algorithm is used as if by std::lock.

The scoped_lock class is non-copyable.

Template parameters

MutexTypes - the types of the mutexes to lock. The types must meet the Lockable requirements unless sizeof...(MutexTypes)==1, in which case the only type must meet BasicLockable

Member types

Member type Definition
mutex_type Mutex

Member functions

constructs a scoped_lock, optionally locking the given mutexes
(public member function)
destructs the scoped_lock object, unlocks the underlying mutexes
(public member function)
not copy-assignable
(public member function)


#include <thread>
#include <mutex>
#include <iostream>
int g_i = 0;
std::mutex g_i_mutex;  // protects g_i
void safe_increment()
    std::scoped_lock lock{g_i_mutex};
    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);
    std::cout << __func__ << ": " << g_i << '\n';

Possible output:

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

See also

implements movable mutex ownership wrapper
(class template)
implements a strictly scope-based mutex ownership wrapper
(class template)