linux基礎——linux線程間通信及同步機制總結

線程間的通信有兩種情況：

　　1、一個進程中的線程與另外一個進程中的線程通信，由於兩個線程只能訪問自己所屬進程的地址空間和資源，故等同於進程間的通信。

　　2、同一個進程中的兩個線程進行通信。本文說的就是第二種情況。

關於進程間通信（IPC）可以看我的另一篇博文

http://blog.csdn.net/a987073381/article/details/52006729

　　比起進程復雜的通信機制（管道、匿名管道、消息隊列、信號量、共享內存、內存映射以及socket等），線程間通信要簡單的多。

　　因為同一進程的不同線程共享同一份全局內存區域，其中包括初始化數據段、未初始化數據段，以及堆內存段，所以線程之間可以方便、快速地共享信息。只需要將數據復制到共享（全局或堆）變量中即可。不過，要避免出現多個線程試圖同時修改同一份信息。

下圖為多線程的進程地址空間：

 線程安全：

　　所在的進程中有多個線程在同時運行，而這些線程可能會同時某一段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。線程安全就是說多線程訪問同一段代碼不會產生不確定的結果。編寫線程安全的代碼依靠線程同步。

線程間的同步：

　　如果變量只讀時，多個線程同時讀取該變量不會有一致性問題，但是，當一個線程可以修改的變量，其他線程也可以讀取或者修改的時候，我們就需要對這些線程進行同步，確保它們在訪問變量的存儲內容時不會訪問到無效的值。

 1. 互斥鎖

　　互斥量本質上說是一把鎖，在訪問共享資源前對互斥量進行加鎖，在訪問完成后釋放互斥量。對互斥量進行枷鎖以后，其他視圖再次對互斥量加鎖的線程都會被阻塞直到當前線程釋放該互斥鎖。如果釋放互斥量時有一個以上的線程阻塞，那么所有該鎖上的阻塞線程都會變成可運行狀態，第一個變成運行狀態的線程可以對互斥量加鎖，其他線程就會看到互斥量依然是鎖着，只能再次阻塞等待它重新變成可用，這樣，一次只有一個線程可以向前執行。

常用頭文件：

#include <pthread.h>

常用函數：

　　int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);//互斥初始化

　　int pthread_mutex_destroy(pthread_mutex_t *mutex);//銷毀互斥

　　int pthread_mutex_lock(pthread_mutex_t *mutex);//鎖定互斥

　　int pthread_mutex_unlock(pthread_mutex_t *mutex);//解鎖互斥

　　int pthread_mutex_trylock(pthread_mutex_t *mutex);//銷毀互斥

　　eg.pthread_t mutex;

　　pthread_mutex_init(&mutex, NULL);

　　pthread_mutex_lock(&mutex);

　　...

　　pthread_mutex_unlock(&mutex);

　　pthread_mutex_detroy(&mutex);

互斥量的死鎖:

　　一個線程需要訪問兩個或者更多不同的共享資源，而每個資源又有不同的互斥量管理。當超過一個線程加鎖同一組互斥量時，就可能發生死鎖。死鎖就是指多個線程/進程因競爭資源而造成的一種僵局（相互等待），若無外力作用，這些進程都將無法向前推進。

死鎖的處理策略：

1、預防死鎖：破壞死鎖產生的四個條件：互斥條件、不剝奪條件、請求和保持條件以及循環等待條件。

2、避免死鎖：在每次進行資源分配前，應該計算此次分配資源的安全性，如果此次資源分配不會導致系統進入不安全狀態，那么將資源分配給進程，否則等待。算法：銀行家算法。

3、檢測死鎖：檢測到死鎖后通過資源剝奪、撤銷進程、進程回退等方法解除死鎖。

 2. 讀寫鎖

　　讀寫鎖與互斥量類似，不過讀寫鎖擁有更高的並行性。互斥量要么是鎖住狀態，要么是不加鎖狀態，而且一次只有一個線程可以對其加鎖。讀寫鎖有3種狀態：讀模式下加鎖狀態，寫模式下加鎖狀態，不加鎖狀態。一次只有一個線程可以占有寫模式的讀寫鎖，但是多個線程可以同時占有讀模式的讀寫鎖。/* 讀寫鎖有3種狀態：讀模式下加鎖狀態，寫模式下加鎖狀態，不加鎖態。一次只有一個線程可以占有寫模式的讀寫鎖，但是多個線程可以同時占有讀模式的讀寫鎖。*/

