概述

C++多线程编程中通常会对共享的数据进行写保护，以防止多线程在对共享数据成员进行读写时造成资源争抢导致程序出现未定义的行为。通常的做法是在修改共享数据成员的时候进行加锁–mutex。在使用锁的时候通常是在对共享数据进行修改之前进行lock操作，在写完之后再进行unlock操作，进场会出现由于疏忽导致由于lock之后在离开共享成员操作区域时忘记unlock，导致死锁。

互斥类的最重要成员函数是lock()和unlock()。在进入临界区时，执行lock()加锁操作，如果这时已经被其它线程锁住，则当前线程在此排队等待。退出临界区时，执行unlock()解锁操作。更好的办法是采用”资源分配时初始化”(RAII)方法来加锁、解锁，这避免了在临界区中因为抛出异常或return等操作导致没有解锁就退出的问题。极大地简化了程序员编写mutex相关的异常处理代码。C++11的标准库中提供了std::lock_guard类模板做mutex的RAII。

std::lock_guard类的构造函数禁用拷贝构造，且禁用移动构造。std::lock_guard类除了构造函数和析构函数外没有其它成员函数。

在std::lock_guard对象构造时，传入的mutex对象(即它所管理的mutex对象)会被当前线程锁住。在lock_guard对象被析构时，它所管理的mutex对象会自动解锁，不需要程序员手动调用lock和unlock对mutex进行上锁和解锁操作。lock_guard对象并不负责管理mutex对象的生命周期，lock_guard对象只是简化了mutex对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个lock_guard对象的生命周期内，它所管理的锁对象会一直保持上锁状态；而lock_guard的生命周期结束之后，它所管理的锁对象会被解锁。程序员可以非常方便地使用lock_guard，而不用担心异常安全问题。

std::lock_guard在构造时只被锁定一次，并且在销毁时解锁。

lock_guard介绍

std::lock_guard()是什么呢？它就像一个保姆，职责就是帮你管理互斥量，就好像小孩要玩玩具时候，保姆就帮忙把玩具找出来，孩子不玩了，保姆就把玩具收纳好。

其原理是：声明一个局部的std::lock_guard对象，在其构造函数中进行加锁，在其析构函数中进行解锁。最终的结果就是：创建即加锁，作用域结束自动解锁。从而使用std::lock_guard()就可以替代lock()与unlock()。

通过设定作用域，使得std::lock_guard在合适的地方被析构（在互斥量锁定到互斥量解锁之间的代码叫做临界区（需要互斥访问共享资源的那段代码称为临界区），临界区范围应该尽可能的小，即lock互斥量后应该尽早unlock），通过使用{}来调整作用域范围，可使得互斥量m在合适的地方被解锁：

#include <iostream>
#include <thread>

//实例化objLock对象，不要理解为定义变量
std::mutex objLock;
using namespace std;
// lock_guard:
// std::lock_guard()是什么呢？它就像一个保姆，职责就是帮你管理互斥量，
// 就好像小孩要玩玩具时候，保姆就帮忙把玩具找出来，孩子不玩了，保姆就把玩具收纳好。
// 其原理是：声明一个局部的std::lock_guard对象，在其构造函数中进行加锁，在其析构函数中进行解锁。
// 最终的结果就是：创建即加锁，作用域结束自动解锁。从而使用std::lock_guard()就可以替代lock()与unlock()。


// =================== 测试lock_guard的示例================================
/**
 * @brief 定义全局方法。用于打印ThreadId
 * @param id
 */
void printThreadId(int id) {
    try {
        // using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
        // 调用lock_guard的构造函数。传入的是mutex对象
        // 用此语句替换了m.lock()；lock_guard传入一个参数时，该参数为互斥量，此时调用了lock_guard的构造函数，申请锁定objLock
        {
            std::lock_guard<std::mutex> lck(objLock);
            cout << "======proc2函数正在改写a=======" << endl;
            cout << "原始id为" << id << endl;
            cout << "现在id为" << id + 1 << endl;
        }//通过使用{}来调整作用域范围，可使得m在合适的地方被解锁
        cout << "作用域外的内容3" << endl;
        cout << "作用域外的内容4" << endl;
        cout << "作用域外的内容5" << endl;
    } catch (std::logic_error &) {
        std::cout << "[exception caught]\n";
    }
}

/**
 * @brief  在std::lock_guard对象构造时，传入的mutex对象(即它所管理的mutex对象)会被当前线程锁住。
 *         在lock_guard对象被析构时，它所管理的mutex对象会自动解锁，不需要程序员手动调用lock和unlock对mutex进行上锁和解锁操作。
 *         lock_guard对象并不负责管理mutex对象的生命周期，lock_guard对象只是简化了mutex对象的上锁和解锁操作，
 *                方便线程对互斥量上锁，即在某个lock_guard对象的生命周期内，它所管理的锁对象会一直保持上锁状态；
 *                而lock_guard的生命周期结束之后，它所管理的锁对象会被解锁。程序员可以非常方便地使用lock_guard，而不用担心异常安全问题。
 *
 *                std::lock_guard在构造时只被锁定一次，并且在销毁时解锁。
 *          所以，我们一般在局部代码块里面进行构造初始化，然后局部代码块执行完毕之后会进行解锁
 * @return
 */
