c/c++ notify/wait 消息机制

相关头文件和函数

#include <condition_variable>

#include <mutex>

std::condition_variable()

std::wait()

std::notify_one()

std::notify_all()

#include<iostream>
#include<thread>
#include<vector>
#include<list>
#include<mutex>
 
using namespace std;
 
class A
{
public:
    //把收到的消息，入到一个队列中
    void inMsgRecvQueue()
    {
        int i;
        for (i = 0; i < 100000; ++i)
        {
 
            cout << "push_back num = " << i << endl;
            //lock之后只能有一个线程可以对msgQueue队列做操作
            unique_lock<mutex> my_unique_lock(my_mutex);
            msgQueue.push_back(i);                   //数字i就是玩家的命令。
            cond.notify_one();        //如果相应线程再阻塞，则将wait的线程唤醒。如果没有阻塞，则没有作用。
        }
    }
 
    //把数据从消息队列中取出
    void outMsgRecvQueue()
    {
        int command = 0;
 
        while (true)
        {
            std::unique_lock<mutex> sbguard1(my_mutex);
            //用来判断第二个参数的条件，如果返回值是false，那么wait将解锁互斥量，并阻塞到本行。
            //直到其他线程调用notify_one或者notify_all唤醒此线程为止。如果wait不写第二个参数，默认第二个参数返回false。
            //如果第二个参数返回true，则继续往下执行。
            //阻塞后被别人唤醒后，wait就会不断的尝试重新获得互斥量锁。拿到锁后，再去判断第二个参数条件。
            //如果阻塞后被唤醒没有第二个参数的情况下，这个时候第二个参数默认是true。
            //这种方式可以减少资源消耗，不用一直判断队列是否为空。
            cond.wait(sbguard1, [this] {
                if (!msgQueue.empty())
                {
                    return true;
                }
                else
                {
                    return false;
                }
                });
 
            command = msgQueue.front();
            msgQueue.pop_front();
            sbguard1.unlock();
 
            cout << "command = " << command << endl;
        }
    }
 
private:
    list<int> msgQueue;
    mutex my_mutex;       //创建一个互斥量
    std::condition_variable cond;
};
 
int main()
{
    A myobj;
    thread myOutMsg(&A::outMsgRecvQueue, std::ref(myobj));   //保证线程中用的同一个对象
    thread myInMsg(&A::inMsgRecvQueue, std::ref(myobj));
 
    myOutMsg.join();
    myInMsg.join();
 
    cout << "main thread end..." << endl;
    return 0;
}