C++ 生产者消费者

当前C++11已经实现了多线程、互斥量、条件变量等异步处理函数，并且提供了诸如sleep之类的时间函数，所以后面使用C++开发这一块的时候完全可以实现跨平台，无需在windows下写一套然后又在linux下写一套了。

   本文用C++11实现了一个简单的生产者-消费者模式，生产者每1S将一个数值放到双向队列中，消费者每2S从双向队列中取出数据。

#ifndef SEMAPHORE_H
#define SEMAPHORE_H
#include <iostream>
#include <mutex>
#include <deque>
#include <thread>
#include <vector>
#include <condition_variable>
using namespace std;

class semaphore{
    public:
        semaphore(){
            _data.clear();
            count = 0;
        }
        void start(int product_num,int consume_num){
             vector<thread> threads;
             threads.clear();
             for(int index = 0;index < product_num;index++){
                threads.push_back(std::thread(&semaphore::product_thread,this));
             }
             for(int index = product_num;index < product_num + consume_num;index++){
                threads.push_back(std::thread(&semaphore::consume_thread,this));
             }

             for(auto& t:threads){
                t.detach();
             }
        }
    private:
        void product_thread(){
                while(true){
                    {
                        unique_lock<mutex> lck(_mutex);
                        if(_data.size() > 10){
                            cv.wait(lck);
                        }else{
                            cout<<"current product thread:"<<this_thread::get_id()<<" product "<<count<<endl;
                            count++;
                            count = count%10;
                            _data.push_back(count);
                            cv.notify_all();
                        }
                    }
                    chrono::milliseconds dura(1000);
			        this_thread::sleep_for(dura);
                }
        }        
        void consume_thread(){
                while(true){
                    {
                        unique_lock<mutex> lck(_mutex);
                        if(_data.empty()){
                            cv.wait(lck);
                        }else{
                            cout<<"current consume thread:"<<this_thread::get_id()<<" consume "<<_data.front()<<endl;
                            _data.pop_front();
                        }
                    }
                    chrono::milliseconds dura(2000);
                    this_thread::sleep_for(dura);
                }
        }
    private:
        int count;
        deque<int> _data;
        mutex _mutex;
        condition_variable cv; 
};
#endif  //SEMPHORE_H

转载：https://blog.csdn.net/dailongjian2008/article/details/53184706

代码下载：https://github.com/NearLife/WhatYouThinking.git