Namespaces
Variants
Views
Actions

std::scoped_lock

From cppreference.com
< 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.

Contents

[edit] 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

[edit] Member types

Member type Definition
mutex_type Mutex

[edit] Member functions

constructs a scoped_lock, optionally locking the given mutexes
(public member function) [edit]
destructs the scoped_lock object, unlocks the underlying mutexes
(public member function) [edit]
operator=
[deleted]
not copy-assignable
(public member function) [edit]

[edit] Example

#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};
    ++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

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