　　當讀寫鎖是寫加鎖狀態時，在這個鎖被解鎖之前，所有試圖對這個鎖加鎖的線程都會被阻塞。當讀寫鎖在讀加鎖狀態時，所有試圖以讀模式對它進行加鎖的線程都可以得到訪問權，但是任何希望以寫模式對此鎖進行加鎖的線程都會阻塞，直到所有的線程釋放它們的讀鎖為止。

常用頭文件：

#include <pthread.h>

常用函數：

　　int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *rwlockattr);//初始化讀寫鎖

　　int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);//銷毀讀寫鎖

　　int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);//讀模式鎖定讀寫鎖

　　int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);//寫模式鎖定讀寫鎖

　　int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);//解鎖讀寫鎖

　　eg.pthread_rwlock_t q_lock;

　　pthread_rwlock_init(&q_lock, NULL);

　　pthread_rwlock_rdlock(&q_lock);

　　...

　　pthread_rwlock_unlock(&q_lock);

　　pthread_rwlock_detroy(&q_lock);

3. 條件變量

　　條件變量是線程可用的另一種同步機制。互斥量用於上鎖，條件變量則用於等待，並且條件變量總是需要與互斥量一起使用，運行線程以無競爭的方式等待特定的條件發生。/* 運行線程以無競爭的方式等待特定的條件發生；無競爭的方式等待是什么意思？*/

　　條件變量本身是由互斥量保護的，線程在改變條件變量之前必須首先鎖住互斥量。其他線程在獲得互斥量之前不會察覺到這種變化，因為互斥量必須在鎖定之后才能計算條件。/*互斥量必須在鎖定之后才能計算條件*/

常用頭文件：

#include <pthread.h>

常用函數：

　　int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);//初始化條件變量

　　int pthread_cond_destroy(pthread_cond_t *cond);//銷毀條件變量

　　int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);//無條件等待條件變量變為真

　　int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *tsptr);//在給定時間內，等待條件變量變為真

　　eg.pthread_mutex_t mutex;

　　pthread_cond_t cond;

　　...

　　pthread_mutex_lock(&mutex);

　　pthread_cond_wait(&cond, &mutex);

　　...

　　pthread_mutex_unlock(&mutex);

　　...

　　注意：  pthread_cond_wait 執行的流程首先將這個mutex解鎖, 然后等待條件變量被喚醒, 如果沒有被喚醒, 該線程將一直休眠, 也就是說, 該線程將一直阻塞在這個pthread_cond_wait調用中, [A1] 而當此線程被喚醒時, 將自動將這個mutex加鎖，然后再進行條件變量判斷（原因是“驚群效應”，如果是多個線程都在等待這個條件，而同時只能有一個線程進行處理，此時就必須要再次條件判斷，以使只有一個線程進入臨界區處理。），如果滿足，則線程繼續執行。/*pthread_cond_wait 執行的流程首先將這個mutex解鎖，然后等待條件變量被喚醒，如果沒有被喚醒，該線程將一直休眠，也就是說，該線程將一直阻塞在這個pthread_cond_wait調用中。*/

4. 信號量

　　線程的信號和進程的信號量類似，使用線程的信號量可以高效地完成基於線程的資源計數。信號量實際上是一個非負的整數計數器，用來實現對公共資源的控制。在公共資源增加的時候，信號量就增加；公共資源減少的時候，信號量就減少；只有當信號量的值大於0的時候，才能訪問信號量所代表的公共資源。[A1] /* 在公共資源增加的時候，信號量就增加；公共資源減少的時候，信號量就減少；只有當信號量的值大於0的時候，才能訪問信號量所代表的公共資源。*/

常用頭文件：

#include <semaphore.h>

常用函數：

　　sem_t sem_event;

　　int sem_init(sem_t *sem, int pshared, unsigned int value);//初始化一個信號量

　　int sem_destroy(sem_t * sem);//銷毀信號量

　　int sem_post(sem_t * sem);//信號量增加1

