std::lock
From cppreference.com
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.
Contents |
[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
(C++11)
|
attempts to obtain ownership of mutexes via repeated calls to try_lock (function template) |