int main() {

    // 我们来学习一下测试Demo
    std::thread threads[100];
    for (int i = 0; i < 100; ++i) {
        // 数组的每个元素调用thread 的  构造函数
        threads[i] = std::thread(printThreadId, i + 1);
    }

    // 线程依次join是保证所有的线程执行完毕
    for (auto &th: threads) {
        th.join();
    }

    return 0;
}

std::lock_gurad也可以传入两个参数，第一个参数为adopt_lock标识时，表示构造函数中不再进行互斥量锁定，因此此时需要提前手动锁定。

unique_lock介绍

针对以上的问题，C++11中引入了std::unique_lock与std::lock_guard两种数据结构。通过对lock和unlock进行一次薄的封装，实现自动unlock的功能。

std::mutex mut;

void insert_data()
{
       std::lock_guard<std::mutex> lk(mut);
       queue.push_back(data);
}

void process_data()
{
       std::unqiue_lock<std::mutex> lk(mut);
       queue.pop();
}

std::unique_lock 与std::lock_guard都能实现自动加锁与解锁功能，但是std::unique_lock要比std::lock_guard更灵活，但是更灵活的代价是占用空间相对更大一点且相对更慢一点。

std::lock_guard其功能是在对象构造时将mutex加锁，析构时对mutex解锁，这样一个栈对象保证了在异常情形下mutex可以在lock_guard对象析构被解锁，lock_guard拥有mutex的所有权。

1
2
3

explicit lock_guard (mutex_type& m);//必须要传递一个mutex作为构造参数
lock_guard (mutex_type& m, adopt_lock_t tag);//tag=adopt_lock表示mutex已经在之前被上锁，这里lock_guard将拥有mutex的所有权
lock_guard (const lock_guard&) = delete;//不允许copy constructor

来看一个与std::lock_guard功能相似但功能更加灵活的管理mutex的对象 std::unique_lock，unique_lock内部持有mutex的状态：locked,unlocked。unique_lock比lock_guard占用空间和速度慢一些，因为其要维护mutex的状态。

unique_lock() noexcept;    //1、可以构造一个空的unique_lock对象，此时并不拥有任何mutex

explicit unique_lock (mutex_type& m);//2、 拥有mutex，并调用mutex.lock()对其上锁

unique_lock (mutex_type& m, try_to_lock_t tag);//3、tag=try_lock表示调用mutex.try_lock()尝试加锁

unique_lock (mutex_type& m, defer_lock_t tag) noexcept;//4、tag=defer_lock表示不对mutex加锁，只管理mutex，此时mutex应该是没有加锁的

unique_lock (mutex_type& m, adopt_lock_t tag);//5、tag=adopt_lock表示mutex在此之前已经被上锁，此时unique_locl管理mutex

template <class Rep, class Period>
unique_lock (mutex_type& m, const chrono::duration<Rep,Period>& rel_time);//6、在一段时间rel_time内尝试对mutex加锁,mutex.try_lock_for(rel_time)

template <class Clock, class Duration>
unique_lock (mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time);//7、mutex.try_lock_until(abs_time)直到abs_time尝试加锁

unique_lock (const unique_lock&) = delete;//8、禁止拷贝构造

unique_lock (unique_lock&& x);//9、获得x管理的mutex，此后x不再和mutex相关，x此后相当于一个默认构造的unique_lock,移动构造函数，具备移动语义,movable but not copyable

unique_lock 在使用上比lock_guard更具有弹性，和 lock_guard 相比，unique_lock 主要的特色在于：
unique_lock 不一定要拥有 mutex，所以可以透过 default constructor 建立出一个空的 unique_lock。
unique_lock 虽然一样不可复制（non-copyable），但是它是可以转移的（movable）。所以，unique_lock 不但可以被函数回传，也可以放到 STL 的 container 里。
另外，unique_lock 也有提供 lock()、unlock() 等函数，可以用来加锁解锁mutex，也算是功能比较完整的地方。
unique_lock本身还可以用于std::lock参数，因为其具备lock、unlock、try_lock成员函数,这些函数不仅完成针对mutex的操作还要更新mutex的状态。

unique_lock其它成员函数

~unique_lock();//若unique_lock对象拥有管理的mutex的所有权，mutex没有被销毁或者unlock,那么将执行mutex::unlock()解锁，并不销毁mutex对象。
mutex_type* mutex() const noexcept;//返回unique_lock管理的mutex指针，但是unique_lock不会放弃对mutex的管理，若unique_lock对mutex上锁了，其有义务对mutex解锁
bool owns_lock() const noexcept;//当mutex被unique_lock上锁，且mutex没有解锁或析构，返回真，否则返回false
explicit operator bool() const noexcept;//同上

std::unique_lock增加了灵活性，比如可以对mutex的管理从一个scope通过move语义转到另一个scope，不像lock_guard只能在一个scope中生存。同时也增加了管理的难度，因此如无必要还是用lock_guard。