生产者消费者问题———pthread实现

#include<iostream>
#include<pthread.h>
#include<ctime>
#include <unistd.h>
#include<queue>
#include<semaphore.h>
using namespace std;
pthread_mutex_t mutexs;
pthread_mutex_t print;
pthread_mutex_t all;
pthread_cond_t full=PTHREAD_COND_INITIALIZER;
pthread_cond_t empty=PTHREAD_COND_INITIALIZER;
int k;
typedef struct item_st{
    int product_id;
    time_t produce_time;
    int producer_id;
}ITEM;
typedef struct buffer_st{
    bool isempty=true;
    ITEM item;
    int len=0;
    buffer_st * nextbuf= nullptr;
}BUFFER;
BUFFER product;
int allproductid=1;
int allcustomer=0;
int maxn=4;
void *customer(void *arg){
    while(true){
        int *customer_id=(int *)arg;

        pthread_mutex_lock(&mutexs);
        pthread_mutex_lock(&print);
        cout<<"消费者"<<*customer_id<<"准备进入临界区"<<endl;
        pthread_mutex_unlock(&print);
        if(allcustomer>=k){
            cout<<"结束！！！！"<<endl;
            pthread_mutex_unlock(&mutexs);
            pthread_exit(NULL);
        }
        while(product.len==0){
            pthread_cond_signal(&empty);
            pthread_cond_wait(&full,&mutexs);
        }
        pthread_mutex_lock(&print);
        cout<<"消费者"<<*customer_id<<"已经进入临界区"<<endl;
        pthread_mutex_unlock(&print);
        allcustomer+=1;
        BUFFER* temp=&product;
        for(int i=1;i<product.len;i++){
            temp=temp->nextbuf;
        }
        pthread_mutex_lock(&print);
        cout<<"消费者"<<*customer_id<<"取出产品id为"<<temp->item.product_id<<endl;
        pthread_mutex_unlock(&print);
        int cur=temp->item.product_id;
        pthread_mutex_lock(&print);
        cout<<"该产品是生产者"<<temp->item.producer_id<<"于"<<ctime(&temp->item.produce_time)<<"生产"<<endl;
        pthread_mutex_unlock(&print);
        temp= nullptr;
        product.len--;

        pthread_mutex_lock(&print);
        cout<<"-----------此时缓冲区内有如下----------"<<endl;
        cout<<"生产时间\t\t\t"<<"生产者\t"<<"产品id"<<endl;
        BUFFER *list=&product;
        for(int i=0;i<product.len;i++){
            cout<<ctime(&(list->item.produce_time))<<"\t"<<list->item.producer_id<<"\t"<<list->item.product_id<<endl;
            if(i<product.len-1)
            list=list->nextbuf;
        }
        pthread_mutex_unlock(&print);
        pthread_mutex_lock(&print);

        cout<<"--------------------------"<<endl;
        cout<<"消费者"<<*customer_id<<"已经离开临界区"<<endl;
        pthread_mutex_unlock(&print);
        pthread_mutex_unlock(&mutexs);
        pthread_cond_signal(&empty);


        int during=rand()%5+1;
        pthread_mutex_lock(&print);
        cout<<"消费者"<<*customer_id<<"开始消费"<<cur<<endl;
        pthread_mutex_unlock(&print);
        sleep(during);
        time_t t;
        time(&t);
        pthread_mutex_lock(&print);
        cout<<"消费者"<<*customer_id<<"于"<<ctime(&t)<<"消费产品"<<cur<<"完毕"<<",用时"<<during<<"s"<<endl;
        pthread_mutex_unlock(&print);
    }
    return 0;
}

