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

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

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

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

### See also

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

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

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

- Todo with reason