#include <stdio.h>

 #include <stdlib.h>

 #include <time.h>

 #include "pthread.h"

 #define BUFFER_SIZE 1600

 #define OVER (110000)

 /* 设置一个整数的圆形缓冲区 */

 struct prodcons {

     int buffer[BUFFER_SIZE]; /* 缓冲区数组 */

     pthread_mutex_t lock; /* 互斥锁 */

     int readpos, writepos; /* 读写的位置*/

     int ji, ou, zheng, fu, zero;    //奇数、偶数、正数、负数，零的个数

     pthread_cond_t readable; /* 缓冲区非空信号 */

     pthread_cond_t writeable; /*缓冲区非满信号 */

 };

 /*--------------------------------------------------------*/

 /*初始化缓冲区*/

 void init(struct prodcons * b)

 {

     pthread_mutex_init(&b->lock, NULL);

     pthread_cond_init(&b->readable, NULL);

     pthread_cond_init(&b->writeable, NULL);

     b->readpos = ;

     b->writepos = ;

     b->ji=;

     b->ou=;

     b->zheng=;

     b->fu=;

     b->zero=;

 }

 /*--------------------------------------------------------*/

 /* 向缓冲区中写入一个整数*/

 void put(struct prodcons * b, int data)

 {

     pthread_mutex_lock(&b->lock);

     /*等待缓冲区非满*/

     //写的话，我就不等了

 //    while ((b->writepos + 1) % BUFFER_SIZE == b->readpos) {

 //    while (b->writepos  == b->readpos) {

 //        printf("wait for not write able\n");

 //        pthread_cond_wait(&b->writeable, &b->lock);

 //    }

     /*写数据并且指针前移*/

     b->buffer[b->writepos] = data;

     b->writepos++;

 //    if (b->writepos >= BUFFER_SIZE) b->writepos = 0;

     /*设置缓冲区非空信号*/

     if (b->writepos  > b->readpos)

         pthread_cond_signal(&b->readable);

     pthread_mutex_unlock(&b->lock);

 }

 /*--------------------------------------------------------*/

 /*从缓冲区中读出一个整数 */

 int get(struct prodcons * b)

 {

     int data;

     pthread_mutex_lock(&b->lock);

     /* 等待缓冲区非空*/

     while (b->writepos <= b->readpos) {

         printf("wait for new data\n");

         pthread_cond_wait(&b->readable, &b->lock);

     }

     /* 读数据并且指针前移 */

     data = b->buffer[b->readpos];

     b->readpos++;

     //统计

     if(data!=OVER){

         if(data%==)    b->ou++;

         else    b->ji++;

         if(data==)    b->zero++;

         else if(data>)    b->zheng++;

         else    b->fu++;

     }

 //    if (b->readpos >= BUFFER_SIZE) b->readpos = 0;

     /* 设置缓冲区非满信号*/

 //    pthread_cond_signal(&b->writeable);

     pthread_mutex_unlock(&b->lock);

     return data;

 }

 /*--------------------------------------------------------*/

 struct prodcons buffer;

 /*--------------------------------------------------------*/

 void * producer(void * data)

 {

     int n;

     int m;

     srand(time());

     for (n = ; n < ; n++) {

 //        srand(time(0));

     //    m=(rand()*1000)%1000;

         m=(rand())%-;

         printf(" wirte-->%d\n", m);

         put(&buffer, m);

     }

     put(&buffer, OVER);

     printf("producer stopped!\n");

     return NULL;

 }

 /*--------------------------------------------------------*/

 void * consumer(void * data)

 {

     int d;

     while () {

         d = get(&buffer);

         if (d == OVER ) break;

         printf(" %d-->read\n", d);

     }

     printf("consumer stopped!\n");

     return NULL;

 }

 /*--------------------------------------------------------*/

 int main(void)

 {

     pthread_t th_a, th_b;

     void * retval;

     init(&buffer);

     pthread_create(&th_a, NULL, producer, );

     pthread_create(&th_b, NULL, consumer, );

     /* 等待生产者和消费者结束 */

     pthread_join(th_a, &retval);

     pthread_join(th_b, &retval);

     printf("奇数个数：%d\n",buffer.ji);

     printf("偶数个数：%d\n",buffer.ou);

     printf("正数个数：%d\n",buffer.zheng);

     printf("负数个数：%d\n",buffer.fu);

     printf("零的个数：%d\n",buffer.zero);

     return ;

 }