生产者 与消费者模型(mutx、cond)

#模型
生产者——消费者
##认识：
一个盘子只能放5个苹果，小明有100个苹果，小张、小刘等着取盘子的苹果；小明放供他们取。(盘子成了有界缓冲区)盘子里面有5 个就不能放，盘子里面为空不能取苹果。
##实现原理：

利用互斥量和条件变量进行同步，实现的一种机制，遵循有界缓冲区不满，生产者往里面写数据，写满了唤醒读线程即消费者消费数据，消费空了则唤醒写线程，生产者去生产数据

##理解：

#代码

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
//20个数据
#define MAX_SIZE 20
//有界缓冲区
#define BUFFER_SIZE 8
//数据结尾
#define OVER -1
//定义一个结构体  
typedef struct st_pc
{
	pthread_mutex_t mutex;
	pthread_cond_t notfull;
	pthread_cond_t notempty;
	int  write_pos;
	int  read_pos;
	char buffer[BUFFER_SIZE];
}st_pc；
st_pc pc;
// 对结构体初始化  动态初始化 
st_init(st_pc *p )
{
	pthread_mutex_init(&p->mutex,NULL);
	pthread_cond_init(&p->notfull,NULL);
	pthread_cond_init(&p->notempty,NULL);
	p->write_pos = 0;
	p->read_pos = 0;
	memset(p->buffer,0,sizeof(p->buffer));
}
//摧毁
st_destory(st_pc *p)
{
	pthread_mutex_destroy(&p->mutex);
	pthread_cond_destroy(&p->notfull);
	pthread_cond_destroy(&p->notempty);
	p->write_pos = 0;
	p->read_pos = 0;
	memset(p->buffer,0,sizeof(p->buffer));
}
//写数据 满了就阻塞 唤醒读
void st_put(st_pc *p,int val)
{
	pthread_mutex_lock(&p->mutex);
	if((p->write_pos+1)%BUFFER_SIZE == p->read_pos)
	{
		pthread_cond_wait(&p->notfull,&p->mutex);
	}
	p->buffer[p->write_pos] = val;
	p->write_pos=(p->write_pos+1)%BUFFER_SIZE;
	pthread_cond_signal(&p->notempty);
	pthread_mutex_unlock(&p->mutex);
}
//取数据 空了就阻塞 唤醒写
int  st_get(st_pc *p)
{
	pthread_mutex_lock(&p->mutex);
	if(p->read_pos == p->write_pos)
	{
		pthread_cond_wait(&p->notempty,&p->mutex);
	}
	int val = p->buffer[p->read_pos];
	p->read_pos=(p->read_pos+1)%BUFFER_SIZE;
	pthread_cond_signal(&p->notfull);
	pthread_mutex_unlock(&p->mutex);
	return val;
}
////////////////////////////
//生产者 写
void *pro_fun(void *arg)
{
	int i;
	for(i=1;i<=MAX_SIZE;i++)
	{
		st_put(&pc,i);
	}
	
	st_put(&pc,OVER);
}
//消费者  读
void *con_fun(void *arg)
{
	int val;
	while(1)
	{
		val=st_get(&pc);
		sleep(1);
		//不停地读，读到over 结束
		if(val == OVER)
			break;
		printf("val = %d\n",val);
	}
}
////////////////////////////
int main()
{
	
	st_init(&pc);
	pthread_t tid1,tid2;
	//生产者 写
	pthread_create(&tid1,NULL,pro_fun,NULL);
	sleep(1);
	//消费者 读
	pthread_create(&tid2,NULL,con_fun,NULL);
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	st_destory(&pc);
	return 0;
}

#总结

1、pthread_mutex_t mutex pthread_cond_cond有两种初始化的方式，静态的和动态的两种；当自定义某种结构时，使用动态的方法
2、msg通过隐式的方式进行通信(send、recv 为阻塞函数)
3、共享内存必须通过显示额方式进行同步同信(sem，或互斥锁、mutex和cond）
4、循环队列的处理方式：(模可以是实现循环)
a、队列为空的判断 w_pos == r _pos%buffer;
r_pos = r_pos+1%(buffer) ;
b、队列满 空出最后一个空间(之前的都是满的) (w_pos+1)%buffer ==r_pos
w_pos = (w_pos+1)%buffer;