五、互斥量概念、用法、死锁

一、互斥量mutex

保护共享数据，操作时，用代码把共享数据锁住，操作数据，解锁。其他线程要操作共享数据的线程必须等待解锁，锁住，操作，解锁。

互斥量就是类对象，一个锁，多个线程用lock()成员函数加锁这个锁头，只有一个线程能锁成功，成功的标志是lock函数返回，如果没有锁成功，那么流程就卡在lock()这里，不断的尝试去锁这个锁头。

互斥量使用要小心，保护数据多了，影响效率，保护少了，没达到保护效果。

二、互斥量用法

1、lock()、unlock()

include <mutex>

先lock，操作共享数据，再unlock。

使用规则：成对使用，有lock必须有unlock；

#include <iostream>
#include <thread> //线程
#include <vector>
#include <list>
#include <mutex>
/*
网络游戏服务器
创建两个线程，一个线程收集玩家命令（用一个数字代表玩家命令），并把命令数据写到一个队列中；
另一个线程从队列中取出玩家发送来的命令，解析，然后执行玩家需要的动作。
list：频繁顺序插入和删除数据时效率高；
vector：频繁随机插入和删除数据时效率高；
准备使用成员函数来作为线程函数
*/
using namespace std;
class A{
public:
    //把收到的消息（玩家命令）让入到一个队列中的线程函数
    void InMsgQue(){
        for(int i=0;i<100;i++){
            cout<<"InMsgQue执行，插入一个元素"<<i<<endl;
            my_mutex.lock();
            MyQue.push_back(i);//假设i就是命令
            my_mutex.unlock();
        }

    }
    bool outMsgLULProc(int &command){//这样的目的是为了方便后序对command的操作
        my_mutex.lock();
        if(!MyQue.empty()){
            int command = MyQue.front();
            MyQue.pop_front();
            my_mutex.unlock();//这个unlock特别容易被忘记写
            return true;
        }
        my_mutex.unlock();
        return false;
    }
    //把数据从消息队列中取出来的线程函数
    void OutMsgQue(){
        int command=0;
        for(int i=0;i<100;i++){
            bool result = outMsgLULProc(command);
            if(result){
                //消息不空
                cout<<"OutMsgQue正在执行，取出一个元素"<<command<<endl;
                //接下来就考虑处理这个取出来的数据command.........
            }
            else{
                cout << "OutMsgQue执行，但是消息队列为空"<<i << endl;
            }

        }
        cout<<"end"<<endl;
    }

private:
    list<int> MyQue;
    std::mutex my_mutex;//创建一个互斥量
};

int main(){
    A myobj;
    std::thread myout(&A::OutMsgQue,&myobj);
    std::thread myin(&A::InMsgQue,&myobj);//必须市引用，才能保证线程用的是同一个对象
    myout.join();
    myin.join();
    cout<<"main end"<<endl;
    return 0;
}

2、std::lock_guard类模板

为了防止忘记unlock，引入lock_guard，类似于智能指针，他会帮你unlock。

bool outMsgLULProc(int &command){
       std::lock_guard<std::mutex> guardd(my_mutex);
        if(!MyQue.empty()){
            int command = MyQue.front();
            MyQue.pop_front();
            return true;
        }
        return false;
    }

lock_guard构造函数执行了lock；析构函数执行了unlock。

只有return的时候才unlock，没有分开使用lock和unlock灵活。

可以用大括号提前结束guard：

    void InMsgQue(){
        for(int i=0;i<100;i++){
            cout<<"InMsgQue执行，插入一个元素"<<i<<endl;
            {
                std::lock_guard<std::mutex> sbguard(my_mutex);
                MyQue.push_back(i);//假设i就是命令
            }//大括号结束，lock_guard析构函数执行
            //其他处理代码、、、、、、、
        }

    }

三、死锁

1、演示

举例：张三在北京等李四，不挪窝；李四在深圳等张三，不挪窝。

c++中：

死锁问题是有至少两个锁头也就是两个互斥量才会产生。

有两个锁：金锁，银锁

线程：A 和 B

线程A先锁金锁，金锁锁成功，然后去lock银锁。。。

线程B先锁银锁，银锁还没被锁的话，锁银锁成功了，然后去lock金锁。。。但是金锁被A锁了。。。

A拿不到银锁，金锁解不开，B去拿金锁，但是金锁被A锁了，所以银锁解不开。

这时就发生死锁了。AB两个线程就干等着直到永远~~

2、解决方案

只要保证两个互斥量的lock顺序一致，就不会发生死锁。

3、std::lock()函数模板

用来处理多个互斥量。

可以一次锁住两个或多个互斥量。

它不存在由于多个线程中因为锁的顺序问题导致的死锁。

如果一个锁没锁住，他就会马上解锁之前所有锁上的互斥量，然后在那儿等着，等所有的互斥量都能够锁住，它才能往下走。

要么都锁住，要么都没有锁住。

    void InMsgQue(){
        for(int i=0;i<100;i++){
            cout<<"InMsgQue执行，插入一个元素"<<i<<endl;
            std::lock(my_mutex1,my_mutex2);//相当于两个互斥量都调用了lock
            MyQue.push_back(i);//假设i就是命令
            my_mutex1.unlock();
            my_mutex2.unlock();
            //其他处理代码、、、、、、、
        }

    }

容易忘记unlock

4、std::lock_guard的std::adopt_lock参数

使用lock模板，还是容易忘记unlock，那么可是使用lock_guard的adopt_lock参数：

    void InMsgQue(){
        for(int i=0;i<100;i++){
            cout<<"InMsgQue执行，插入一个元素"<<i<<endl;
　　　　　　　　 std::lock(my_mutex1,my_mutex2);
            std::lock_guard<std::mutex> sbguard(my_mutex1,std::adopt_lock);
            std::lock_guard<std::mutex> sbguard2(my_mutex2,std::adopt_lock);
            MyQue.push_back(i);//假设i就是命令
            //其他处理代码、、、、、、、
        }
    }

这个参数就是起一个标记作用，就是如果互斥量已经被lock了，那就不会再调用lock_guard的构造函数了，就只剩析构函数了