五、互斥量

互斥量：

　　是个类对象，理解成一把锁，多个线程尝试用lock()来加锁这把锁头时，只有一个线程能锁定成功。（成功的标志是lock()函数返回），如果没锁成功，那么流程卡在lock()这里不断尝试去锁这把锁头（也就是每被调用寄存器一次，都会去申请锁）。

　　慎用lock()保护共享数据不多也不少，少了达不到效果，多了影响效率；

lock()与unlock()要成对使用

　　每调用一次lock()必然要调用一次unlock()，不能调用次数不一致，否则会导致代码不稳定甚至崩溃。

#include <thread>
#include <iostream>
#include <list>
#include <mutex>
using namespace std;
 
class A {
public:
    void inMsgRecvQueue() {
        for (int i = 0; i < 10000; ++i) {
            cout << "inMsgRecvQueue插入一个元素" << i << endl;
            mymutex.lock();
            msgRecvQueue.push_back(i);
            mymutex.unlock();
        }
    }
 
    bool outMsgProc(int &command) {
        mymutex.lock();
        if (!msgRecvQueue.empty()) {
            int command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            mymutex.unlock();  //两个代码分支最后都要解锁，否则会出现未解锁情况
            return true;
        }
        mymutex.unlock();  //两个代码分支最后都要解锁，否则会出现未解锁情况
        return false;
    }
 
    void outMsgRecvQueue() {
        int command = 0;
        for (int i = 0; i < 10000; ++i) {
            bool re = outMsgProc(command);
            if (re == true) {
                cout << "outMsgRecvQueue执行，取出一个元素" << command << endl;
            }
            else {
                cout << "消息队列为空" << endl;
            }
        }
    }
 
private:
    std::list<int> msgRecvQueue;
    std::mutex mymutex;
};
 
 
 
int main() {
    A myobja;
    std::thread myoutobj(&A::outMsgRecvQueue, &myobja); 
    std::thread myinobj(&A::inMsgRecvQueue, &myobja);
    myinobj.join();
    myoutobj.join();
}

std::lock_guard的类模板

你忘记了unlock，系统替你unlock()；

std::lock_guard类模板：直接取代lock()和unlock()：也就是说用了lock_guard之后，再不能用lock()和unlock()了；

#include <thread>
#include <iostream>
#include <list>
#include <mutex>
using namespace std;
 
class A {
public:
    void inMsgRecvQueue() {
        for (int i = 0; i < 10000; ++i) {
            cout << "inMsgRecvQueue插入一个元素" << i << endl;
            //mymutex.lock();
                        {
                            std::lock_guard<std::mutex> sbguard(mymutex); //sbguard名称随意
                msgRecvQueue.push_back(i);
                        }
            //mymutex.unlock();
        }
    }
 
    bool outMsgProc(int &command) {
        std::lock_guard<std::mutex> sbguard(mymutex); //sbguard名称随意
        //lock_guard构造函数里执行了mutex::lock()
        //lock_guard析构函数里执行了mutex::unlock()
 
        //mymutex.lock();
        if (!msgRecvQueue.empty()) {
            int command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            //mymutex.unlock();
            return true;
        }
        //mymutex.unlock();
        return false;
    }
 
    void outMsgRecvQueue() {
        int command = 0;
        for (int i = 0; i < 10000; ++i) {
            bool re = outMsgProc(command);
            if (re == true) {
                cout << "outMsgRecvQueue执行，取出一个元素" << command << endl;
            }
            else {
                cout << "消息队列为空" << endl;
            }
        }
    }
 
private:
    std::list<int> msgRecvQueue;
    std::mutex mymutex;
};
 
int main() {
    A myobja;
    std::thread myoutobj(&A::outMsgRecvQueue, &myobja); 
    std::thread myinobj(&A::inMsgRecvQueue, &myobja);
    myinobj.join();
    myoutobj.join();
}

lock_guard相对还是没有lock()/unlock()灵活。

死锁

两个线程A,B，两把锁sa，sb

1、线程A执行的时候，这个线程先锁sa锁，把sa锁 lock()成功了，然后它去lock sb锁，还未成功时，出现了上下文切换。

2、线程B开始执行，这个线程先锁 sb锁，因为 sb锁 还没有被锁，所以 sb锁 会lock()成功，线程B要去锁 sa锁

3、此时死锁就产生了，线程A因为拿不到 sb锁 流程就走不下去（sa锁 就解不开）

4、线程B因为拿不到 sa锁 流程也走不下去（sb锁 就解不开）

死锁演示：

#include <thread>
#include <iostream>
#include <list>
#include <mutex>
using namespace std;
 
