Linux多线程之线程同步

  线程最大的特点就是资源的共享性，所以也就有了一个难点线程同步，实现线程同步的方法最常用的方法是：互斥锁，条件变量和信号量。接下来就让我们来看下这几种同步的方法。

一、互斥锁（Mutex）

  获得锁的线程可以完成“读-修改-写”的操作，然后释放锁给其它线程,没有获得锁的线程只能等待而不能访问共享数据，这样“读-修改-写”三步操作组成一个原子操作，要么都执行，要么都不执行，不会执行到中间被打断，也不会在其它处理器上并行做这个操作。

1、锁的初始化和销毁（Mutex用pthread_mutex_t类型的变量表示）

  注意：如果Mutex变量是静态分配的(全局变量 或static变量),也可以用宏PTHREAD_MUTEX_INITIALIZER来初始化,相当于用pthread_mutex_init初始化并且attr参数为NULL。用函数初始化则是动态分配。

2、加锁解锁

  一个线程可以调用pthread_mutex_lock获得Mutex，如果这时另一个线程已经调用pthread_mutex_lock获得了该Mutex，则当前线程需要挂起等待，直到另一个线程调用
pthread_mutex_unlock释放Mutex，当前线程被唤醒，才能获得该Mutex并继续执行。如果一个线程既想获得锁，又不想挂起等待，可以调用pthread_mutex_trylock，如果Mutex已经被另一个线程获得，这个函数会失败返回EBUSY，而不会使线程挂起等待。

#include
#include
#include
#define LOOP 5000
static int count = 0;
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
void *read_write(void *val)
{
	int _val = 0;
	int i = 0;
	for( ; i < LOOP; i++ ){
		pthread_mutex_lock(&mutex_lock);
		_val = count;
		printf("pthread id is :%x,count : %d\n",
				(unsigned long)pthread_self(),count);
		count = _val+1;
		pthread_mutex_unlock(&mutex_lock);
	}
}
int main()
{
	pthread_t tid1;
	pthread_t tid2;
	pthread_create(&tid1,NULL,read_write,NULL);//为了简单没有判断是否创建成功
	pthread_create(&tid2,NULL,read_write,NULL);
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	printf("count final value is : %d\n",count);
	return 0;
}

如果没有加入互斥锁，运行结果不会是10000。

3、互斥锁的缺点

  死锁的情况：1）一般情况下，如果同一个线程先后两次调用lock，在第二次调用时，由于锁已经被占用，该线程会挂起等待别的线程释放锁，然而锁正是被自己占用着的，该线程又被挂起而没有机会释放锁，因此就永远处于挂起等待状态了。2）线程A获得了锁1，线程B获得了锁2，这时线程A调用lock试图获得锁2，结果是需要挂起等待线程B释放锁2，而这时线程B也调用lock试图获得锁1，结果是需要挂起等待线程A释放锁1，于是线程A和B都永远处于挂起状态了。

  解决办法：首先要尽量避免同时获得多个锁。如果所有线程在需要多个锁时都按相同的先后顺序(常见的是按Mutex变量的地址顺序)获得锁，则不会出现死锁。

二、条件变量

  互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量分为两部分: 条件和变量。条件本身是由互斥量保护的。线程在改变条件状态前先要锁住互斥量。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。  

1、条件变量的初始化和销毁

  条件变量初始化和互斥锁初始化类似，宏表示静态分配，函数表示动态分配，当函数的第二个参数为NULL则两者等价。

2、等待条件成立和激活条件变量

  可见，一个条件变量总是和一个Mutex搭配使用的。 一个线程可以调用pthread_cond_wait在一个条件变量上阻塞等待，这个函数做以下三步操作：
1）释放Mutex
2）阻塞等待
3）当被唤醒时，重新获得Mutex并返回
  pthread_cond_timedwait函数还有一个额外的参数可以设定等待超时，如果到达了abstime所指定的时刻仍然没有别的线程来唤醒当前线程，就返回ETIMEDOUT。一个线程可以调用pthread_cond_signal唤醒在某个条件变量上等待的另一个线程，也可以调用pthread_cond_broadcast唤醒在这个条件变量上等待的所有线程。

  下面写一个生产者和消费者的实现（链表）：