　　int sem_wait(sem_t * sem);//信號量減少1

　　int sem_getvalue(sem_t * sem, int * sval);//獲取當前信號量的值 

互斥與同步的區別：

　　互斥：是指某一資源同時只允許一個訪問者對其進行訪問，具有唯一性和排它性。但互斥無法限制訪問者對資源的訪問順序，即訪問是無序的。

　　同步：主要是流程上的概念，是指在互斥的基礎上（大多數情況），通過其它機制實現訪問者對資源的有序訪問。在大多數情況下，同步已經實現了互斥，特別是所有寫入資源的情況必定是互斥的。少數情況是指可以允許多個訪問者同時訪問資源。

 

互斥鎖、條件變量和信號量的區別：

　　互斥鎖：互斥，一個線程占用了某個資源，那么其它的線程就無法訪問，直到這個線程解鎖，其它線程才可以訪問。

　　條件變量：同步，一個線程完成了某一個動作就通過條件變量發送信號告訴別的線程，別的線程再進行某些動作。條件變量必須和互斥鎖配合使用。

　　信號量：同步，一個線程完成了某一個動作就通過信號量告訴別的線程，別的線程再進行某些動作。而且信號量有一個更加強大的功能，信號量可以用作為資源計數器，把信號量的值初始化為某個資源當前可用的數量，使用一個之后遞減，歸還一個之后遞增。

 

另外還有以下幾點需要注意：

　　1、信號量可以模擬條件變量，因為條件變量和互斥量配合使用，相當於信號量模擬條件變量和互斥量的組合。在生產者消費者線程池中，生產者生產數據后就會發送一個信號 pthread_cond_signal通知消費者線程，消費者線程通過pthread_cond_wait等待到了信號就可以繼續執行。這是用條件變量和互斥鎖實現生產者消費者線程的同步，用信號量一樣可以實現！

　　2、信號量可以模擬互斥量，因為互斥量只能為加鎖或解鎖（0 or 1），信號量值可以為非負整數，也就是說，一個互斥量只能用於一個資源的互斥訪問，它不能實現多個資源的多線程互斥問題。信號量可以實現多個同類資源的多線程互斥和同步。當信號量為單值信號量時，就完成一個資源的互斥訪問。前面說了，信號量主要用做多線程多任務之間的同步，而同步能夠控制線程訪問的流程，當信號量為單值時，必須有線程釋放，其他線程才能獲得，同一個時刻只有一個線程在運行（注意，這個運行不一定是訪問資源，可能是計算）。如果線程是在訪問資源，就相當於實現了對這個資源的互斥訪問。

　　3、互斥鎖是為上鎖而優化的；條件變量是為等待而優化的； 信號量既可用於上鎖，也可用於等待，因此會有更多的開銷和更高的復雜性。

　　4、互斥鎖，條件變量都只用於同一個進程的各線程間，而信號量（有名信號量）可用於不同進程間的同步。當信號量用於進程間同步時，要求信號量建立在共享內存區。

　　5、互斥量必須由同一線程獲取以及釋放，信號量和條件變量則可以由一個線程釋放，另一個線程得到。

　　6、信號量的遞增和減少會被系統自動記住，系統內部的計數器實現信號量，不必擔心丟失，而喚醒一個條件變量時，如果沒有相應的線程在等待該條件變量，此次喚醒會被丟失。

5. 自旋鎖

　　自旋鎖與互斥量類似，但它不是通過休眠使進程阻塞，而是在獲取鎖之前一直處於忙等（自旋）阻塞狀態。自旋鎖可以用於以下情況：鎖被持有的時間短，而且線程並不希望在重新調度上花費太多的成本。

6. 屏障

　　屏障是指用戶可以協調多個線程並行工作的同步機制。屏障允許每個線程等待，直到所有的合作線程都到達某一點，然后從改點繼續執行。

還記pthread_join函數嗎？在子線程退出之前，主線程要一直等待。pthread_join函數就是一種屏障，它允許一個線程等待，直到另一個線程退出。屏障允許任意數量的線程等待，直到所有的線程完成處理工作，而線程不需要退出。所有線程達到屏障后可以接着工作。

