lesson4 线程同步

1. 互斥量mutex

2. 读写锁：pthread_rwlock_t rwlock//非常适合读次数大于写次数的程序

读写锁的三种状态：读模式加锁、写模式加锁、不加锁。一次只有一个线程占用写模式的读写锁，但是多个线程可以同时占用读模式的读写锁。

读写锁在写加锁状态时，在被解锁前，所有试图这个锁加锁的线程将会阻塞。以读加锁时，所有试图读模式加锁的线程都能获得访问权限，但是如果希望以写模式加锁，则必须阻塞直到所有线程释放锁。

读写锁一读模式加锁时，如果有其他线程试图以写模式加锁，那么读写锁会阻塞随后的读模式加锁请求，避免锁长期占用。

pthread_rwlock_init初始化锁

pthread_rwlock_destroy销毁锁

pthread_rwlock_rdlock //读模式加锁

pthread_rwlock_tryrdlock

pthread_rwlock_wrlock //写模式加锁

pthread_rwlock_trywrlock

pthread_rwlock_unlock //解锁

3. 条件变量

当互斥量被锁住以后发现当前线程还是无法完成自己的操作，那么它应该释放互斥量，让其他线程工作：

a. 轮询的方法，不停的查询你需要的条件；

b. 系统帮你查询条件，使用条件变量pthread_condi_t cond

pthread_cond_init //初始化

pthread_cond_destroy //销毁

pthread_cond_wait //等待条件为真

参数中的互斥量对条件进行保护，传递锁住的互斥量

函数将线程放到等待条件的线程列表上，然后对互斥量进行解锁。当条件满足时函数返回，返回以后继续对互斥量加锁。

pthread_cond_timedwait //指定时间条件不满足，那么函数返回

条件满足时需要唤醒等待条件的线程

pthread_cond_boradcast //唤醒等待条件的所有线程

pthread_cond_signal //至少唤醒等待条件的一个线程

一定要在条件改变以后再唤醒进程

4. 一个很好的例子：说明了条件变量的使用

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <time.h>  
#include <unistd.h>  
#include <pthread.h>  
  
#define BUFFER_SIZE         5       //产品库存大小  
#define PRODUCT_CNT         50      //产品生产总数   
  
struct product_cons  
{  
	int buffer[BUFFER_SIZE];  //生产产品值  
	pthread_mutex_t lock;     //互斥锁 volatile int  
    int readpos, writepos;    //读写位置  
    pthread_cond_t notempty;  //条件变量，非空  
   pthread_cond_t notfull;   //非满  
}buffer;  
  
void init(struct product_cons *p)  
{  
	pthread_mutex_init(&p->lock, NULL);     //互斥锁  
    pthread_cond_init(&p->notempty, NULL);  //条件变量  
    pthread_cond_init(&p->notfull, NULL);   //条件变量  
    p->readpos = 0;                         //读写位置  
    p->writepos = 0;  
}  
  
void fini(struct product_cons *p)  
{  
    pthread_mutex_destroy(&p->lock);     //互斥锁  
	pthread_cond_destroy(&p->notempty);  //条件变量  
	pthread_cond_destroy(&p->notfull);   //条件变量  
	p->readpos = 0;                      //读写位置  
	p->writepos = 0;  
}  
  
void cleanup_handler(void *arg)  
{  
	printf("cleanup_handler exec!\n");  
	pthread_mutex_t *lock = (pthread_mutex_t*)arg;  
	pthread_mutex_unlock(lock); //解锁  
}  
  
//存储 一个数据 到 bufferr  
void put(struct product_cons *p, int data) //输入产品子函数  
{  
    pthread_mutex_lock(&p->lock); //上锁  

	/*等待，直到 buffer 不为 满*/  
	while((p->writepos + 1) % BUFFER_SIZE == p->readpos) //测试空间是否已满  
	{  
		printf("producer wait for not full\n");  
		pthread_cond_wait(&p->notfull, &p->lock); //阻塞等待  
		//这里，生产者 notfull 等待消费者 pthread_cond_signal(&p->notfull);信号  
		//如果，消费者发送了 signal 信号，表示有了 空闲  
	}  

	p->buffer[p->writepos] = data; //写数据  
	p->writepos++;  
	if(p->writepos >= BUFFER_SIZE) //如果写到 尾部,返回  
		p->writepos = 0;  
	pthread_cond_signal(&p->notempty); //发送有数据信号  
	pthread_mutex_unlock(&p->lock); //解锁        
}  

//读，移除 一个数据 从 buffer  
int get(struct product_cons *p)  
{  
	int data = 0;
	pthread_mutex_lock(&p->lock);
	/*等待，直到不为空*/  
	while(p->writepos == p->readpos)  
	{  
		printf("consumer wait for not empty\n");  
		pthread_cond_wait(&p->notempty,&p->lock);  
	}  
	
	/*读 一个 数据*/  
	data = p->buffer[p->readpos];          
	p->readpos++;  

	if(p->readpos >= BUFFER_SIZE) //如果读到 尾  
		p->readpos = 0;  

	pthread_cond_signal(&p->notfull);
	pthread_mutex_unlock(&p->lock);  

	return data;      
}  

void *producer(void *data) //子线程 ，生产
{
	int n;  
	for(n = 1; n <= 50; ++n) //生产 50 个产品  
	{  
		sleep(1);  
		printf("put the %d product\n",n);
		put(&buffer,n);  
	}  

	printf("producer stopped\n");  

	return NULL;  
}  

void *consumer(void *data)  
{  
	static int cnt = 0;  
	while(1)  
	{  
		sleep(2);  
		printf("get the %d product\n", get(&buffer));  
		if(++cnt == PRODUCT_CNT)  
			break;  
	}  

	printf("consumer stopped\n");  
	return NULL;  
}  

int main(int argc, char *argv[])  
{  
	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);  

	fini(&buffer);  

	return 0;  
}  

执行结果：