class A {
public:
    void inMsgRecvQueue() {
        for (int i = 0; i < 10000; ++i) {
            cout << "inMsgRecvQueue插入一个元素" << i << endl;
            mymutex1.lock();
            //...其他操作
            mymutex2.lock();
            msgRecvQueue.push_back(i);
            mymutex2.unlock();
            //...其他操作
            mymutex1.unlock();
        }
    }
 
    bool outMsgProc(int &command) {
        mymutex2.lock();
        mymutex1.lock();
        if (!msgRecvQueue.empty()) {
            int command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            mymutex1.unlock();
            mymutex2.unlock();
            return true;
        }
        mymutex1.unlock();
        mymutex2.unlock();
        return false;
    }
 
    void outMsgRecvQueue() {
        int command = 0;
        for (int i = 0; i < 10000; ++i) {
            bool re = outMsgProc(command);
            if (re == true) {
                cout << "outMsgRecvQueue执行，取出一个元素" << command << endl;
            }
            else {
                cout << "消息队列为空" << endl;
            }
        }
    }
 
private:
    std::list<int> msgRecvQueue;
    std::mutex mymutex1;
    std::mutex mymutex2;
};
 
int main() {
    A myobja;
    std::thread myoutobj(&A::outMsgRecvQueue, &myobja); //注意这里myobja用引用，才能保证线程里用的是同一个对象
    std::thread myinobj(&A::inMsgRecvQueue, &myobja);
    myinobj.join();
    myoutobj.join();
}

运行结果：卡住不动了。

死锁的一般解决方法：只要保证两个互斥量的调用顺序保持一致。

std::lock()模板

上面的lock时是std::mutex.lock()。

能力：一次锁住两个或以上互斥量（至少两个，多了不限），如果互斥量中有一个没锁住，它就在那里等着，直到所有互斥量都锁住，它才继续执行。

它不存在，因为在多个线程中，因为锁头的lock的顺序问题导致的死锁风险问题（若没锁住全部，它会将锁住的锁释放掉）；

因此：要么两个互斥量都锁住，要么都没锁住。

std::lock_guard的std::adopt_lock参数

#include <thread>
#include <iostream>
#include <list>
#include <mutex>
using namespace std;
 
class A {
public:
    void inMsgRecvQueue() {
        for (int i = 0; i < 10000; ++i) {
            cout << "inMsgRecvQueue插入一个元素" << i << endl;
            std::lock(mymutex1, mymutex2);
            std::lock_guard<std::mutex> sbguard1(mymutex1, std::adopt_lock);
            std::lock_guard<std::mutex> sbguard2(mymutex2, std::adopt_lock);
            msgRecvQueue.push_back(i);
            //mymutex2.unlock();
            //...其他操作
            //mymutex1.unlock();
        }
    }
 
    bool outMsgProc(int &command) {
        std::lock(mymutex1, mymutex2);
        std::lock_guard<std::mutex> sbguard1(mymutex1, std::adopt_lock);
        std::lock_guard<std::mutex> sbguard2(mymutex2, std::adopt_lock);
        if (!msgRecvQueue.empty()) {
            command = msgRecvQueue.front();
            msgRecvQueue.pop_front();
            //mymutex1.unlock();
            //mymutex2.unlock();
            return true;
        }
        //mymutex1.unlock();
        //mymutex2.unlock();
        return false;
    }
 
    void outMsgRecvQueue() {
        int command = 0;
        for (int i = 0; i < 10000; ++i) {
            bool re = outMsgProc(command);
            if (re == true) {
                cout << "outMsgRecvQueue执行，取出一个元素" << command << endl;
            }
            else {
                cout << "消息队列为空" << endl;
            }
        }
    }
 
private:
    std::list<int> msgRecvQueue;
    std::mutex mymutex1;
    std::mutex mymutex2;
};
 
int main() {
    A myobja;
    std::thread myoutobj(&A::outMsgRecvQueue, &myobja); //注意这里myobja用引用，才能保证线程里用的是同一个对象
    std::thread myinobj(&A::inMsgRecvQueue, &myobja);
    myinobj.join();
    myoutobj.join();
}

std::adopt_lock是一个结构体对象，起标记作用，就是表示这个互斥量已经lock()，不需要在std::lock_guard<std::mutex>里面对对象再次进行lock了

总结：

std::lock()：一次性锁定多个互斥量，配合

std::lock_guard<std::mutex> sbguard1(mymutex1, std::adopt_lock);

实现不用在意加锁顺序与释放锁，但也可以手动unlock以实现细粒度锁。

std::lock() 谨慎使用（建议一个一个锁）；