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 = ;
     int nthds = atoi( argv[] );   //线程的个数
     aque.m_capacity = atoi( argv[] );//字符串队列的大小
     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 = ; index < nthds; index ++)
     {
         pthread_create( thd_arr + index, NULL, thd_func,(void*)&aque );
     }

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

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

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

     pthread_mutex_destroy(&aque.m_lock);
     pthread_cond_destroy(&aque.m_pro);
     pthread_cond_destroy(&aque.m_con);
     return  ;
 }
 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 ==  &&  pq ->string_queue.empty()  ) //队列空 并且未结束 则阻塞
     {
         pthread_cond_wait(&pq ->m_con, &pq ->m_lock);
     }
     if(pq ->m_flag == )                 //判断结束标志
     {
         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 =  ;
     while()
     {
         memset(buf, , LEN) ;
         get(pq, buf);
         if(pq ->m_flag == )            //判断结束标志
         {
             printf("%u exit!\n", pthread_self());
             pthread_exit((void*)ncnt);             //退出
         }
         ncnt ++ ;
         printf("%u: %s\n", pthread_self(), buf);  //打印字符串
         if(strcmp("over", buf) == )              //判断结束字符串
         {
             pq ->m_flag =  ;                    //把结束符号置为 1
             pthread_cond_broadcast(&pq ->m_con); //唤醒所有线程
             pthread_exit((void*)ncnt);           //退出
         }
         if(ncnt &  == ) sleep();     //简单的负载平衡
     }
 }