#include
#include
#include
typedef struct list{
	struct list *next;
	int val;
}product_list;
product_list *head = NULL;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t need_product=PTHREAD_COND_INITIALIZER;
/*init list*/
void init_list(product_list *list)
{
	if(NULL != list){
		list->next = NULL;
		list->val = 0;
	}
}
/*consumer*/
void *consumer(void *_val)
{
	product_list *p = NULL;
	while(1){
		pthread_mutex_lock(&lock);
		while(NULL == head){
			pthread_cond_wait(&need_product,&lock);
		}
		p = head;
		head = head->next;
		p->next = NULL;
		pthread_mutex_unlock(&lock);
		printf("consum success,val is : %d\n",p->val);
		free(p);
		p = NULL;
	}
}
/*product*/
void *product(void *_val)
{
	while(1){
		sleep(rand()%2);
		product_list *p = (product_list*)malloc(sizeof(product_list));
		pthread_mutex_lock(&lock);
		init_list(p);
		p->val = rand()%1000;
		p->next = NULL;
		head = p;
		pthread_mutex_unlock(&lock);
        printf("product success,val : %d\n",p->val);
		pthread_cond_signal(&need_product);
	}
}
int main()
{
	pthread_t t_product;
	pthread_t t_consumer;
	pthread_create(&t_product,NULL,product,NULL);//no check
        pthread_create(&t_consumer,NULL,consumer,NULL);//no check

	pthread_join(t_product,NULL);//wait product thread
	pthread_join(t_consumer,NULL);//wait consumer thread
	return 0;
}

三、信号量

  Mutex变量是非0即1的，可看作一种资源的可用数量，初始化时Mutex是1，表示有一个可用资源，加锁时获得该资源，将Mutex减到0，表示不再有可用资源，解锁时释放该资源，将Mutex重新加到1,表示又有了一个可用资源。
  信号量(Semaphore)和Mutex类似，表示可用资源的数量，和Mutex不同的是这个数量可以大于1。即，如果信号量描述的资源数目是1时，此时的信号量和互斥锁相同！POSIX semaphore库函数，这种信号量不仅可用于同一进程的线程间同步，也可用于不同进程间的同步。

1、信号量的创建和销毁

int sem_init(sem_t *sem , int pshared, unsigned int value);
int sem_destroy(sem_t *sem);

2、信号量的等待和释放

int sem_wait(sem_t *sem);//阻塞等待
int sem_trywait(sem_t *sem);//非阻塞等待

  调用sem_wait()可以获得资源（P操作），使semaphore的值减1，如果调用sem_wait()时semaphore的值已经是0，则挂起等待。如果不希望挂起等待，可以调用sem_trywait() 。调用sem_post() 可以释放资源（V操作），使semaphore 的值加1，同时唤醒挂起等待的线程。

  下面写一个生产者和消费者的实现（固定大小循环队列）：

#include
#include
#include
#include

#define SEM_PRO 10
#define SEM_COM 0
/*定义信号量*/
sem_t sem_product;
sem_t sem_consume;
int bank[SEM_PRO];
/*消费者线程执行函数*/
void *consumer(void *_val)
{
	int c = 0;
	while(1){
		sem_wait(&sem_consume);
		int _consume = bank[c];
		printf("consumer done...,val : %d\n",_consume);
		sem_post(&sem_product);
		c = (c+1)%SEM_PRO;
		sleep(rand()%5);
	}
}
/*生产者线程执行函数*/
void *producter(void *_val)
{
	int p = 0;
	while(1){
		sem_wait(&sem_product);
		int _product = rand()%100;
		bank[p] = _product;
		printf("product done... val is : %d\n",_product);
		sem_post(&sem_consume);
		p = (p+1)%SEM_PRO;
		sleep(rand()%3);
	}
}
/*创建生产者消费者线程*/
void run_product_consume()
{
	pthread_t tid_consumer;
	pthread_t tid_producter;

	pthread_create(&tid_consumer,NULL,consumer,NULL);
	pthread_create(&tid_producter,NULL,producter,NULL);
    
	pthread_join(tid_consumer,NULL);
	pthread_join(tid_producter,NULL);
}
/*销毁信号量*/
void destroy_all_sem()
{
	printf("process done...\n");
	sem_destroy(&sem_product);
	sem_destroy(&sem_consume);
	exit(0);
}
/*初始化信号量*/
void init_all_sem()
{
	int bank[SEM_PRO];
	int num = sizeof(bank)/sizeof(bank[0]);
	int i = 0;
	for(; i < num; i++ ){
		bank[i] = 0;
	}
	sem_init(&sem_product,0,SEM_PRO);
	sem_init(&sem_consume,0,SEM_COM);
}

int main()
{
	init_all_sem();
	run_product_consume();
//	destroy_all_sem();//避免销毁信号量
	return 0;
}