Linux——线程锁实现的生产者、消费者模型

资料来自于网络整理：

下面以著名的生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。

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

#define BUFFER_SIZE 16 // 缓冲区数量

struct prodcons
{
	int buffer[BUFFER_SIZE];  /* 实际数据存放的数组*/
	pthread_mutex_t lock;     /* 互斥体lock 用于对缓冲区的互斥操作 */
	int readpos, writepos;    /* 读写指针*/
	pthread_cond_t notempty;  /* 缓冲区非空的条件变量：put */
	pthread_cond_t notfull;   /* 缓冲区未满的条件变量：get */
};

/* 初始化缓冲区结构 */
void init(struct prodcons *b)
{
	pthread_mutex_init(&b->lock, NULL);
	pthread_cond_init(&b->notempty, NULL);
	pthread_cond_init(&b->notfull, NULL);
	b->readpos  = 0;
	b->writepos = 0;
}

/* 将产品放入缓冲区,这里是存入一个整数*/
void put(struct prodcons *b, int data)
{
	pthread_mutex_lock(&b->lock);
	/* 等待缓冲区未满*/
	/*读写的有效位置：读的有效位置为有数据；写的有效位置为NULL；
	   如果当前写为NULL，但是下一个位置为读有效位置，则不可以写：
			write:3, read:0
			write:2, read:3
			write:1, read:2
			write:0, read:1
			write:3, read:0
			write:2, read:3*/
	if ((b->writepos + 1) % BUFFER_SIZE == b->readpos)
	{
		//printf("write:%d, read:%d\n", b->writepos, b->readpos);
		pthread_cond_wait(&b->notfull, &b->lock);
	}
	/* 写数据,并移动指针 */
	b->buffer[b->writepos] = data;
	b->writepos++;
	if (b->writepos >= BUFFER_SIZE)
		b->writepos = 0;
	/* 设置缓冲区非空的条件变量*/
	pthread_cond_signal(&b->notempty);
	pthread_mutex_unlock(&b->lock);
} 

/* 从缓冲区中取出整数*/
int get(struct prodcons *b)
{
	int data;
	pthread_mutex_lock(&b->lock);
	/* 等待缓冲区非空 */ 
	/* 保证读的位置不等于写的位置，即保证有数据 */
	if (b->writepos == b->readpos)
	{
		pthread_cond_wait(&b->notempty, &b->lock);
	}
	/* 读数据,移动读指针*/
	data = b->buffer[b->readpos];
	b->readpos++;
	if (b->readpos >= BUFFER_SIZE)
		b->readpos = 0;
	/* 设置缓冲区未满的条件变量*/
	pthread_cond_signal(&b->notfull);
	pthread_mutex_unlock(&b->lock);
	return data;
}

/* 测试:生产者线程将1 到10000 的整数送入缓冲区,消费者线
   程从缓冲区中获取整数,两者都打印信息*/
#define OVER ( - 1)
struct prodcons buffer;
void *producer(void *data)
{
	int n;
	for (n = 0; n < 20; n++)
	{
		printf("%d --->\n", n);
		put(&buffer, n);
	} 
	put(&buffer, OVER);
	return NULL;
}

void *consumer(void *data)
{
	int d;
	while (1)
	{
		d = get(&buffer);
		if (d == OVER) //put缓冲区的数据为OVER
			break;
		printf("--->%d \n", d);
	}
	return NULL;
}

int main(void)
{
	pthread_t th_a, th_b;
	void *retval;
	init(&buffer);
	/* 创建生产者和消费者线程*/
	pthread_create(&th_a, NULL, producer, 0);
	pthread_create(&th_b, NULL, consumer, 0);
	/* 等待两个线程结束*/
	pthread_join(th_a, &retval);
	pthread_join(th_b, &retval);
	
	return 0;
}

线程同步：同步就是线程等待某个事件的发生。只有当等待的事件发生线程才继续执行，否则线程挂起并放弃处理器。当多个线程协作时，相互作用的任务必须在一定的条件下同步。
Linux下的C语言编程有多种线程同步机制，最典型的是条件变量(condition variable)：
》pthread_cond_init 用来创建一个条件变量，其函数原型为：
pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr);
》pthread_cond_wait和pthread_cond_timedwait用来等待条件变量被设置，值得注意的是这两个等待调用需要一个已经上锁的互斥体mutex，这是为了防止在真正进入等待状态之前别的线程有可能设置该条件变量而产生竞争。
pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);

》pthread_cond_broadcast用于设置条件变量，即使得事件发生，这样等待该事件的线程将不再阻塞：
pthread_cond_broadcast (pthread_cond_t *cond) ;

》pthread_cond_signal则用于解除某一个等待线程的阻塞状态，唤醒：
pthread_cond_signal (pthread_cond_t *cond) ; 

》pthread_cond_destroy 则用于释放一个条件变量的资源。