C++多线程 Lesson 3 笔记：互斥量和锁
报名了Udacity（优达学城）的 C++ Nanodegree 课程，其中关于C++相关高级内容比如内存管理，多线程是其比较吸引我的地方，也正是自己想要提高的方面。由于这两部分的课程中的文字资料相比视频来说多了很多很多，而且全英文读起来很累，于是打算在这里边学边通过自己的理解记下一些笔记，以便日后查阅，同时与其他有需要的人分享。
这一篇对应于 Lesson 3: Mutexes and Locks
（C++多线程的部分总共有4个Lessons，有时间会逐步更新后面的内容）
1.1. 使用互斥量(mutex)保护共享数据
- mutex对象
到目前为止，我们介绍过的在线程之间传递数据的方法是短期的，涉及将参数（通过Promise）从主线程传递到子线程，即工作线程，然后一旦可以就绪的话，将结果传递回主线程（通过Future）。 因此，Promise-Future的通讯方式是一种一次性使用的，非永久性的通信通道。我们之前还看到，为了避免数据竞争（Data races）的发生，我们需要放弃访问共享数据，或者在不改变数据的情况下将其用于只读访问。在本章中，我们想研究一种能够建立稳定长期交流渠道的方法，该渠道既可以共享数据也可以对数据进行修改。理想情况下，我们希望有一个类似于无线电语音通信相对应的通信协议，其中，发射器可以使用一种表达式（比如“over”）来提示接收器表示传输过程的结束。通过使用这样的通讯协议，发送方和接收方可以轮流发送数据。在C++中，这种“轮流”的概念可以由一个称为“mutex（互斥量）”的实体构建，mutex是MUtual EXclusion（互斥现象）的缩写。
数据竞争（Data races）需要相关的数据被同时从两个线程访问，但如果我们可以保证一次只有一个线程可以访问特定的内存位置，则就不会发生数据竞争。因此，我们想设法建立一个通信协议。这里需要注意的是，mutex本身并不是解决数据竞争问题的方法，而它仅仅是一个线程之间安全通信协议的启动器，其必须由程序员实现并遵守。
具体关于这个协议的工作原理：假设我们有一块内存（比如存储了一个共享变量），并且想要防止其被其他的对象同时访问。因此，我们可以指定一个互斥锁mutex作为该特定内存的守护者。需要注意的是，互斥锁会被受限于它所要保护的内存。比如在下图中，如果线程1想要访问受保护的内存，1必须首先“锁定（lock）”这个mutex。在线程1“拥有了mutex的lock（under the lock）”之后，线程2将被阻止访问这里的共享变量，它也无法“lock“这个mutex，且被系统临时挂起。
一旦线程1对共享变量的读取或写入操作完成，它必须“解锁（unlock）”这个互斥锁，以便线程2在之后可以访问该内存位置。通常，把“在锁下（under the lock）”的被执行的代码部分称为“关键部分（critical section）”。另外需要注意的是，对共享内存的只读访问也必须锁定mutex以防止数据竞争的发生，特别是当另一个当时处于“在锁下（under the lock）”状态的线程正在修改数据。
当有多个线程试图同时获取并锁定mutex时，只有其中的一个线程会成功，而所有其他的线程将自动被搁置，就像汽车在十字路口等待绿灯一样。当之前成功执行了锁定的线程完成其工作并解锁mutex后，另一个正在排队等待访问的线程会被唤醒，并允许它现在锁定这个mutex以继续进行自己的读/写操作。因此，如果所有线程都遵循该协议，则将有效避免数据竞争的发生。 - 一个共享数据的例子
下面的这段代码基于我们在之前看到过的一些类。从代码一开始，首先，有一个Vehicle类，它具有单个数据成员_id。之后，还定义了一个WaitingVehicles的类，它看上去要用来将Vehicle的对象存储在其内部的向量中。这里，我们使用右值参考来作为pushback()函数的参数，用来将车辆移入向量中。另外还要注意，普通的push_back()函数在此处已注释掉，因为我们试图引发一个不会让程序崩溃的数据竞争（之后还会讲解）。最后，辅助成员_tmpVehicles的存在用于计算通过调用pushback()函数添加的Vehicle数量，它尤其将帮助我们在不使程序崩溃的情况下展现该程序中数据竞争的效果。
在main()主函数中，一个for循环用于启动大量Task（通过使用std::async()而得到的Task，而非标准的Thread，具体内容见上一篇文章)，所有Task都试图将新创建的Vehicle添加到队列中。如果首先我们将启动选项更改为std::launch::deferred的话，程序会在控制台上生成以下输出：
正如预期的那样，每个Task将一个Vehicle对象插入vector，车辆总数在打印输出时为1000。如果我们现在试图强制执行并发的行为，即将启动选项更改回std::launch::async，在打印输出时将会在每次执行后看到不同的结果（车辆的总数）。关于为什么会产生这样的结果，请注意，在线程函数pushback()中，有一个sleep_for的调用，该调用会暂停线程的执行一小段时间。这便是在这个例子中发生数据竞争的地方。
首先，_tmpVehicles的当前值存储在一个临时变量oldNum中。线程暂停时，其他的线程可能对_tmpVehicles进行更改。当该线程恢复执行时，_tmpVehicles的先前值将被写回oldNum+1，从而导致在暂停的这段时间内所有执行过的其他线程对_tmpVehicles的修改是无效的。有趣的是，当注释sleep_for时，程序的输出与std::launch::deferred相同，至少在大多数情况下，运行程序时是如此，但不排除有时可能会有一个调度的异常会导致该错误被暴露出来。最后，通过这个例子除了了解数据竞争外，建议在开发时的测试/调试阶段故意地引入类似的时间延迟，以便可以暴露潜在的并发错误。
#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <algorithm>
class Vehicle
{
public:
Vehicle(int id) : _id(id) {}
private:
int _id;
};
class WaitingVehicles
{
public:
WaitingVehicles() : _tmpVehicles(0) {}
// getters / setters
void printSize()
{
std::cout << "#vehicles = " << _tmpVehicles << std::endl;
}
// typical behaviour methods
void pushBack(Vehicle &&v)
{
//_vehicles.push_back(std::move(v)); // data race would cause an exception
int oldNum = _tmpVehicles;
std::this_thread::sleep_for(std::chrono::microseconds(1)); // wait deliberately to expose the data race
_tmpVehicles = oldNum + 1;
}
private:
std::vector<Vehicle> _vehicles; // list of all vehicles waiting to enter this intersection
int _tmpVehicles;
};
int main()
{
std::shared_ptr<WaitingVehicles> queue(new WaitingVehicles);
std::vector<std::future<void>> futures;
for (int i = 0; i < 1000; ++i)
{
Vehicle v(i);
futures.emplace_back(std::async(std::launch::async, &WaitingVehicles::pushBack, queue, std::move(v)));
}
std::for_each(futures.begin(), futures.end(), [](std::future<void> &ftr) {
ftr.wait();
});
queue->printSize();
return 0;
}
- 使用mutex以保护数据
使用mutex包括四个简单的步骤：1. 包含mutex的头文件，2. 创建一个std::mutex对象，3. 在调用读/写权限之前，使用lock()函数锁定mutex，4. 读/写操作完成后，使用unlock()函数解锁mutex。
为了保护上一个例子中的_vehicles变量不被多个线程访问进行读写操作，我们将一个mutex变量作为私有数据成员添加到Vehicle的类中。在pushback()函数中，mutex变量将在新vehicle对象添加到vector之前被锁定，并在相关操作完成后被解锁。另外，mutex也被添加在了函数printSize()中。锁定该函数的原因有两个：首先，我们要防止发生对vector的读写入访问时发生的数据争用。其次，我们希望将标准输出保留给控制台，以打印vector的大小。
在指定位置添加了mutex之后，程序的打印输出就会变为正常（车辆的总数=1000）。
#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <mutex>
#include <algorithm>
class Vehicle
{
public:
Vehicle(int id) : _id(id) {}
private:
int _id;
};
class WaitingVehicles
{
public:
WaitingVehicles() {}
// getters / setters
void printSize()
{
_mutex.lock();
std::cout << "#vehicles = " << _vehicles.size() << std::endl;
_mutex.unlock();
}
// typical behaviour methods
void pushBack(Vehicle &&v)
{
_mutex.lock();
_vehicles.emplace_back(std::move(v)); // data race would cause an exception
_mutex.unlock();
}
private:
std::vector<Vehicle> _vehicles; // list of all vehicles waiting to enter this intersection
std::mutex _mutex;
};
int main()
{
std::shared_ptr<WaitingVehicles> queue(new WaitingVehicles);
std::vector<std::future<void>> futures;
for (int i = 0; i < 1000; ++i)
{
Vehicle v(i);
futures.emplace_back(std::async(std::launch::async, &WaitingVehicles::pushBack, queue, std::move(v)));
}
std::for_each(futures.begin(), futures.end(), [](std::future<void> &ftr) {
ftr.wait();
});
queue->printSize();
return 0;
}
- 其他的mutex
下面将简要介绍几种不同的可用mutex类型：- mutex：提供核心放的功能lock()和unlock()。另外，提供无阻塞的try_lock()函数，如果mutex不可用，则有返回值。
- recursive_mutex：允许从同一线程多次获取mutex。
- timed_mutex：类似于mutex，但是它带有另外两个函数try_lock_for()和try_lock_until()，它们尝试在一段时间内或直到到达某个时刻之前获取互斥锁。
- recursive_timed_mutex：是timed_mutex和recursive_mutex的组合。
- timed_mutex的使用
在下面的一段代码中，我们使用了timed_mutex改编了上一个示例中的代码。其中，在pushBack()函数中，我们使用了try_lock_for()函数而不是lock()函数，该函数将相应执行到最大的尝试次数（3次）为止。如果一次尝试lock()失败，会在控制台上会打印一条错误消息，其中包含相应的车辆ID。然后，线程将休眠一段时间，再进行下一次try_lock_for()尝试。
#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <mutex>
#include<algorithm>
class Vehicle
{
public:
Vehicle(int id) : _id(id) {}
int getID() { return _id; }
private:
int _id;
};
class WaitingVehicles
{
public:
WaitingVehicles() {}
// getters / setters
void printSize()
{
_mutex.lock();
std::cout << "#vehicles = " << _vehicles.size() << std::endl;
_mutex.unlock();
}
// typical behaviour methods
void pushBack(Vehicle &&v)
{
for (size_t i = 0; i < 3; ++i)
{
if (_mutex.try_lock_for(std::chrono::milliseconds(100)))
{
_vehicles.emplace_back(std::move(v));
//std::this_thread::sleep_for(std::chrono::milliseconds(10));
_mutex.unlock();
break;
}
else
{
std::cout << "Error! Vehicle #" << v.getID() << " could not be added to the vector" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
}
private:
std::vector<Vehicle> _vehicles; // list of all vehicles waiting to enter this intersection
std::timed_mutex _mutex;
};
int main()
{
std::shared_ptr<WaitingVehicles> queue(new WaitingVehicles);
std::vector<std::future<void>> futures;
for (int i = 0; i < 1000; ++i)
{
Vehicle v(i);
futures.emplace_back(std::async(std::launch::async, &WaitingVehicles::pushBack, queue, std::move(v)));
}
std::for_each(futures.begin(), futures.end(), [](std::future<void> &ftr) {
ftr.wait();
});
queue->printSize();
return 0;
}
- 死锁类型1
如上例所示，使用mutex可以大大降低数据竞争所带来的风险。但是我们可以想象一下，如果在关键部分（即在锁定和解锁之间）执行代码时抛出异常会发生什么情况。在这种情况下，mutex将会无限期地保持锁定状态，并且没有其他线程可以对其进行解锁，程序因此很可能会冻结。
下面的例子展示了死锁的一个情形。我们在divideByNumber()函数前后上了锁并再解锁，这样可以有效的防止数据竞争的发生。然而，当某个线程执行该函数并抛出异常后，由于直接进行了返回而不能继续执行unlock()函数，在编译运行程序时，程序会卡住而不能继续运行。
相反的，如果我们在这段代码中删除这个mutex以及相应的lock()和unlock()指令后，程序将会不可避免的发生数据竞争。这种情况下，在控制台输出的打印信息将会是混乱无序的，即便这种情况下程序没有发生死锁可以正常地结束（这种情况下，多个线程可能同时执行打印输出函数而导致发生混乱）。
#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <mutex>
#include<algorithm>
std::mutex mtx;
double result;
void printResult(int denom)
{
std::cout << "for denom = " << denom << ", the result is " << result << std::endl;
}
void divideByNumber(double num, double denom)
{
mtx.lock();
try
{
// divide num by denom but throw an exception if division by zero is attempted
if (denom != 0)
{
result = num / denom;
std::this_thread::sleep_for(std::chrono::milliseconds(1));
printResult(denom);
}
else
{
throw std::invalid_argument("Exception from thread: Division by zero!");
}
}
catch (const std::invalid_argument &e)
{
// notify the user about the exception and return
std::cout << e.what() << std::endl;
return;
}
mtx.unlock();
}
int main()
{
// create a number of threads which execute the function "divideByNumber" with varying parameters
std::vector<std::future<void>> futures;
for (double i = -5; i <= +5; ++i)
{
futures.emplace_back(std::async(std::launch::async, divideByNumber, 50.0, i));
}
// wait for the results
std::for_each(futures.begin(), futures.end(), [](std::future<void> &ftr) {
ftr.wait();
});
return 0;
}
- 死锁类型2
第二种死锁的状态是有两个或更多线程被阻塞，由于每个线程在释放另一个线程的资源之前都在等待另一个线程的资源被释放。这样下来，这种死锁造成的结果是程序完全停滞，相应的线程，或者通常整个程序都将被永远阻塞。以下给出的第一段代码展示了这个问题，编译执行后，程序将永远不会到达输出“Finished“的语句并在主函数main()中return 0。在上面的程序中，线程函数ThreadA()和ThreadB()都需要访问控制台以执行各自的打印输出的语句。不幸的是，他们请求的这个资源由两个mutex以不同的顺序保护。因此，如果两个线程进行相应指定的上锁流程，即首先ThreadA锁住mutex2，然后ThreadB锁住mutex1，则程序会处于死锁（Deadlock）状态：因为，每个线程都试图接下来锁定另外一个mutex，但这需要等待其被另外的线程释放，而这永远不会发生。下面的插图以图形的方式解释了该死锁问题。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex1, mutex2;
void ThreadB()
{
// Creates deadlock problem
mutex2.lock();
std::cout << "Thread B" << std::endl;
mutex1.lock();
mutex2.unlock();
mutex1.unlock();
}
void ThreadA()
{
// Creates deadlock problem
mutex1.lock();
std::cout << "Thread A" << std::endl;
mutex2.lock();
mutex1.unlock();
mutex2.unlock();
}
void ExecuteThreads()
{
std::thread t1( ThreadA );
std::thread t2( ThreadB );
t1.join();
t2.join();
std::cout << "Finished" << std::endl;
}
int main()
{
ExecuteThreads();
return 0;
}
- 解决上面的死锁类型2
避免上面的代码出现的死锁的一种方法是对所有资源进行编号，并要求进程仅按严格增加（或减少）的顺序请求资源。比如，在下面的一段代码中，我们在修改了上锁和解锁mutex1，mutex2的顺序后，程序将可以正常编译并执行，不会发生死锁。可以预见，通过这种方法避免这种死锁类型是可能的，但需要时间和大量经验。在下一节中，我们将继续探讨避免上述两种死锁的方法。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex1, mutex2;
void ThreadB()
{
// Solves deadlock problem
mutex1.lock();
std::cout << "Thread B" << std::endl;
mutex2.lock();
mutex1.unlock();
mutex2.unlock();
}
void ThreadA()
{
// Solves deadlock problem
mutex1.lock();
std::cout << "Thread A" << std::endl;
mutex2.lock();
mutex2.unlock();
mutex1.unlock();
}
void ExecuteThreads()
{
std::thread t1( ThreadA );
std::thread t2( ThreadB );
t1.join();
t2.join();
std::cout << "Finished" << std::endl;
}
int main()
{
ExecuteThreads();
return 0;
}
1.2. 使用特别的锁(locks)防止死锁
- Lock Guard
在前面一节的示例中，我们使用过了mutex附带的lock()和unlock()函数。 随之而来特别重要的一个概念“在锁下工作（working under the lock）”的主要想法便是阻止其他线程对同一资源进行同时的访问。因此，获得执行lock()的线程在结束对数据的操作后可以继续解锁mutex，这将为所有其余线程提供继续获得lock()的机会。但是在实际中，由于死锁的可能性（见上一节内容），我们应该避免直接调用lock()函数。
对此，我们可以通过创建std::lock_guard对象来避免此问题，该对象可以在其整个对象生命周期中都将链接的mutex对象保持锁定的状态：锁是在执行对象的构造函数时获取的，并在执行对象的析构函数时自动释放。这样的一种设计可以保证不会发生忘记解锁而导致死锁的情况。另外，std::lock_guard保证了异常安全，因为在引发异常时，任何关键部分（critical section）都将被自动解锁。对比之前的代码示例，我们现在可以使用以下包含std::lock_guard的代码来实现对关键部分的上锁lock()和解锁unlock()操作。从下面给出的第一段代码可以看出，我们不再需要显示地调用lock()或unlock()的操作。现在有一个std::lock_guard对象被生成，该对象将mutex作为参数并在创建时执行上锁操作。最后，当divideByNumber()函数返回时，一旦std::lock_guard对象被销毁（这是由于局部变量std::lock_guard对象超出作用范围），自动的解锁操作便会执行。因此程序的打印输出将是有序的，并且不会发生之前出现过的死锁现象。
最后，我们可以通过将mutex的范围限制在更小，特别是访问关键资源的部分，以进一步优化此代码（即，使用被注释掉的std::lock_guard对象代码，以代替try之前的std::lock_guard对象代码）。
#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <mutex>
#include<algorithm>
std::mutex mtx;
double result;
void printResult(int denom)
{
std::cout << "for denom = " << denom << ", the result is " << result << std::endl;
}
void divideByNumber(double num, double denom)
{
std::lock_guard<std::mutex> lck(mtx);
try
{
// divide num by denom but throw an exception if division by zero is attempted
if (denom != 0)
{
//std::lock_guard<std::mutex> lck(mtx);
result = num / denom;
std::this_thread::sleep_for(std::chrono::milliseconds(1));
printResult(denom);
}
else
{
throw std::invalid_argument("Exception from thread: Division by zero!");
}
}
catch (const std::invalid_argument &e)
{
// notify the user about the exception and return
std::cout << e.what() << std::endl;
return;
}
}
int main()
{
// create a number of threads which execute the function "divideByNumber" with varying parameters
std::vector<std::future<void>> futures;
for (double i = -5; i <= +5; ++i)
{
futures.emplace_back(std::async(std::launch::async, divideByNumber, 50.0, i));
}
// wait for the results
std::for_each(futures.begin(), futures.end(), [](std::future<void> &ftr) {
ftr.wait();
});
return 0;
}
- Unique lock
Lock guard的问题在于，我们只能将互斥锁锁定一次，即控制锁定和解锁的唯一方法是使std::lock_guard对象生效（生成std::lock_guard对象）和变为无效（局部变量std::lock_guard超出范围）。但是，如果我们想要（或需要）对锁定机制进行更好的控制，应该怎么办？
lock_guard一种更加灵活的替代是unique_lock。此外，它还支持更高级的机制，比如延迟锁定，时间锁定，递归锁定，转移锁的所有权和条件变量的使用等等（将在后面讨论）。unique_lock的行为类似于lock_guard，但是它提供了更大的灵活性，尤其是在锁定机制的时间行为方面。
在下面给出的示例代码中，之前的std::lock_guard被替换为std::unique_lock对象。和之前一样，生成的std::unique_lock对象lck将在其析构函数中解锁互斥锁，即当divideByNumber()函数返回（局部变量lck超出范围时）。除了这种自动的解锁之外，std::unique_lock还提供了额外的灵活性，比如可以通过手动调用方法lock()和unlock()来根据编程者的实际需要适当释放或再次锁住共享的资源。该功能可以极大地提高并发程序的性能，尤其是当许多线程正在等待访问锁定资源的时侯。在代码中，我们在执行一些非关键性工作（由sleep_for模拟）之前释放了该锁，并在关键部分工作重新开始之前再次锁住了该互斥锁，因此在divideByNumber()函数的结束前处于锁定状态之下。这个例子想说明，当在两次访问关键资源之间的代码需要花费大量的时间执行时，临时的解锁使其他线程对该资源的访问成为了可能-这对于优化程序的性能和运算时间特别有帮助。
#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <mutex>
#include<algorithm>
std::mutex mtx;
double result;
void printResult(int denom)
{
std::cout << "for denom = " << denom << ", the result is " << result << std::endl;
}
void divideByNumber(double num, double denom)
{
std::unique_lock<std::mutex> lck(mtx);
try
{
// divide num by denom but throw an exception if division by zero is attempted
if (denom != 0)
{
result = num / denom;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
printResult(denom);
lck.unlock();
// do something outside of the lock
std::this_thread::sleep_for(std::chrono::milliseconds(100));
lck.lock();
// do someting else under the lock
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
else
{
throw std::invalid_argument("Exception from thread: Division by zero!");
}
}
catch (const std::invalid_argument &e)
{
// notify the user about the exception and return
std::cout << e.what() << std::endl;
return;
}
}
int main()
{
// create a number of threads which execute the function "divideByNumber" with varying parameters
std::vector<std::future<void>> futures;
for (double i = -5; i <= +5; ++i)
{
futures.emplace_back(std::async(std::launch::async, divideByNumber, 50.0, i));
}
// wait for the results
std::for_each(futures.begin(), futures.end(), [](std::future<void> &ftr) {
ftr.wait();
});
return 0;
}
- Unique lock的一些优点
尽管std::unique_lock和std::lock_guard优于直接使用mutex进行上锁和解锁，但是需要注意，即便使用了它们，因为不当访问两个互斥锁而导致死锁的情况仍然有可能发生（死锁类型2），比如见下面给出的代码。
不过，我们在这里还想要简要列举了一些使用std::unique_lock以替代std::lock_guard所带来的优点。- 可以使用默认构造函数构造没有相关联mutex的实例
- 可以使用关联的mutex构造实例，同时首先使用延迟锁定的构造函数使mutex处于解锁的状态
- 可以构造一个尝试锁定mutex的实例，但是如果使用try-lock构造函数导致上锁失败，则将其解锁
- 可以构造一个实例，尝试在指定时间段内或直到指定时间点获取锁
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex1, mutex2;
void ThreadA()
{
// Creates deadlock problem
std::lock_guard<std::mutex> lock2(mutex2);
std::cout << "Thread A" << std::endl;
std::lock_guard<std::mutex> lock1(mutex1);
}
void ThreadB()
{
// Creates deadlock problem
std::lock_guard<std::mutex> lock1(mutex1);
std::cout << "Thread B" << std::endl;
std::lock_guard<std::mutex> lock2(mutex2);
}
void ExecuteThreads()
{
std::thread t1( ThreadA );
std::thread t2( ThreadB );
t1.join();
t2.join();
std::cout << "Finished" << std::endl;
}
int main()
{
ExecuteThreads();
return 0;
}
- 使用std::lock()来避免死锁
在大多数情况下，代码一次只能在一个mutex上持有一个锁。有时我们可以嵌套锁，比如通过调用使用一个mutex保护一个子程序，同时在另一个mutex上保有锁，但通常尽可能避免同时锁定多个mutex。然而有时，我们需要对一个以上的mutex持有锁，这是因为我们需要对多个不同的数据元素执行操作，其中每个数据元素均受其自己的mutex所保护。
在之前的内容中我们看到，当需要一次使用两个mutex并且没有很好地管理好锁定这两个mutex的顺序时，可能会导致死锁。为了避免此问题，我们必须告知系统这两个mutex应该被同时锁定，以避免潜在的死锁现象。这正是std::lock()函数的作用-我们需要提供一些lock_guard或unique_lock的对象，系统通过该函数可以确保它们在函数返回时都被锁定。
在下面的经过优化的无死锁代码中，std::lock()函数用于确保mutex对象始终以相同的顺序被锁定，而不管其中参数的顺序如何。另外注意，std::adopt_lock选项允许我们在已经被锁定的mutex上使用std::lock_guard。根据经验，编程者应该尽量避免一次使用多个mutex对象。实践表明，这一点在大多数情况下都可以实现。对于其余的情况，使用std::lock()函数是避免死锁情况的一种安全方法。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutex1, mutex2;
void ThreadA()
{
// Ensure that locks are always executed in the same order
std::lock(mutex1, mutex2);
std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);
std::cout << "Thread A" << std::endl;
std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
}
void ThreadB()
{
std::lock(mutex1, mutex2);
std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
std::cout << "Thread B" << std::endl;
std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);
}
void ExecuteThreads()
{
std::thread t1( ThreadA );
std::thread t2( ThreadB );
t1.join();
t2.join();
std::cout << "Finished" << std::endl;
}
int main()
{
ExecuteThreads();
return 0;
}
本篇内容完结。。。
6812
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
