Linux平台下线程同步，实现“生产者消费者问题”

（1）线程同步，实现“生产者消费者问题”

要求：缓冲区大小为20，生产者每次放一个产品，消费者每次取走一个产品；生产者和消费者至少2个。

（2）代码如下：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sched.h>
void *producter_f (void *arg);					/*生产者*/
void *consumer_f (void *arg);					/*消费者*/
int buffer_has_item=0;							/*缓冲区计数值*/
pthread_mutex_t mutex;								/*互斥区*/
//pthread_cond_t mqlock= PTHREAD_COND_INITIALIZER;
int running =1 ;								/*线程运行控制*/
int main (void)
{
	pthread_t consumer_t;						/*消费者线程参数*/
	pthread_t producter_t;						/*生产者线程参数*/
	pthread_mutex_init (&mutex,NULL);			/*初始化互斥*/
	pthread_create(&producter_t, NULL,(void*)producter_f, NULL );														/*建立生产者线程*/
	pthread_create  (&consumer_t, NULL, (void *)consumer_f, NULL);													/*建立消费者线程*/
	//usleep(1);									/*等待，线程创建完毕*/
	//running =0;									/*设置线程退出值*/
	pthread_join(consumer_t,NULL);				/*等待消费者线程退出*/
	pthread_join(producter_t,NULL);			/*等待生产者线程退出*/
	pthread_mutex_destroy(&mutex);				/*销毁互斥*/

	return 0;
}
void *producter_f (void *arg)					/*生产者线程程序*/
{
	while(running)								/*没有设置退出值*/
	{
		pthread_mutex_lock (&mutex);			/*进入互斥区*/
		if(buffer_has_item > 20)                /*缓冲区满则不生产*/
		{
			pthread_mutex_unlock(&mutex);
			usleep(1);
		}
		buffer_has_item++;						/*增加计数值*/
		printf("生产，总数量:%d\n",buffer_has_item); 	/*打印信息*/
		pthread_mutex_unlock(&mutex);			/*离开互斥区*/
	}
}
void *consumer_f(void *arg)						/*消费者线程程序*/
{
	while(running)								/*没有设置退出值*/
	{
		pthread_mutex_lock(&mutex);				/*进入互斥区*/
		buffer_has_item--;						/*减小计数值*/
		if(buffer_has_item <  0)                /*缓冲区空则不消费*/
		{
			pthread_mutex_unlock(&mutex);
			usleep(1);
		}
		printf("消费，总数量:%d\n",buffer_has_item);	/*打印信息*/
		pthread_mutex_unlock(&mutex);			/*离开互斥区*/
	}
}

（2）第二种，加入同步机制

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#define N 2   // 消费者或者生产者的数目
#define M 20 // 缓冲数目

int in = 0;   // 生产者放置产品的位置
int out = 0; // 消费者取产品的位置
int buff[M] = { 0 }; // 缓冲初始化为0, 开始时没有产品
sem_t empty_sem; // 同步信号量, 当满了时阻止生产者放产品
sem_t full_sem;   // 同步信号量, 当没产品时阻止消费者消费
pthread_mutex_t mutex; // 互斥信号量, 一次只有一个线程访问缓冲
int product_id = 0;   //生产者id
int prochase_id = 0; //消费者id

/* 打印缓冲情况 */
void print()
{
	int i;
	for (i = 0; i < M; i++)
	{
		printf("%d ", buff[i]);
	}
	printf("\n");
}

/* 生产者方法 */
void *product()
{
	int id = ++product_id; //当生产者进入的时候 执行计数加1
	while (1)
	{
		// 用sleep的数量可以调节生产和消费的速度,便于观察
		sleep(1);
		sem_wait(&empty_sem);
		pthread_mutex_lock(&mutex);
		in = in % M;
		printf("product%d in %d. like: \t", id, in);
		buff[in] = 1;
		print();
		++in;
		pthread_mutex_unlock(&mutex);
		sem_post(&full_sem);
	}
}

/* 消费者方法 */
void *prochase()
{
	int id = ++prochase_id;
	while (1)
	{
		// 用sleep的数量可以调节生产和消费的速度,便于观察
		sleep(1);
		sem_wait(&full_sem);
		pthread_mutex_lock(&mutex);
		out = out % M;
		printf("prochase%d in %d. like: \t", id, out);
		buff[out] = 0;
		print();
		++out;
		pthread_mutex_unlock(&mutex);
		sem_post(&empty_sem);
	}
}

int main()

{
	pthread_t id1[N];
	pthread_t id2[N];
	int i;
	int ret[N];
	// 初始化同步信号量
	int ini1 = sem_init(&empty_sem, 0, M);
	int ini2 = sem_init(&full_sem, 0, 0);
	if (ini1 && ini2 != 0)
	{
		printf("sem init failed \n");
		exit(1);
	}

	//初始化互斥信号量

	int ini3 = pthread_mutex_init(&mutex, NULL);
	if (ini3 != 0)
	{
		printf("mutex init failed \n");
		exit(1);
	}

	// 创建N个生产者线程
	for (i = 0; i < N; i++)
	{
		ret[i] = pthread_create(&id1[i], NULL, product, (void *) (&i));
		if (ret[i] != 0)
		{
			printf("product%d creation failed \n", i);
			exit(1);
		}
	}

	//创建N个消费者线程
	for (i = 0; i < N; i++)
	{
		ret[i] = pthread_create(&id2[i], NULL, prochase, NULL);
		if (ret[i] != 0)
		{
			printf("prochase%d creation failed \n", i);
			exit(1);
		}
	}
	//销毁线程
	for(i=0;i<N;i++)
	{
		pthread_join(id1[i],NULL);
		pthread_join(id2[i],NULL);
	}
	exit(0);
}

运行结果：