std::scoped_lock - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

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

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

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

### [edit] Example

| This section is incomplete Reason: should show multiple mutexes

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::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

unique_lock (C++11) | implements movable mutex ownership wrapper (class template) [edit]

lock_guard (C++11) | implements a strictly scope-based mutex ownership wrapper (class template) [edit]

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

- Todo with reason