　　如果我們要讓主線程在所有工作線程完成之后再做某項任務，一般把屏障計數值設為工作線程數加1，主線程也作為其中一個候選線程。

 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Linux進程間通信與線程間同步詳解（全面詳細）

linux下進程間通信的幾種主要手段簡介：

   　　1. 管道（Pipe）及有名管道（named pipe）：管道可用於具有親緣關系進程間的通信，有名管道克服了管道沒有名字的限制，因此，除具有管道所具有的功能外，它還允許無親緣關系進程間的通信；[A1] /* 管道（pipe）用於具有親緣關系進程的通信;有名管道（name pipe）除具有管道所具有的功能外，還允許無親緣關系進程間的通信。*/

  　　2. 信號（Signal）：信號是比較復雜的通信方式，用於通知接受進程有某種事件發生，除了用於進程間通信外，進程還可以發送信號給進程本身；linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標准的信號函數 sigaction（實際上，該函數是基於BSD的，BSD為了實現可靠信號機制，又能夠統一對外接口，用sigaction函數重新實現了signal 函數）；

   　　3. 報文（Message）隊列（消息隊列）：消息隊列是消息的鏈接表，包括Posix消息隊列system V消息隊列。有足夠權限的進程可以向隊列中添加消息，被賦予讀權限的進程則可以讀走隊列中的消息。消息隊列克服了信號承載信息量少，管道只能承載無格式字節流以及緩沖區大小受限等缺點。

   　　4. 共享內存：使得多個進程可以訪問同一塊內存空間，是最快的可用IPC形式。是針對其他通信機制運行效率較低而設計的。往往與其它通信機制，如信號量結合使用，來達到進程間的同步及互斥。

   　　5. 信號量（semaphore）：主要作為進程間以及同一進程不同線程之間的同步手段。

   　　6. 套接口（Socket）：更為一般的進程間通信機制，可用於不同機器之間的進程間通信。起初是由Unix系統的BSD分支開發出來的，但現在一般可以移植到其它類Unix系統上：Linux和System V的變種都支持套接字。

線程的最大特點是資源的共享性，但資源共享中的同步問題是多線程編程的難點。linux下提供了多種方式來處理線程同步，最常用的是互斥鎖、條件變量和信號量。

1）互斥鎖（mutex）

    通過鎖機制實現線程間的同步。同一時刻只允許一個線程執行一個關鍵部分的代碼。

　　int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_attr_t *mutexattr);

　　int pthread_mutex_lock(pthread_mutex *mutex);

　　int pthread_mutex_destroy(pthread_mutex *mutex);

　　int pthread_mutex_unlock(pthread_mutex *

(1)先初始化鎖init()或靜態賦值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER

attr_t有:

　　PTHREAD_MUTEX_TIMED_NP:其余線程等待隊列

　　PTHREAD_MUTEX_RECURSIVE_NP:嵌套鎖,允許線程多次加鎖,不同線程,解鎖后重新競爭

　　PTHREAD_MUTEX_ERRORCHECK_NP:檢錯,與一同,線程請求已用鎖,返回EDEADLK;

　　PTHREAD_MUTEX_ADAPTIVE_NP:適應鎖,解鎖后重新競爭

(2)加鎖,lock,trylock,lock阻塞等待鎖,trylock立即返回EBUSY

(3)解鎖,unlock需滿足是加鎖狀態,且由加鎖線程解鎖

(4)清除鎖,destroy(此時鎖必需unlock,否則返回EBUSY,//Linux下互斥鎖不占用內存資源

示例代碼

#include <cstdio>

#include <cstdlib>

#include <unistd.h>

#include <pthread.h>

#include "iostream"

using namespace std;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int tmp;

void* thread(void *arg)

{

    cout << "thread id is " << pthread_self() << endl;

    pthread_mutex_lock(&mutex);

    tmp = 12;

    cout << "Now a is " << tmp << endl;

    pthread_mutex_unlock(&mutex);

    return NULL;

}

int main()

{

    pthread_t id;

    cout << "main thread id is " << pthread_self() << endl;

    tmp = 3;

    cout << "In main func tmp = " << tmp << endl;

    if (!pthread_create(&id, NULL, thread, NULL))

    {

        cout << "Create thread success!" << endl;

    }

    else

    {

        cout << "Create thread failed!" << endl;

    }

    pthread_join(id, NULL);

    pthread_mutex_destroy(&mutex);

    return 0;

}

編譯： g++ -o thread testthread.cpp -lpthread

說明：pthread庫不是Linux系統默認的庫，連接時需要使用靜態庫libpthread.a，所以在使用pthread_create()創建線程，以及調用pthread_atfork()函數建立fork處理程序時，需要鏈接該庫。在編譯中要加 -lpthread參數。[A1] /*線程處理函數是什么時候調用？*/

2）條件變量（cond）

    利用線程間共享的全局變量進行同步的一種機制。條件變量上的基本操作有：觸發條件(當條件變為 true 時)；等待條件，掛起線程直到其他線程觸發條件。

　　int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);  

　　int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);

