生产者/消费者模型改进版 ——队列

上述消费者/生产者模型比较简单，缓冲区中只能容纳一条消息。生产者每提交一条消息到缓冲区中，就会通知消费者，等消费者取走消息之后才能提交下一条消息。同样，消费者也必须等待生产者提交一条消息后才能进行处理。这种设计的效率是比较低下的。

    如果将缓冲区设计为一个先进先出的队列，可以同时容纳多条消息，那么只要缓冲区不满，生产者就可以提交消息；同时，只要缓冲区不空，消费者就可以取出消息进行处理。这将大大提高整个程序的效率。
  实现时，可以利用信号量计数的特性，用信号量的值表示缓冲区中消息的个数及空闲空间的个数。但这时由于生产者和消费者可能同时访问缓冲区，故需要再用一个互斥量来进行保护。
    综上，对一个缓冲区需要定义以下三个同步变量：
sem_t full; /* 表示缓冲区中消息的个数 */
sem_t empty;/* 表示缓冲区中的空闲空间(还能容纳的消息个数) */
pthread_mutex_t lock; /* 同步对缓冲区的访问 */
这些同步变量的初始化如下：
sem_init(&full, 0, 0); /* 缓冲区中消息数为0 */
sem_init(&empty, 0, N); /* 缓冲区中的空闲空间数为N，即缓冲区的容量 */
pthread_mutex_init(&lock, NULL); /* 初始化互斥量 */

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <time.h>
#include <string.h>
#include "SqQueue.h"

// 信号量和缓冲区
struct data
{
	sem_t empty;  // 用来控制生产者，只有缓冲区为空，生产者才可以生产消息
	sem_t full;   // 用来控制消费者，只有缓冲区有数据，才可以消费
	Queue q;      // 缓冲区队列
};

struct data msg;
// 互斥锁
pthread_mutex_t mutex;

int num = 0;

// 生产者线程工作函数
void *Produce(void *v)
{	
	while (1)
	{
		int time = rand() % 100 + 1;
		usleep(time*10000);

		// 只要队列不满 就能生产消息， empty代表当前队列剩余的空间
		sem_wait(&msg.empty);
		pthread_mutex_lock(&mutex);    // 抢锁
		
		num++;   // 生产一个消息
  		
		// 将消息放入到队列里面
		EnQueue (&(msg.q), num);
		printf ("生产一条消息\n");
		
		pthread_mutex_unlock(&mutex);  // 解锁
		// 生产完了，通知消费者进行消费
		sem_post(&msg.full);
	}
}

// 消费者线程工作函数
void *Consum(void *v)
{
	char  buf[32];
	while (1)
	{
		int time = rand() % 100 + 1;
		usleep(time*10000);
		
		// 只有缓冲区有数据，就能消费消息， full当前队列消息的个数
		sem_wait(&msg.full);
		pthread_mutex_lock(&mutex);    // 抢锁
		
		int num;
		DeQueue(&(msg.q), &num);   // 去队列里取出一条消息
		printf("消费了一条消息: %d\n", num);
		
		pthread_mutex_unlock(&mutex);  // 解锁
		// 消费完了，通知生产则会进行生产
		sem_post(&msg.empty);
	}
}

int main()
{
	srand ((unsigned int)time(NULL));
	
	// 初始化信号量
	sem_init(&msg.empty, 0, 10); // 生产者，一开始要生产 10 条消息
	sem_init(&msg.full, 0, 0);   // 消费者，一开始要不能消费消息
	
	// 初始化互斥锁
	pthread_mutex_init(&mutex, NULL);
	
	// 初始化队列
	InitQueue(&(msg.q));

	pthread_t produceId;
	pthread_t consumId;
	
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		// 创建生产者线程
		pthread_create(&produceId, NULL, Produce, NULL);
		pthread_detach(produceId);
	}
	
	// 创建消费者线程
	pthread_create(&consumId, NULL, Consum, NULL);
	
	// 等待线程结束
	pthread_join(consumId, NULL);
	
	// 销毁信号量
	sem_destroy(&msg.empty);
	sem_destroy(&msg.full);
	
	// 销毁互斥锁
	pthread_mutex_destroy(&mutex);
	return 0;
}