在多線程訪問共享數據的時候可能會發生沖突，例如：

/*沖突的例子*/
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>

int common_data=0;//公共數據 

void increase_data(void* vptr){
	//讓common_data自增10次
	//兩個線程都來執行它，如果不沖突的話common_data最后會等于20
	int val; 
	for(int i=0;i<10;i++){
	 	val=common_data;
	 	sleep(vptr);
	 	printf("線程%d：common_data=%d\n",(unsigned int)pthread_self(),common_data);
	 	common_data=val+1;
	}
	return NULL;
}

int main(void){
	pthread_t tid1,tid2;
	int err;
	err=pthread_create(&tid1,NULL,(void*)increase_data,(void *)1);
	if(err!=0){//創建失敗 
		printf("failed to create thread\n");
		exit(1);
	}
	err=pthread_create(&tid2,NULL,(void*)increase_data,(void *)2);
	if(err!=0){//創建失敗 
		printf("failed to create thread\n");
		exit(1);
	}
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	return 0;
}

我們會觀察到：

數據完全亂套了，沒有得到預期的20。

和這個類似的還有一個有趣的例子：

/*沒有加鎖但是沒有沖突的情況*/
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>

int common_data=0;//公共數據 

void pthread1(void* arg);//第一個線程 
void pthread1(void* arg);//第二個線程 

void pthread1(void* arg){
	//線程1要修改公共的數據common_data
	//按照預期，執行后common_data=10 
	for(int i=0;i<10;i++){
		common_data++;
		//sleep(2);
		printf("pthread1:第%d次循環,common_data=%d\n",i,common_data);
	}
}

void pthread2(void* arg){
	//線程2要修改公共的數據common_data
	//按照預期，執行后common_data=10
	//如果兩個線程不發生沖突，common_data最后等于20 
	for(int i=0;i<10;i++){
		common_data++;
		//sleep(1);
		printf("pthread2:第%d次循環,common_data=%d\n",i,common_data);
	}
}

int main(void){
	pthread_t tid1,tid2;
	int err;
	err=pthread_create(&tid1,NULL,(void*)pthread1,NULL);
	if(err!=0){//創建失敗 
		printf("failed to create thread\n");
		exit(1);
	}
	err=pthread_create(&tid2,NULL,(void*)pthread2,NULL);
	if(err!=0){//創建失敗 
		printf("failed to create thread\n");
		exit(1);
	}
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	return 0;
}

這個例子運行以后沒有沖突，這是為什么呢？！在和同學討論并經過自己動手實踐以后證實，其實只要把循環次數增加，比如增加到10000000，還是會觀察到沖突的，如下圖：

也就是說，當數據量小的時候，執行速度較快，給人的錯覺是“順序”執行的，但是數據量一旦大起來，總有某次讀寫操作相互過不去......。然后common_data的值就亂了。這也體現了所謂“量變引起質變”吧。

為了解決多個線程訪問同一個數據（可能）會出現的沖突問題，一個行之有效的方法就是加互斥鎖（MUTual EXclusive lock，mutex）。相關的函數：

（1）pthread_mutex_init

用來申請一個互斥鎖。

例如：

pthread_mutex_t mutex;
pthread_mutex_init(&mutex,NULL);

第一個參數傳入pthread_mutex_t類型的指針，第二個指定了需要的屬性，一般用NULL。

（2）pthread_mutex_lock

給代碼段加鎖。加鎖意味著當前只有這個鎖定這個代碼段的線程能夠執行它，如果其他線程要執行這些代碼，這些線程就會被掛起。

（3）pthread_mutex_trylock

功能同（2），但是這個函數是“嘗試加鎖”，也就是說如果加鎖失敗了，函數會立刻返回，線程繼續執行。

（4）pthread_mutex_unlock

解鎖（但鎖還在，區別下面的pthread_mutex_destroy），和（3）、（4）配合使用。

（5）pthread_mutex_destroy

徹底銷毀鎖，功能同解鎖，如果我們不再需要某個鎖了就可以銷毀它。

有了互斥鎖的機制，就可以解決剛才的沖突問題了：

/*沒有加鎖但是沒有沖突的情況*/
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>

int common_data=0;//公共數據 
pthread_mutex_t mutex;
 
void pthread1(void* arg);//第一個線程 
void pthread1(void* arg);//第二個線程 

void pthread1(void* arg){
	//線程1要修改公共的數據common_data
	//按照預期，執行后common_data=10 
	for(int i=0;i<10;i++){
		pthread_mutex_lock(&mutex);//加鎖 
		common_data++;
		printf("pthread1:第%d次循環,common_data=%d\n",i,common_data);
		pthread_mutex_unlock(&mutex);//解鎖 
	}
}

void pthread2(void* arg){
	//線程2要修改公共的數據common_data
	//按照預期，執行后common_data=10
	//如果兩個線程不發生沖突，common_data最后等于20 
	for(int i=0;i<10;i++){
		pthread_mutex_lock(&mutex);//加鎖 
		common_data++;
		printf("pthread2:第%d次循環,common_data=%d\n",i,common_data);
		pthread_mutex_unlock(&mutex);//解鎖 
	}
}

int main(void){
	pthread_t tid1,tid2;
	int err;
	pthread_mutex_init(&mutex,NULL);//初始化鎖 
	err=pthread_create(&tid1,NULL,(void*)pthread1,NULL);
	if(err!=0){//創建失敗 
		printf("failed to create thread\n");
		exit(1);
	}
	err=pthread_create(&tid2,NULL,(void*)pthread2,NULL);
	if(err!=0){//創建失敗 
		printf("failed to create thread\n");
		exit(1);
	}
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_mutex_destroy(&mutex);//將鎖徹底銷毀 
	return 0;
}

運行效果：

這一次盡管執行次數很大，但是沒有沖突了，得到了預期的2000000。