std::lock - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::lock

From cppreference.com
< cpp‎ | thread

Defined in header `<mutex>` |  |
template< class Lockable1, class Lockable2, class LockableN... > void lock( Lockable1& lock1, Lockable2& lock2, LockableN& lockn... ); |  | (since C++11)

Locks the given `Lockable` objects `lock1`, `lock2`, `...`, `lockn` using a deadlock avoidance algorithm to avoid deadlock.

The objects are locked by an unspecified series of calls to `lock`, `try_lock`, `unlock`. If a call to `lock` or `unlock` results in an exception, `unlock` is called for any locked objects before rethrowing.

### [edit] Parameters

lock1, lock2, ... , lockn | - | the `Lockable` objects to lock

### [edit] Return value

(none)

### [edit] Notes

Boost provides a version of this function that takes a sequence of `Lockable` objects defined by a pair of iterators.

### [edit] Example

The following example uses `std::lock` to lock pairs of mutexes without deadlock.

Run this code

    #include <mutex>
    #include <thread>
    #include <iostream>
    #include <vector>
    #include <functional>
    #include <chrono>

    struct Employee {
        Employee(int id) : id(id) {}
        int id;
        std::vector<int> lunch_partners;
        std::mutex m;
    };

    void send_mail(Employee &e1, Employee &e2)
    {
        // simulate a time-consuming messaging operation
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    void assign_lunch_partner(Employee &e1, Employee &e2)
    {
        // use std::lock to acquire two locks without worrying about
        // other calls to assign_lunch_partner deadlocking us
        std::lock(e1.m, e2.m);

        e1.lunch_partners.push_back(e2.id);
        e2.lunch_partners.push_back(e1.id);

        e1.m.unlock();
        e2.m.unlock();

        send_mail(e1, e2);
        send_mail(e2, e1);
    }

    int main()
    {
        Employee alice(0), bob(1), christina(2), dave(3);

        // assign in parallel threads because mailing users about lunch assignments
        // takes a long time
        std::vector<std::thread> threads;
        threads.emplace_back(assign_lunch_partner, std::ref(alice), std::ref(bob));
        threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(bob));
        threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(alice));
        threads.emplace_back(assign_lunch_partner, std::ref(dave), std::ref(bob));

        for (auto &thread : threads) thread.join();
    }

### [edit] See also

try_lock (C++11) | attempts to obtain ownership of mutexes via repeated calls to `try_lock` (function template) [edit]

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