void *producer(void *arg){
    int current_product;
    while(true){
        int *producer_id=(int *)arg;

        pthread_mutex_lock(&all);
        current_product=allproductid;
        if(allproductid==k+1){
            cout<<"退出！！！！"<<endl;
            pthread_mutex_unlock(&all);
            pthread_exit(NULL);
        }
        allproductid++;
        int during=rand()%5+1;
        pthread_mutex_lock(&print);
        cout<<"生产者"<<*producer_id<<"开始生产产品"<<current_product<<endl;
        pthread_mutex_unlock(&print);
        sleep(during);
        time_t t;
        time(&t);
        pthread_mutex_lock(&print);
        cout<<"生产者"<<*producer_id<<"于"<<ctime(&t)<<"生产完毕"<<",用时"<<during<<"s"<<endl;
        pthread_mutex_unlock(&print);
        pthread_mutex_unlock(&all);

        pthread_mutex_lock(&mutexs);
        pthread_mutex_lock(&print);
        cout<<"生产者"<<*producer_id<<"准备进入临界区"<<endl;
        pthread_mutex_unlock(&print);
        while(product.len==maxn){
            pthread_cond_signal(&full);
            pthread_cond_wait(&empty,&mutexs);
        }
        pthread_mutex_lock(&print);
        cout<<"生产者"<<*producer_id<<"已经进入临界区"<<endl;
        pthread_mutex_unlock(&print);
        BUFFER *temp=&product;

        if(product.len==0){
            temp->isempty= false;
            temp->item.producer_id=*producer_id;
            temp->item.produce_time=t;
            temp->item.product_id=current_product;
            temp->nextbuf= nullptr;
            product.len=1;
        }
        else if(product.len<maxn){
            for(int i=0;i<product.len;i++){
                temp=temp->nextbuf;
            }
            BUFFER *one=new BUFFER ;
            one->isempty= false;
            one->item.producer_id=*producer_id;
            one->item.produce_time=t;
            one->item.product_id=current_product;
            one->nextbuf= nullptr;
            temp=one;
            product.len++;
        }
        pthread_mutex_lock(&print);
        cout<<"生产者"<<*producer_id<<"已经把产品"<<current_product<<"放入缓冲区"<<endl;
        cout<<"-----------此时缓冲区内有如下----------"<<endl;
        cout<<"生产时间\t\t\t"<<"生产者\t"<<"产品id"<<endl;
        BUFFER *list=&product;
        for(int i=0;i<product.len;i++){
            cout<<ctime(&(list->item.produce_time))<<"\t"<<list->item.producer_id<<"\t"<<list->item.product_id<<endl;
            if(i==product.len-1)
                break;
        }
        pthread_mutex_unlock(&print);
        pthread_mutex_lock(&print);
        cout<<"-----------------------"<<endl;
        cout<<"生产者"<<*producer_id<<"已经离开临界区"<<endl;
        pthread_mutex_unlock(&print);
        pthread_mutex_unlock(&mutexs);
        pthread_cond_signal(&full);
    }
    return 0;
}
int main(){
    pthread_mutex_init(&mutexs,NULL);
    pthread_mutex_init(&print,NULL);
    pthread_mutex_init(&all,NULL);
    int c_num,p_num;
    cin>>p_num>>c_num>>k;
    pthread_t pro_thread[10];
    pthread_t cus_thread[10];
    int a,b,c,d;
    int c1=1;
    int c2=2;
    int c3=3;
    int c4=4;
    int p1=1;
    int p2=2;
    for(a=0;a<p_num;a++){
        if(a==0) {
            pthread_create(&pro_thread[a], NULL, producer, (void *) &p1);
        }
        if(a==1){
            pthread_create(&pro_thread[a], NULL, producer, (void *) &p2);
        }
    }
    for(b=0;b<c_num;b++){
        if(b==0) {
            pthread_create(&cus_thread[b], NULL, customer, (void *) &c1);
        }
        if(b==1){
            pthread_create(&cus_thread[b], NULL, customer, (void *) &c2);
        }
        if(b==2){
            pthread_create(&cus_thread[b], NULL, customer, (void *) &c3);
        }
    }
    for(c=0;c<p_num;c++){
        pthread_join(pro_thread[c],NULL);
    }
    for(d=0;d<c_num;d++){
        pthread_join(cus_thread[d],NULL);
    }

    pthread_mutex_destroy(&mutexs);
    pthread_mutex_destroy(&print);
    return 0;
}