生产者消费者模型c++版本

mutex.h

#ifndef _MUTEX_H_#define _MUTEX_H_#include<pthread.h>#include"condition.h"class Mutex { public:  friend class Condition;  Mutex() {    pthread_mutex_init(&pthread_mutex_, NULL); }  ~Mutex() {    pthread_mutex_destroy(&pthread_mutex_); }    int Lock();  int Unlock();  private:  pthread_mutex_t pthread_mutex_;};#endif

mutex.cpp

#include"mutex.h"inline int Mutex::Lock() {  return pthread_mutex_lock(&pthread_mutex_);}inline int Mutex::Unlock() {  return pthread_mutex_unlock(&pthread_mutex_);}

condition.h

#ifndef _CONDITION_H_#define _CONDITION_H_#include <stdint.h>#include<pthread.h>#include"mutex.h"class Mutex;class Condition { public:  Condition(){}  Condition(Mutex* mutex){    pthread_cond_init(&condition_, NULL);    is_signaled_ = 0;    mutex_= mutex;  }  ~Condition(){    pthread_cond_destroy(&condition_);  }     void Wait(Mutex* mutex);  void Signal();  void BroadCast();    protected:  pthread_cond_t condition_;  int32_t is_signaled_;    private:  Mutex* mutex_;};#endif   

condition.cpp

#include"condition.h"inline void Condition::Wait(Mutex* mutex) {  pthread_cond_wait(&condition_, &mutex_->pthread_mutex_);}inline void Condition::Signal(){ pthread_cond_signal(&condition_); }inline void Condition::BroadCast() { pthread_cond_broadcast(&condition_);}

queue.h

#ifndef _QUEUE_H_#define _QUEUE_H_#include<iostream>#include<pthread.h>#include"mutex.h"#include"condition.h"#include"mutex.cpp"#include"condition.cpp"class Mutex;class Condition;using namespace std;template <class T>class Queue { public:   Queue() {}  Queue(int size , Mutex* m , Condition* c) {    buff = new T[size];    front_ = 0;    tail_ = 0;    number_ = 0;    MaxSize_ = size;    queue_mutex_ = m;    queue_cond_=c;  }  ~Queue() {    delete buff;  }    void Enqueue(T& item) {   queue_mutex_->Lock();   while(number_ == MaxSize_) {  //   cout<<"queue is full "<<endl;     queue_cond_->Wait(queue_mutex_);   }   buff[tail_] = item;   ++tail_;   ++number_;   cout<< "producer thread: "<<pthread_self();   cout<<"     enqueue......"<<item<<endl;   queue_mutex_->Unlock();   queue_cond_->Signal();   }  void Dequeue() {    queue_mutex_->Lock();    while(number_ == 0){//      cout<<"queue is empty  "<<endl;      queue_cond_->Wait(queue_mutex_);     }   T value = buff[front_];   ++front_;   --number_;   cout<< "consumer thread: "<<pthread_self();   cout<<"      dequeue......"<<value<<endl;   queue_mutex_->Unlock();   queue_cond_->Signal();  }  bool IsEmpty(){    if(number_ == 0)      return true;    else      return false;  }  bool IsFull(){    if(number_ == MaxSize_)      return true;    else      return false;  }  int Size(bool real) {    return number_;}  private:  int front_;  int tail_;  int number_;  T* buff;  int MaxSize_;  Mutex* queue_mutex_;  Condition* queue_cond_;};   #endif   

threadbase.h

#ifndef _THREADBASE_H_#define _THREADBASE_H_#include<pthread.h>template<class T>class ThreadBase { public:  ThreadBase() {}     int Start(pthread_t pthread , const pthread_attr_t* attr = NULL) {    return pthread_create(&pthread, attr , &ThreadBase::DoStart , (void*)this);  }  static  void* DoStart(void* param) {    ThreadBase* obj = (ThreadBase*)param;obj->Run();return NULL;  }   virtual  void Run() {}    private:  pthread_t thread_;};#endif

thread.h

#ifndef _THREAD_H_#define _THREAD_H_#include<iostream>#include"threadbase.h"#include"queue.h"#include <unistd.h>using namespace std;template<class T> class Queue;template<class T> class Thread;template<class T>class Thread : public ThreadBase<T> { public:  Thread(){}  Thread(Queue<T>* queue ,int flag ,T item ) {    queue_ = queue;    flag_= flag;    item_=item;  }      void Run() {    if(flag_ == 1)      while(1){        sleep(1);    queue_->Enqueue(item_);      }    else      while(1){        sleep(1);    queue_->Dequeue();      }   } private:    Queue<T>* queue_;  int flag_;  T item_;};#endif

producerconsumer.h

#ifndef _PRODUCER_H_#define _PRODUCER_H_#include"queue.h"#include"thread.h"#include"mutex.h"#include"condition.h"#include<iostream>#include<unistd.h>#include<pthread.h>using namespace std;template<class T>class ProducerConsumer { public:  ProducerConsumer(int buff_size ,int producer_number , int consumer_number){    number_producer_= producer_number;    number_consumer_= consumer_number;    mutex_= new Mutex;    cond_= new Condition(mutex_);    queue_= new Queue<T>(buff_size , mutex_ ,cond_);    p1 = new pthread_t[number_producer_];    p2 = new pthread_t[number_consumer_];  }  void Produce(T& item){    Thread<T>* thread1[number_producer_];    for(int i =0 ;i < number_producer_ ;++i){      thread1[i]=new Thread<T>(queue_ ,1 ,item);      thread1[i]->Start(p1[i]);}  }  void Consume() {    Thread<T>* thread2[number_consumer_];    for(int i =0 ;i < number_consumer_ ;++i){      thread2[i]= new Thread<T>(queue_ ,2 ,arg);      thread2[i]->Start(p2[i]);    }  }   /*  void join(){    for(int i =0 ;i < number_producer_ ;++i)      pthread_join(p1[i] ,NULL);    for(int i =0 ;i < number_consumer_ ;++i)       pthread_join(p2[i] ,NULL);  }*/ private:  T arg;  int number_producer_;  int number_consumer_;    Mutex* mutex_;  Condition* cond_;  Queue<T>* queue_;  pthread_t* p1;  pthread_t* p2;  };#endif

main.cpp

#include"producerconsumer.h"#include<pthread.h>#include <unistd.h>#include<string>#include<stdlib.h>int main() {  string item ="apple";  ///缓冲区大小设为150，3个生产者，3个消费者  ProducerConsumer<string>* procon = new ProducerConsumer<string>(150 ,3, 3);  procon->Produce(item);  procon->Consume();  sleep(10000);    return 0;}