　　int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);

　　int pthread_cond_destroy(pthread_cond_t *cond);

　　int pthread_cond_signal(pthread_cond_t *cond);

　　int pthread_cond_broadcast(pthread_cond_t *cond);  //解除所有線程的阻塞

　　(1)初始化.init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER（前者為動態初始化，后者為靜態初始化）;屬性置為NULL

　　(2)等待條件成立.pthread_wait,pthread_timewait.wait()釋放鎖,並阻塞等待條件變量為真，timewait()設置等待時間,仍未signal,返回ETIMEOUT(加鎖保證只有一個線程wait)

　　(3)激活條件變量:pthread_cond_signal,pthread_cond_broadcast(激活所有等待線程)

　　(4)清除條件變量:destroy;無線程等待,否則返回EBUSY

對於

　　int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

　　int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

一定要在mutex的鎖定區域內使用。

 　　如果要正確的使用pthread_mutex_lock與pthread_mutex_unlock，請參考

pthread_cleanup_push和pthread_cleanup_pop宏，它能夠在線程被cancel的時候正確的釋放mutex！

　　另外，posix1標准說，pthread_cond_signal與pthread_cond_broadcast無需考慮調用線程是否是mutex的擁有者，也就是說，可以在lock與unlock以外的區域調用。如果我們對調用行為不關心，那么請在lock區域之外調用吧。

說明：

　　(1)pthread_cond_wait 自動解鎖互斥量(如同執行了pthread_unlock_mutex)，並等待條件變量觸發。這時線程掛起，不占用CPU時間，直到條件變量被觸發（變量為ture）。在調用 pthread_cond_wait之前，應用程序必須加鎖互斥量。pthread_cond_wait函數返回前，自動重新對互斥量加鎖(如同執行了pthread_lock_mutex)。

 　  (2)互斥量的解鎖和在條件變量上掛起都是自動進行的。因此，在條件變量被觸發前，如果所有的線程都要對互斥量加鎖，這種機制可保證在線程加鎖互斥量和進入等待條件變量期間，條件變量不被觸發。條件變量要和互斥量相聯結，以避免出現條件競爭——個線程預備等待一個條件變量，當它在真正進入等待之前，另一個線程恰好觸發了該條件（條件滿足信號有可能在測試條件和調用pthread_cond_wait函數（block）之間被發出，從而造成無限制的等待）。

      (3)pthread_cond_timedwait 和 pthread_cond_wait 一樣，自動解鎖互斥量及等待條件變量，但它還限定了等待時間。如果在abstime指定的時間內cond未觸發，互斥量mutex被重新加鎖，且pthread_cond_timedwait返回錯誤 ETIMEDOUT。abstime 參數指定一個絕對時間，時間原點與 time 和 gettimeofday 相同：abstime = 0 表示 1970年1月1日00:00:00 GMT。

     (4)pthread_cond_destroy 銷毀一個條件變量，釋放它擁有的資源。進入 pthread_cond_destroy 之前，必須沒有在該條件變量上等待的線程。

     (5)條件變量函數不是異步信號安全的，不應當在信號處理程序中進行調用。特別要注意，如果在信號處理程序中調用 pthread_cond_signal 或pthread_cond_boardcast 函數，可能導致調用線程死鎖。

示例程序1

#include <stdio.h>

#include <pthread.h>

#include "stdlib.h"

#include "unistd.h"

