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 = ;

     while(threadrun)
     {
         cin>>in;

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

         switch(in)
         {
         case 'p':  testQueue.Put((int)); 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开始被执行一次。