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<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#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<stdio.h>
#include<stdlib.h>
#include<pthread.h>
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<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>

#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;
}