pthread_mutex_t mutex;

pthread_cond_t cond;

void hander(void *arg)

{

    free(arg);

    (void)pthread_mutex_unlock(&mutex);

}

void *thread1(void *arg)

{

     pthread_cleanup_push(hander, &mutex);

     while(1)

     {

         printf("thread1 is running\n");

         pthread_mutex_lock(&mutex);

         pthread_cond_wait(&cond,&mutex);

         printf("thread1 applied the condition\n");

         pthread_mutex_unlock(&mutex);

         sleep(4);

     }

     pthread_cleanup_pop(0);

}

void *thread2(void *arg)

{

    while(1)

    {

        printf("thread2 is running\n");

        pthread_mutex_lock(&mutex);

        pthread_cond_wait(&cond,&mutex);

        printf("thread2 applied the condition\n");

        pthread_mutex_unlock(&mutex);

        sleep(1);

    }

}

int main()

{

     pthread_t thid1,thid2;

     printf("condition variable study!\n");

     pthread_mutex_init(&mutex,NULL);

     pthread_cond_init(&cond,NULL);

     pthread_create(&thid1,NULL,thread1,NULL);

     pthread_create(&thid2,NULL,thread2,NULL);

     sleep(1);

     do

     {

         pthread_cond_signal(&cond);

     }while(1);

     sleep(20);

     pthread_exit(0);

     return 0;

}

示例程序2：

#include <pthread.h>

#include <unistd.h>

#include "stdio.h"

#include "stdlib.h"

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

struct node

{

     int n_number;

     struct node *n_next;

} *head = NULL;

/*[thread_func]*/

static void cleanup_handler(void *arg)

{

     printf("Cleanup handler of second thread./n");

     free(arg);

     (void)pthread_mutex_unlock(&mtx);

}

static void *thread_func(void *arg)

{

     struct node *p = NULL;

     pthread_cleanup_push(cleanup_handler, p);

     while (1)

     {

         //這個mutex主要是用來保證pthread_cond_wait的並發性

         pthread_mutex_lock(&mtx);

         while (head == NULL)

        {

        //這個while要特別說明一下，單個pthread_cond_wait功能很完善，為何

        //這里要有一個while (head == NULL)呢？因為pthread_cond_wait里的線

        //程可能會被意外喚醒，如果這個時候head != NULL，則不是我們想要的情況。

        //這個時候，應該讓線程繼續進入pthread_cond_wait

        // pthread_cond_wait會先解除之前的pthread_mutex_lock鎖定的mtx，

        //然后阻塞在等待對列里休眠，直到再次被喚醒（大多數情況下是等待的條件成立

        //而被喚醒，喚醒后，該進程會先鎖定先pthread_mutex_lock(&mtx);，再讀取資源

        //用這個流程是比較清楚的/*block-->unlock-->wait() return-->lock*/

         pthread_cond_wait(&cond, &mtx);

         p = head;

         head = head->n_next;

         printf("Got %d from front of queue/n", p->n_number);

         free(p);

       }

          pthread_mutex_unlock(&mtx); //臨界區數據操作完畢，釋放互斥鎖

     }

     pthread_cleanup_pop(0);

     return 0;

}

int main(void)

{

     pthread_t tid;

     int i;

     struct node *p;

     //子線程會一直等待資源，類似生產者和消費者，但是這里的消費者可以是多個消費者，而不僅僅支持普通的單個消費者，這個模型雖然簡單，但是很強大

     pthread_create(&tid, NULL, thread_func, NULL);

     sleep(1);

     for (i = 0; i < 10; i++)

     {

         p = (struct node*)malloc(sizeof(struct node));

         p->n_number = i;

         pthread_mutex_lock(&mtx); //需要操作head這個臨界資源，先加鎖，

         p->n_next = head;

         head = p;

         pthread_cond_signal(&cond);

         pthread_mutex_unlock(&mtx); //解鎖

         sleep(1);

     }

     printf("thread 1 wanna end the line.So cancel thread 2./n");

    

     //關於pthread_cancel，有一點額外的說明，它是從外部終止子線程，子線程會在最近的取消點，退出

     //線程，而在我們的代碼里，最近的取消點肯定就是pthread_cond_wait()了。

     pthread_cancel(tid);

     pthread_join(tid, NULL);

     printf("All done -- exiting/n");

     return 0;

}

