C++11并发与多线程【第八节】

第八节 condition_variable 、wait notify_one 、notify_all

一、条件变量std::condition_variable、wait、notify_one()

线程A：等待一个条件满足
线程B：专门往消息队列中放消息(数据)

#include<iostream>
#include<vector>
#include<thread>
#include<string>
#include<list>
#include<mutex>
#include <condition_variable>
using namespace std;

class A{
public:
    //把收到的消息(玩家命令)放入到一个队列的线程入口函数
    void inMsgRecvQueue(){
        for(int i=0;i<10000;i++){//用数字模拟玩家发送来的命令
            cout<<"inMsgRecvQueue()执行，插入一个元素 "<<i<<endl;
            //
            std::unique_lock<std::mutex> sbguard(my_mutex);
            msgRecvQueue.push_back(i);//把命令放入队列当中
            //
        }
    }

    bool MsgProcess(int &command){
        //双重锁定，双重检查，避免每一次都要锁了之后再判断
        if(!msgRecvQueue.empty()){
            std::unique_lock<std::mutex> sbguard(my_mutex);
            if(!msgRecvQueue.empty()){
                command=msgRecvQueue.front();//返回第一个元素
                msgRecvQueue.pop_front();//取出后移除该元素
                //然后处理数据
                return true;
            }
        }
        return false;
    }
    //从消息队列list中读取玩家命令的线程入口函数
    void outMsgRecvQueue(){
        int command=0;
        for(int i=0;i<10000;i++){
            //
            bool result=MsgProcess(command);
            if(result){
                cout<<"outMsgRecvQueue执行，取出一个元素 "<<command<<endl;
                //然后对数据进行处理
            }
            else
                cout<<"outMsgRecvQueue执行，但是list已经空了 ： "<<i<<endl;
        }
        cout<<"end "<<endl;
    }

private:
    std::list<int> msgRecvQueue;//在list中存放玩家发来的命令
    std::mutex my_mutex;
};

int main(){
    A myobj;
    std::thread myInMsgObj(&A::outMsgRecvQueue,&myobj);//第二个参数是引用，作用与std::ref相同，保证是子线程中使用的是主线程中的同一个对象，但是主线程后面必须等待子线程完成
    std::thread myOutMsgObj(&A::inMsgRecvQueue,&myobj);
    myInMsgObj.join();
    myOutMsgObj.join();

    cout<<"主线程结束"<<endl;
    return 0;
}

其中，每一次取数据都需要判断消息队列是否为空，效率低，能不能让队列不为空时自动通知我们来取数据？？

    bool MsgProcess(int &command){
        //双重锁定，双重检查，避免每一次都要锁了之后再判断
        if(!msgRecvQueue.empty()){
            std::unique_lock<std::mutex> sbguard(my_mutex);
            if(!msgRecvQueue.empty()){
                command=msgRecvQueue.front();//返回第一个元素
                msgRecvQueue.pop_front();//取出后移除该元素
                //然后处理数据
                return true;
            }
        }
        return false;
    }

1.1 使用条件变量std::condition_variable

std::condition_variable 实际上是一个与条件相关的类，说白了就是等待条件达成，需要与互斥量来配合工作。

class A{
public:
    //把收到的消息(玩家命令)放入到一个队列的线程入口函数
    void inMsgRecvQueue(){
        for(int i=0;i<10000;i++){//用数字模拟玩家发送来的命令
            cout<<"inMsgRecvQueue()执行，插入一个元素 "<<i<<endl;
            //
            std::unique_lock<std::mutex> sbguard(my_mutex);
            msgRecvQueue.push_back(i);//把命令放入队列当中
            //如果outMsgRecvQueue()取出数据线程正在处理一个事物，需要一段时间，而不是恰好卡在wait那等待唤醒，此时notify_one就没有效果
            my_cond.notify_one();//尝试唤醒wait()
            //
        }
    }

