一个生产者和一个消费者的生产消费模型

Makefile

ConProd:ConProd.cc
	gcc -o ConProd ConProd.cc -std=c++11 -lstdc++ -pthread

.PHONY:clean
clean:
	rm -f ConProd

BlockQueue.hpp

#pragma once

#include <iostream>
#include <queue>
#include <mutex>
#include <pthread.h>

const int gDefaultCap=5;

template<class T>
class BlockQueue
{
public:
    bool isQueueEmpty()
    {
        return _bq.size()==0;
    }

    bool isQueueFull()
    {
        return _bq.size()==_capacity;
    }

    BlockQueue(int capacity=gDefaultCap):_capacity(capacity)
    {
        pthread_mutex_init(&_mtx,nullptr);
        pthread_cond_init(&_Empty,nullptr);
        pthread_cond_init(&_Full,nullptr);

    }
    void push(const T &in)
    {
        pthread_mutex_lock(&_mtx);
        while(isQueueFull()) pthread_cond_wait(&_Full,&_mtx);
        //访问临界资源，100%确定，资源是就绪的
        _bq.push(in);
        if(_bq.size() >= _capacity/2)   pthread_cond_signal(&_Empty);
        pthread_mutex_unlock(&_mtx);

    }

    void pop(T* out)
    {
        pthread_mutex_lock(&_mtx);
        while(isQueueEmpty())pthread_cond_wait(&_Empty,&_mtx);
        *out=_bq.front();
        _bq.pop();
        pthread_mutex_unlock(&_mtx);
        pthread_cond_signal(&_Full);
    }

    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mtx);
        pthread_cond_destroy(&_Empty);
        pthread_cond_destroy(&_Full);

    }
private:
    std::queue<T> _bq;//阻塞队列
    int _capacity;//容量上限
    pthread_mutex_t _mtx;//通过互斥锁保证队列安全
    pthread_cond_t _Empty; //用它来表示bq 是否空的条件
    pthread_cond_t _Full;  //用它来表示bq 是否满的条件
};

ConProd.cc

#include "BlockQueue.hpp"
#include <unistd.h>
#include "Task.hpp"

void* consumer(void* args)
{
    BlockQueue<int>* bqueue=(BlockQueue<int>*)args;
    while(true)
    {
        int a;
        bqueue->pop(&a);
        std::cout<< "消费一个数据" << a <<std::endl;
        sleep(1);
    }
    return nullptr;
}

int func(int a,int b)
{
    return a+b;
}

void* productor(void* args)
{
    BlockQueue<int>* bqueue=(BlockQueue<int>*)args;
    while(true)
    {
        int a=10;
        while(true)
        {
            bqueue->push(a);
            std::cout << "生产一个数据" <<a<<std::endl;
            a++;
        }
    }
    return nullptr;
}

int main()
{
    BlockQueue<Task>* bqueue = new BlockQueue<Task>();
    pthread_t c,p;
    pthread_create(&c,nullptr,consumer,bqueue);
    pthread_create(&p,nullptr,productor,bqueue);

    pthread_join(c,nullptr);
    pthread_join(p,nullptr);

    delete bqueue;

}