3）信號量

　　如同進程一樣，線程也可以通過信號量來實現通信，雖然是輕量級的。

      信號量函數的名字都以"sem_"打頭。線程使用的基本信號量函數有四個。

#include <semaphore.h>

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

       這是對由sem指定的信號量進行初始化，設置好它的共享選項（linux 只支持為0，即表示它是當前進程的局部信號量），然后給它一個初始值VALUE。

兩個原子操作函數：

　　int sem_wait(sem_t *sem);

　　int sem_post(sem_t *sem);

       這兩個函數都要用一個由sem_init調用初始化的信號量對象的指針做參數。

sem_post：給信號量的值加1；

sem_wait:給信號量減1；對一個值為0的信號量調用sem_wait,這個函數將會等待直到有其它線程使它不再是0為止。

int sem_destroy(sem_t *sem);

    這個函數的作用是再我們用完信號量后都它進行清理。歸還自己占有的一切資源。

示例代碼：

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <pthread.h>

#include <semaphore.h>

#include <errno.h>  

#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}  

typedef struct _PrivInfo

{

  sem_t s1;

  sem_t s2;

  time_t end_time;

}PrivInfo;

   

static void info_init (PrivInfo* thiz);

static void info_destroy (PrivInfo* thiz);

static void* pthread_func_1 (PrivInfo* thiz);

static void* pthread_func_2 (PrivInfo* thiz);

   

int main (int argc, char** argv)

{

  pthread_t pt_1 = 0;

  pthread_t pt_2 = 0;

  int ret = 0;

  PrivInfo* thiz = NULL;

     

  thiz = (PrivInfo* )malloc (sizeof (PrivInfo));

  if (thiz == NULL)

  {

    printf ("[%s]: Failed to malloc priv./n");

    return -1;

  }

   

  info_init (thiz);

  ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);

  if (ret != 0)

  {

    perror ("pthread_1_create:");

  }

   

  ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);

  if (ret != 0)

  {

     perror ("pthread_2_create:");

  }

   

  pthread_join (pt_1, NULL);

  pthread_join (pt_2, NULL);

   

  info_destroy (thiz);

  return 0;

}

   

static void info_init (PrivInfo* thiz)

{

  return_if_fail (thiz != NULL);

  thiz->end_time = time(NULL) + 10;

  sem_init (&thiz->s1, 0, 1);

  sem_init (&thiz->s2, 0, 0);

  return;

}

   

static void info_destroy (PrivInfo* thiz)

{

  return_if_fail (thiz != NULL);

  sem_destroy (&thiz->s1);

  sem_destroy (&thiz->s2);

  free (thiz);

  thiz = NULL;

  return;

}

static void* pthread_func_1 (PrivInfo* thiz)

{

  return_if_fail (thiz != NULL);

  while (time(NULL) < thiz->end_time)

  {

    sem_wait (&thiz->s2);

    printf ("pthread1: pthread1 get the lock./n");

   

    sem_post (&thiz->s1);

    printf ("pthread1: pthread1 unlock/n");

   

    sleep (1);

  } 

  return;

}

static void* pthread_func_2 (PrivInfo* thiz)

{

  return_if_fail (thiz != NULL);

  while (time (NULL) < thiz->end_time)

  {

    sem_wait (&thiz->s1);

    printf ("pthread2: pthread2 get the unlock./n");

    sem_post (&thiz->s2);

    printf ("pthread2: pthread2 unlock./n");

   

    sleep (1);

  }

   

  return;

}

　　通過執行結果后，可以看出，會先執行線程二的函數，然后再執行線程一的函數。它們兩就實現了同步。在上大學的時候，雖然對這些概念知道，可都沒有實踐過，所以有時候時間一久就會模糊甚至忘記，到了工作如果還保持這么一種狀態，那就太可怕了。雖然現在外面的技術在不斷的變化更新，可是不管怎么變，其核心技術還是依舊的，所以我們必須要打好自己的基礎，再學習其他新的知識，那時候再學新的知識也會覺得比較簡單的。

轉自：https://blog.csdn.net/a987073381/article/details/52029070