1 producer — n consumers 模型 实现

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<queue>
using namespace std;
#define LEN 128
typedef struct task_que
{
    queue<char*> string_queue;
    int m_flag ;        //结束标志
    int m_capacity;
    pthread_mutex_t m_lock;
    pthread_cond_t m_pro , m_con;
}QUE , *pQUE;
void* thd_func(void* arg);
void put(pQUE pq, char* src);
void get(pQUE pq, char* dest);
int main(int argc, char *argv[])
{
    QUE aque;
    aque.m_flag = 0;
    int nthds = atoi( argv[1] );   //线程的个数
    aque.m_capacity = atoi( argv[2] );//字符串队列的大小
    pthread_mutex_init( &aque.m_lock , NULL ); //锁
    pthread_cond_init( &aque.m_pro ,NULL );   //生产者条件变量
    pthread_cond_init( &aque.m_con , NULL );  //消费者条件变量
    //开辟线程空间
    pthread_t *thd_arr = ( pthread_t*)calloc(nthds, sizeof(pthread_t));
    int* ntasks = (int*)calloc(nthds, sizeof(int));//用来记录 线程工作了几次
    //创建线程
    int index;
    for(index = 0; index < nthds; index ++)
    {    
        pthread_create( thd_arr + index, NULL, thd_func,(void*)&aque );
    }


    //输入字符串到队列中
    char buf[LEN] ;
    while( memset(buf, 0, LEN), fgets(buf, LEN, stdin) != NULL)
    {
        put(&aque, buf);
    }



    //发出结束字符串
    strcpy(buf, "over");
    put(&aque, buf);

    for(index = 0; index < nthds; index ++)
    {
        pthread_join(thd_arr[index], (void**)(ntasks + index ));
    }
    for(index = 0; index < nthds; index ++)
    {
        printf("%d ", ntasks[index]);
    }
    printf("
");

    pthread_mutex_destroy(&aque.m_lock);
    pthread_cond_destroy(&aque.m_pro);
    pthread_cond_destroy(&aque.m_con);
    return 0 ;
}
void put(pQUE pq,  char* src)      //把字符串写到队列中
{
    pthread_mutex_lock(&pq ->m_lock);   //加锁
    while(pq ->string_queue.size() == pq ->m_capacity)  //队列满则阻塞
    {
        pthread_cond_wait(&pq -> m_pro, &pq ->m_lock);

    }
    //插入队列
    char* tem =  ( char*)calloc( LEN , sizeof( char ));
    strcpy(tem,src);
    pq->string_queue.push(tem);
    pthread_mutex_unlock(&pq -> m_lock);  //解锁
    pthread_cond_broadcast(&pq ->m_con);  //唤醒所有消费者线程


}

void get(pQUE pq, char* dest)
{
    pthread_mutex_lock(&pq ->m_lock); //加锁
    while(pq ->m_flag == 0 &&  pq ->string_queue.empty()  ) //队列空 并且未结束 则阻塞
    {
        pthread_cond_wait(&pq ->m_con, &pq ->m_lock);
    }
    if(pq ->m_flag == 1)                 //判断结束标志
    {
        pthread_mutex_unlock(&pq ->m_lock); //解锁
        return ;                         
    }
    //出队
    strcpy(dest, pq ->string_queue.front());
    pq->string_queue.pop();

    pthread_mutex_unlock(&pq ->m_lock);
    pthread_cond_signal(&pq ->m_pro);

}

void* thd_func(void* arg)
{
    pQUE pq = (pQUE)arg ;
    char buf[LEN] ;
    int ncnt = 0 ;
    while(1)
    {
        memset(buf, 0, LEN) ;
        get(pq, buf);
        if(pq ->m_flag == 1)            //判断结束标志
        {
            printf("%u exit!
", pthread_self());
            pthread_exit((void*)ncnt);             //退出
        }
        ncnt ++ ;
        printf("%u: %s
", pthread_self(), buf);  //打印字符串
        if(strcmp("over", buf) == 0)              //判断结束字符串        
        {
            pq ->m_flag = 1 ;                    //把结束符号置为 1
            pthread_cond_broadcast(&pq ->m_con); //唤醒所有线程
            pthread_exit((void*)ncnt);           //退出
        }
        if(ncnt & 1 == 1) sleep(1);     //简单的负载平衡
    }
}