C++11 条件变量

　　C++11中的条件变量提供了用户等待的同步机制，在同步队列的应用中有很大的便利。

　　简单同步队列代码如下(SimpleSyncQueue.h):

#ifndef SIMPLESYNCQUEUE_H
#define SIMPLESYNCQUEUE_H

#include <thread>
#include <condition_variable>
#include <mutex>
#include <list>
#include <iostream>

using namespace std;

template<typename T>
class SimpleSyncQueue
{
public:
    SimpleSyncQueue()
    {

    }

    void Put(const T& x)
    {
        //调用Put函数的线程获取互斥量，如果互斥量正在被占用，将等待
        std::lock_guard<std::mutex> lk(m_mutex);

        //保存数据
        m_queue.push_back(x);

        //通知等待m_notEmpty的线程
        m_notEmpty.notify_one();
    }

    void Take(T& x)
    {
        //调用Take函数的线程获取互斥量，如果互斥量正在被占用，将等待
        std::unique_lock<std::mutex> locker(m_mutex);

        m_notEmpty.wait(locker,[this] {

            if(m_queue.empty())
            {
                cout<<"现在队列为空，请稍等"<<endl;
            }

            return !m_queue.empty();
        });

        x = m_queue.front();
        m_queue.pop_front();
    }

    bool Empty()
    {
        std::lock_guard<std::mutex> lk(m_mutex);

        return m_queue.empty();
    }

    size_t Size()
    {
        std::lock_guard<std::mutex> lk(m_mutex);

        return m_queue.size();
    }

private:
    std::list<T> m_queue;   /* 用于等待的同步变量 */
    std::mutex m_mutex;     /* 用于多线程同步的互斥量 */
    std::condition_variable m_notEmpty; /* 用于等待的同步变量 */
};



#endif // SIMPLESYNCQUEUE_H

　　测试代码如下：

#include <QCoreApplication>

#include "simplesyncqueue.h"

SimpleSyncQueue<int> testQueue;
bool threadrun = true;

void consumerthread()
{
    int get;

    while(threadrun)
    {
        testQueue.Take(get);

        cout<<"consumer thread get: "<<get<<endl;
    }

    cout<<"consumerthread exit"<<endl;
}

void producerthread()
{
    char in = 0;

    while(threadrun)
    {
        cin>>in;

        cout<<"user input: "<<in<<endl;

        switch(in)
        {
        case 'p':  testQueue.Put((int)100); break;
        case 'q':  threadrun = false; break;
        default:   break;
        }
    }

    cout<<"producerthread exit"<<endl;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    std::thread t1(consumerthread);

    std::thread t2(producerthread);
    t1.detach();

    t2.join();

    cout<<"program exit"<<endl;

    return a.exec();
}

　　测试结果如下：  
      

　　看看condition_variable类中的wait函数定义，参见http://en.cppreference.com/w/cpp/thread/condition_variable/wait

　　

　　关于这个函数，其实疑惑的是pred ()函数会被执行多少遍的问题。cppreference里的详解里给了一个 Equivalent to：

　 　　while (!pred()) {
    　　wait(lock);
　 　　}
 　　　从Equivalent To可以看到pred开始被执行一次。