互斥量(std::mutex)是多线程间同时访问某一共享变量时，保证变量可被安全访问的手段。
引用 cppreference 的介绍：
| 1 |
|
锁住的代码少，这个粒度叫细，执行效率高。
锁住的代码多，这个粒度叫粗，执行效率低。
使用方法：
1：直接操作 mutex，即直接调用 mutex 的 lock/unlock 函数
try_lock() 函数是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
2：使用 lock_guard 自动加锁、解锁。
lock_guard是一个互斥量包装程序，它提供了一种方便的RAII（Resource acquisition is initialization ）风格的机制来在作用域块的持续时间内拥有一个互斥量。
创建lock_guard对象时，它将尝试获取提供给它的互斥锁的所有权。当控制流离开lock_guard对象的作用域时，lock_guard析构并释放互斥量。
特点如下：
- 创建即加锁，作用域结束自动析构并解锁，无需手工解锁
- 不能中途解锁，必须等作用域结束才解锁
- 不能复制
3：使用 unique_lock 自动加锁、解锁。
unique_lock是一个通用的互斥量锁定包装器，它允许延迟锁定，限时深度锁定，递归锁定，锁定所有权的转移以及与条件变量一起使用。
简单地讲，unique_lock 是 lock_guard 的升级加强版，它具有 lock_guard 的所有功能，同时又具有其他很多方法，使用起来更强灵活方便，能够应对更复杂的锁定需要。
特点如下：
- 创建时可以不锁定（通过指定第二个参数为std::defer_lock），而在需要时再锁定
- 可以随时加锁解锁
- 作用域规则同 lock_grard，析构时自动释放锁
- 不可复制，可移动
- 条件变量需要该类型的锁作为参数（此时必须使用unique_lock）
注意：
mutex::scoped_lock其实就是unique_lock<mutex>的typedef。
总结：
所有 lock_guard 能够做到的事情，都可以使用 unique_lock 做到，反之则不然。
那么何时使用lock_guard呢？很简单，
需要使用锁的时候，首先考虑使用 lock_guard
它简单、明了、易读。如果用它完全ok，就不要考虑其他了。
如果现实不允许，就让实力派 unique_lock 出马吧！
死锁：
两个线程A、B
(a) 线程A执行的时候，这个线程先把a锁lock()成功，然后去锁b锁。线程A拿不到b锁就停在这里一直加锁
出现上下文切换
(b) 线程B执行的时候，这个线程先把b锁lock()成功，然后去锁a锁。线程B拿不到a锁就停在这里一直加锁
这时死锁就产生了。
死锁的解决方案：两个互斥量的调用顺序必须保持一致
在多线程编程中，还有另一种十分常见的行为：线程同步。线程同步是指线程间需要按照预定的先后次序顺序进行的行为。C++11对这种行为也提供了有力的支持，这就是条件变量。条件变量位于头文件condition_variable下。
条件变量提供了两类操作：wait和notify。这两类操作构成了多线程同步的基础。
（1） wait(lock): 调用时即阻塞线程，并且调用lock.unlock()
（2） wait(lock, conditions): 调用时检查conditions，如果为false,则阻塞线程，并且调用lock.unlock(), 否则，继续执行
（3） wait_for(lock, time_duration, conditions): 调用时，检查条件是否满足:(1) conditions返回true; (2) 时间超时，如果不满足(1)(2)中的一个条件，则阻塞线程，并调用lock.unlock(), 否则，到达一定等待时间或满足条件被唤醒 ，注意，等待超过时间段后自动唤醒，判断条件一般需要使用者自己在合适的时候判断，并通过notify_one()或notify_all()唤醒，所以，使用的时候注意判断返回值，即状态是否为std::cv_status::timeout
（4） wait_until(lock, time_point, conditions): 实际wait_for是通过wait_until实现，实际上也是一样的，到达指定时间点或满足条件conditions时被唤醒，注意，到达时间点是自动唤醒，判断条件一般需要使用者自己在合适的时候判断，并通过notify_one()或notify_all()唤醒，所以，使用的时候注意判断返回值，即状态是否为std::cv_status::timeout
示例程序
条件变量和std::mutex合用，这是为了线程间通信。
#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;
void worker_thread()
{
// Wait until main() sends data
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return ready;}); // 一开始，ready为false，此处会释放lock，然后在cv上阻塞等待，直到main线程通过cv.notify_xxx来唤醒当前线程，cv被唤醒后会再次对lock进行上锁，然后wait函数才会返回。wait返回后可以安全的使用mutex保护的临界区内的数据，此时mutex仍为上锁状态，故后面还需要手动释放锁
// std::mutex mutex_;
// std::condition_variable cv_;
// std::unique_lock<std::mutex> lk(mutex_);
// cv_.wait(lk, [this] {return a_.b;});
// after the wait, we own the lock.
std::cout << "Worker thread is processing data\n";
data += " after processing";
// Send data back to main()
processed = true;
std::cout << "Worker thread signals data processing completed\n";
// Manual unlocking is done before notifying, to avoid waking up
// the waiting thread only to block again (see notify_one for details)
lk.unlock();
cv.notify_one();
}
int main()
{
std::thread worker(worker_thread);
data = "Example data";
// send data to the worker thread
{
std::lock_guard<std::mutex> lk(m);
ready = true;
std::cout << "main() signals data ready for processing\n";
}
cv.notify_one();
// wait for the worker
{
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return processed;});
}
std::cout << "Back in main(), data = " << data << '\n';
worker.join();
}输出
main() signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in main(), data = Example data after processing最后，总结一下条件变量的几个关键点：
1. wait()函数的内部实现是：先释放了互斥量的锁，然后阻塞以等待条件为真；
2. notify系列函数需在unlock之后再被调用；
3. 套路是：
a. A线程拿住锁，然后wait,此时已经释放锁，只是阻塞了在等待条件为真；
b. B线程拿住锁，做一些业务处理，然后令条件为真，释放锁，再调用notify函数；
c. A线程被唤醒，接着运行。
参考：