生产者与消费者

解释来着wiki:

生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常采用进程间通信的方法解决该问题，常用的方法有信号灯法^[1]等。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。

此题是一种协同的方式来完成任务。（主要是因为资源有限），并且保证消费者退出后，生产者在退出，最终主线程退出！

在此利用的是条件变量的方式实现协同！代码如下，大家可以适当加sleep();//这个是延时s的，usleep()来实现一定的时延更方便看结果！

#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <pthread.h>

pthread_t  consumer_id,product_id;//生产者消费者线程id
const int max_size = 100;//
int count = 0;
int global_arr[max_size];
struct  product_consumer
{
    int read_pos;
    int write_pos;
    pthread_mutex_t  mutex_lock;
    pthread_cond_t  product_cond;
    pthread_cond_t  consumer_cond;
};
struct  product_consumer  gloabal_product_consumer_val;
struct  product_consumer   *gloabal_product_consumer = &gloabal_product_consumer_val;
void init(struct  product_consumer  *product_consumer_val);
void * product_fcn(void *);
void * consumer_fcn(void *);

int main()
{

    init(gloabal_product_consumer);

    pthread_create(&consumer_id,NULL,consumer_fcn,NULL);
    pthread_create(&product_id,NULL,product_fcn,NULL);

    pthread_join(product_id,NULL);

    return 0;
}

void init(struct  product_consumer  *product_consumer_val)
{
    product_consumer_val->read_pos = 0;
    product_consumer_val->write_pos = 0;
    pthread_mutex_init(&product_consumer_val->mutex_lock,NULL);
    pthread_cond_init(&product_consumer_val->product_cond,NULL);
    pthread_cond_init(&product_consumer_val->consumer_cond,NULL);
}

void * product_fcn(void *)
{
     while(true)
     {
             pthread_mutex_lock(&gloabal_product_consumer->mutex_lock);

             //full
                while((gloabal_product_consumer->write_pos + 1)%max_size== gloabal_product_consumer->read_pos)
                {
                    pthread_cond_wait(&gloabal_product_consumer->product_cond,&gloabal_product_consumer->mutex_lock);
                }
                count++;
                printf("product:%d,%d \n",count,gloabal_product_consumer->write_pos);
                global_arr[(gloabal_product_consumer->write_pos + 1)%max_size] = 1;
                gloabal_product_consumer->write_pos  = (gloabal_product_consumer->write_pos + 1)%max_size;

            pthread_mutex_unlock(&gloabal_product_consumer->mutex_lock);
            pthread_cond_signal(&gloabal_product_consumer->consumer_cond);
            if(count >= 1000)
            {
                pthread_join(consumer_id,NULL);//保证消费者先退出
                 printf("product exit!\n");
                break;
            }

     }
    return NULL;
}


void * consumer_fcn(void *)
{
     while(true)
     {
             pthread_mutex_lock(&gloabal_product_consumer->mutex_lock);

             //empty
                while((gloabal_product_consumer->write_pos )%max_size== gloabal_product_consumer->read_pos)
                {
                    pthread_cond_wait(&gloabal_product_consumer->consumer_cond,&gloabal_product_consumer->mutex_lock);
                }
                printf("consumer:%d ,%d\n",count,gloabal_product_consumer->read_pos);

                global_arr[(gloabal_product_consumer->read_pos + 1)%max_size] = 0;
                gloabal_product_consumer->read_pos  = (gloabal_product_consumer->read_pos + 1)%max_size;

            pthread_mutex_unlock(&gloabal_product_consumer->mutex_lock);
            pthread_cond_signal(&gloabal_product_consumer->product_cond);

             if(count >= 1000&&gloabal_product_consumer->write_pos == gloabal_product_consumer->read_pos)
            {
                printf("consumer exit! \n");
                break;

            }
     }
   return NULL;
}