線程互斥：
所謂互斥：即是間接制約關系，指系統中的某些共享資源，一次只允許一個線程訪問，當一個線程正在訪問該臨界資源時，其它線程必須等待。

mutex(互斥量):

• 互斥量本身也是一把鎖，提供對資源的獨占訪問。
• 大部分情況下，線程使用的數據都是局部變量，變量的地址空間在線程棧空間內，變量歸屬于某個單個線程，其它線程無法獲得這種變量。

• 共享變量：很多變量需要在線程間共享，可以通過數據的共享，完成數據間的交互。

  下面我們來看一個買票問題（沒加互斥量之前)

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<pthread.h>
  5 
  6 int ticket=100;
  7 
  8 void*thread_run(void*arg)
  9 {
 10         int a=(int)arg;
 11         while(1){
 12                 if(ticket>0){
 13                         usleep(10000);
 14                         printf("%d sells ticket:%d\n",a ,ticket);
 15                         ticket--;
 16                 }else{
 17                         break;
 18                 }
 19         }
 20 }
 21 int main()
 22 {
 23         pthread_t t1,t2,t3,t4;
 24         void*ret1;
 25         void*ret2;
 26         void*ret3;
 27         void*ret4;
 28         pthread_create(&t1,NULL,thread_run,(void*)1);
 29         pthread_create(&t2,NULL,thread_run,(void*)2);
 30         pthread_create(&t3,NULL,thread_run,(void*)3);
 31         pthread_create(&t4,NULL,thread_run,(void*)4);
 32 
 33         pthread_join(t1,&ret1);
 34         pthread_join(t2,&ret2);
 35         pthread_join(t3,&ret3);
 36         pthread_join(t4,&ret4);
 37 }

結果顯示：

因為每個線程取票的過程并不是原子性的。

下面來看看互斥量的接口；
- 初始化互斥量：

• 方法一：靜態分配：

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER

• 方法二：動態分配：

int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

    參數解釋：mutex:要初始化的互斥量。
            attr:NULL

- 銷毀互斥量：
1.靜態分配的互斥量不需要銷毀。
2.不要銷毀一個已經加鎖的互斥量。
3.已經銷毀的互斥量，要確保后面的不會有線程再嘗試加鎖。

int pthread_mutex_destroy(pthread_mutex_t *mutex);

互斥量的加鎖與解鎖：

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值:成功返回0，失敗返回錯誤號。
則可改進上邊的售票系統：

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<unistd.h>
  4 #include<pthread.h>
  5 
  6 int ticket=100;
  7 pthread_mutex_t mutex;
  8 
  9 void*thread_run(void*arg)
 10 {
 11         int a=(int)arg;
 12         while(1){
 13                 pthread_mutex_lock(&mutex);//加鎖
 14                 if(ticket>0){
 15                         usleep(10000);
 16                         printf("%d sells ticket:%d\n",a ,ticket);
 17                         ticket--;
 18                         pthread_mutex_unlock(&mutex);//解鎖
 19                 }else{
 20 
 21                         pthread_mutex_unlock(&mutex);//解鎖
 22                         break;
 23                 }
 24         }
 25 }
 26 int main()
 27 {
 28         pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//初始化互斥量
 29         pthread_t t1,t2,t3,t4;
 30         void*ret1;
 31         void*ret2;
 32         void*ret3;
 33         void*ret4;
 34         pthread_create(&t1,NULL,thread_run,(void*)1);
 35         pthread_create(&t2,NULL,thread_run,(void*)2);
 36         pthread_create(&t3,NULL,thread_run,(void*)3);
 37         pthread_create(&t4,NULL,thread_run,(void*)4);
 39         pthread_join(t1,&ret1);
 40         pthread_join(t2,&ret2);
 41         pthread_join(t3,&ret3);
 42         pthread_join(t4,&ret4);
 43 }

運行結果：

線程同步：
1. 條件變量
- 當一個線程互斥地訪問某個變量時，它可能發現在其他線程改變狀態之前，它什么也做不了。
- 例如一個線程訪問隊列時，發現隊列為空，它只能等待。直到其他線程將一個節點添加到隊列中。
- 所以條件變量相當于一個中介。如一個搶答器，兩人同時按其的過程。
- 多線程條件下通知某些事件已經就緒的方式。

條件變量函數：
初始化：

int pthread_cond_init(pthread_cond_t *cond,const pthread_condattr_t *attr);
參數：
    cond:要初始化的條件變量
    attr:NULL

銷毀：int pthread_cond_destroy(pthread_cond_t *cond)
等待條件滿足：

int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);
參數：
    cond:要在此條件變量上等待
    mutex:互斥量,因為在等待時需要將鎖釋放掉。

喚醒條件：

int pthread_cond_signal(pthread_cond_t *cond);

一個簡單的案例：

1 #include<stdio.h>
  2 #include<pthread.h>
  3 #include<unistd.h>
  4 #include<string.h>
  5 #include<stdlib.h>
  6 
  7 pthread_cond_t cond;
  8 pthread_mutex_t mutex;
  9 
 10 void*r1(void*arg)
 11 {
 12         while(1){
 13                 pthread_cond_wait(&cond,&mutex);
 14                 printf("hello\n");
 15         }
 16 }
 17 void *r2(void*arg)
 18 {
 19         while(1){
 20                 pthread_cond_signal(&cond);
 21                 sleep(1);
 22         }
 23 }
 24 int main()
 25 {
 26         pthread_t t1,t2;
 27         pthread_mutex_init(&mutex,NULL);
 28         pthread_create(&t1,NULL,r1,NULL);
 29         pthread_create(&t2,NULL,r2,NULL);
 30         pthread_join(t1,NULL);
 31         pthread_join(t2,NULL);
 32         pthread_mutex_destroy(&mutex);
 33         pthread_cond_destroy(&cond);
 34 }
~     

運行結果顯示：(每隔1秒打印一個hello world)

2. POSIX信號量（用于實現線程同步）
初始化信號量：

#include<semaphore.h>
int sem_init(sem_t *sem,int pshared,unsigned int value);
參數:
     pshared:0表示線程間共享，非0表示進程間共享
     value:信號量初始值。

申請信號量不成功時，則申請的線程會被掛起。
銷毀信號量:

#include<semaphore.h>
int sem_destroy(sem_t *sem)

等待信號量（p操作）

功能：會將信號量的值減1
int sem_wait(sem_t *sem);

發布信號量(v操作）

功能：表示資源使用完畢，可以歸還資源了，將信號量值加1.
int sem_post(sem_t *sem)

好了，具體的代碼會在下篇博客生產者、消費者模型中呈現。