    //从消息队列list中读取玩家命令的线程入口函数
    void outMsgRecvQueue(){
        int command=0;
        while(true){
            std::unique_lock<std::mutex> sbguard(my_mutex);//在构造函数中给my_mutex上锁

            //wait()用来等一个信号，如果第二个参数(lambda表达式)返回值是false，那么wait()将解锁互斥量，并将本线程阻塞到本行，
            //阻塞直到某个其他线程调用notify_one()成员函数为止
            //如果wait第二个参数是true，wait()就直接返回
            //如果wait没有第二个参数，那么就和第二个参数返回false的效果相同
            //当其他线程用notify_one把本wait()唤醒，wait就开始恢复干活:
            //a)wait()不断尝试重新获取互斥锁，如果获取不到流程就继续阻塞到这等待获取，如果获取到了，加上锁就继续往下执行；
            //b.1)然后如果wait有第二个参数lambda，就判断这个lambda表达式，如果还是false，那么wait就又对互斥量解锁，然后又将本线程阻塞到本行，即回到第一个步骤
            //b.2)如果lambda表达式为true，则wait返回，程序往下执行,此时互斥量依然是被本线程锁着的
            //b.3)如果wait()没有第二个参数，则wait返回，程序往下执行，此时互斥量依然是被本线程锁着的
            my_cond.wait(sbguard,[this]{//lambda表达式,一个lambda表达式就是一个可调用对象(函数)
                if(!msgRecvQueue.empty())
                    return true;
                return false;
            });
            //程序如果能执行到这一步，互斥锁一定还是被本线程锁着的，消息队列中至少是有一条数据的
            command=msgRecvQueue.front();//返回第一个元素
            msgRecvQueue.pop_front();//取出后移除该元素
            sbguard.unlock();//由于unique_lock的灵活性，可以随时unlock解锁，以免锁住的时间太长
            cout<<"outMsg执行,取出一个元素"<<endl;
            //然后可以执行一些其他动作，如一些比较费时的操作
            //******
            //执行100毫秒
        }
        cout<<"end "<<endl;
    }

private:
    std::list<int> msgRecvQueue;//在list中存放玩家发来的命令
    std::mutex my_mutex;
    std::condition_variable my_cond;
};

int main(){
    A myobj;
    std::thread myInMsgObj(&A::outMsgRecvQueue,&myobj);//第二个参数是引用，作用与std::ref相同，保证是子线程中使用的是主线程中的同一个对象，但是主线程后面必须等待子线程完成
    std::thread myOutMsgObj(&A::inMsgRecvQueue,&myobj);
    myInMsgObj.join();
    myOutMsgObj.join();

    cout<<"主线程结束"<<endl;
    return 0;
}

其中；

my_cond.wait(sbguard,[this]{//lambda表达式,一个lambda表达式就是一个可调用对象(函数)
                if(!msgRecvQueue.empty())
                    return true;
                return false;
            });

**wait()**用来等一个信号，如果第二个参数(lambda表达式)返回值是false，那么wait()将解锁互斥量，并将本线程阻塞到本行；
阻塞直到某个其他线程调用notify_one()成员函数为止；
如果wait第二个参数是true，wait()就直接返回；
如果wait没有第二个参数，那么就和第二个参数返回false的效果相同；
当其他线程用notify_one把本wait()唤醒，wait就开始恢复干活:
a)wait()不断尝试重新获取互斥锁，如果获取不到流程就继续阻塞到这等待获取，如果获取到了，加上锁就继续往下执行；
b.1)然后如果wait有第二个参数lambda，就判断这个lambda表达式，如果还是false，那么wait就又对互斥量解锁，然后又将本线程阻塞到本行，即回到第一个步骤；
b.2)如果lambda表达式为true，则wait返回，程序往下执行,此时互斥量依然是被本线程锁着的；
b.3)如果wait()没有第二个参数，则wait返回，程序往下执行，此时互斥量依然是被本线程锁着的；

**注意：**如果outMsgRecvQueue()线程正在处理一个事物，需要一段时间，而不是恰好卡在wait那等待唤醒，此时notify_one就没有效果。

二、对上述代码思考

思考写入数据的线程如果在取出数据线程之前执行的情况。

三、notify_all()

notify_one()只能通知一个线程,多线程时唤醒哪一个线程是不确定的。
如果多个线程干的活不一样，但是都被卡在wait()，此时就需要全部唤醒在wait()那卡住的线程。
在上面的例子中，就算把notify_one换成notify_all其实效果是一样的，因为wait唤醒后，还需要得到互斥锁，但是一次只能有一个线程得到互斥锁，所以并不会冲突或发生错误，当然仅限于本案例。

思考：notify_all（）的应用场景