第12章 執行緒控制

1.  執行緒屬性

執行緒屬性結構體：pthread_arrr_t

int pthread_attr_init(pthread_attr_t *attr);  //初始化執行緒屬性

int pthread_attr_destroy(pthread_attr_t*attr); //釋放屬性物件記憶體

執行緒屬性主要有：

（1）執行緒的分離狀態屬性detachstate，

（2）執行緒棧末尾的警戒緩衝區大小guardsize，

（3）執行緒棧的最低地址statckaddr，

（4）執行緒棧的大小stacksize。

其中常用的是分離狀態屬性：

int pthread_attr_getdetachstate

(pthread_attr_t*attr, int *detachstate);//獲取當前的分離狀態屬性

int pthread_attr_setdetachstate(pthread_attr_t*attr, intdetachstate); //設定分離狀態屬性

detatchstate取值：

(1)PTHREAD_CREATE_DETACHED分離狀態啟動，

(2)PTHREAD_CREATE_JOINABLE正常啟動，應用程式可以獲取執行緒的終止狀態。

2.  同步屬性

1)  互斥量屬性

程序共享屬性和型別屬性兩種

         i.             程序共享屬性

PTHREAD_PROCESS_PRIVATE，預設，程序間不共享，程序私有。用於程序中的執行緒同步。

PTHREAD_PROCESS_SHARED，程序間共享，用於程序的同步。

int pthread_mutexattr_init(pthread_mutexattr_t*attr);  //初始化

int pthread_mutexattr_destroy(pthread_mutexattr_t*attr); //回收

int pthread_mutexattr_getpshared(constpthread_mutexattr_t *restrictattr,int *restrictpshared);  //查詢程序共享屬性

int pthread_mutexattr_setpshared(pthread_mutexattr_t*attr

,intpshared); //設定程序共享屬性

       ii.             型別屬性

int pthread_mutexattr_gettype(constpthread_mutexattr_t *restrictattr,int*restricttype); //查詢型別屬性

int pthread_mutexattr_settype(pthread_mutexattr_t*attr, inttype); //設定型別屬性

互斥量型別	用途	沒有解鎖時再次加鎖	不佔用時解鎖	在已解鎖時解鎖
PTHREAD_MUTEX_NORMAL	標準型別，不做任何檢查	死鎖	未定義	未定義
PTHREAD_MUTEX_ERRORCHECK	程序錯誤檢查	返回錯誤	返回錯誤	返回錯誤
PTHREAD_MUTEX_RECURSIVE	避免死鎖	允許	返回錯誤	返回錯誤
PTHREAD_MUTEX_DEFFAULT	請求預設語義	未定義	未定義

PTHREAD_MUTEX_RECURSIVE型別：遞迴鎖，允許在同一個執行緒在互斥量解鎖之前對該互斥量程序多次加鎖，解鎖次數和加鎖次數不同時不會釋放鎖。

2)  讀寫鎖屬性

只有一個：程序共享屬性，與互斥量類似。

int pthread_rwlockattr_init(pthread_rwlockattr_t*attr);

int pthread_rwlockattr_destroy(pthread_rwlockattr_t*attr);

int pthread_rwlockattr_getpshared(constpthread_rwlockattr_t *restrict attr, int *restrict pshared);

int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*attr,int pshared);

3)  條件變數屬性

與讀寫鎖屬性類似。

3.  執行緒私有資料(執行緒區域性資料)

多執行緒程式設計時，遇到最多的就是多執行緒讀寫同一變數的問題，由於執行緒中的區域性變數只能在函式體內使用，不能跨函式使用，而執行緒的全域性變數又被程序內的所有執行緒所共享，因此存線上程資料安全的需求。大多情況下遇到這類問題都是通過鎖機制來處理，但這對程式的效能帶來了很大的影響。

在一個執行緒內部的各個函式呼叫都能訪問，但其它執行緒不能訪問的變數，稱之為執行緒特有資料（TSD: Thread-SpecificData）或者執行緒區域性儲存（TLS:Thread-Local Storage）。這一型別的資料，在程式中每個執行緒都會分別維護一份變數的副本，並且長期存在於該執行緒中，對此類變數的操作不影響其他執行緒。

其實現機制是：

程序內分配一個全域性陣列，陣列中的每個元素是一個結構體，其包含兩個變數：標記該鍵是否在用的標誌變數、執行緒區域性變數的解構函式的函式指標。當呼叫pthread_key_create()建立一個鍵時，得到的實際上是該陣列的一個索引值。系統根據“在用”標誌查詢一個未用的元素，將“在用”標誌置為used，然後存入該變數的解構函式指標，最後返回該陣列的索引值。

 

另外，在每個執行緒內，執行緒還分別維護一個數組，存放每個執行緒的執行緒特有資料塊的地址。pthreadAPI為每個函式都維護指向執行緒區域性資料塊的指標陣列，其中每個陣列元素都與程序內全域性pthread_keys中元素一一對應。當呼叫pthread_setspcific()函式時，將執行緒特有資料塊的指標放入與該Key相對應的陣列元素位置。這樣，也就將執行緒私有資料繫結（關聯）到了該鍵上。呼叫pthread_getspecific() 即可取出所儲存的資料。

表面上看起來這是一個全域性變數(Key)，所有執行緒都可以使用它，而它的值在每一個執行緒中又是單獨儲存的,都是各個執行緒私有的。

下面說一下執行緒私有資料的具體用法。

1)首先建立一個型別為pthread_key_t 型別的變數key。

int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));

第一個引數就是上面宣告的pthread_key_t 變數，

第二個引數是一個清理函式，用來線上程釋放該執行緒儲存的時候被呼叫。該函式指標可以設成 NULL，這樣系統將呼叫預設的清理函式。

2)當執行緒中需要儲存特殊值的時候，呼叫pthread_setspcific() 關聯私有資料。

int pthread_setspecific(pthread_key_tkey, const void *value);

第一個為前面宣告的pthread_key_t 變數key，

第二個為void* 變數，指向執行緒私有資料塊，可以儲存任何型別的值。

3)當需要使用私有資料時，呼叫 pthread_getspecific() 。

void *pthread_getspecific(pthread_key_tkey);

傳入引數為鍵，返回void* 型別指標，指向要使用的執行緒私有資料。因此若要使用該資料，還需要一個間接訪問操作。

4)呼叫pthread_key_delete函式取消鍵與私有資料的關聯。

int pthread_key_delete(pthread_key_tkey);

鍵所佔用的記憶體將被釋放。注意，與該鍵關聯的執行緒私有資料所佔用的記憶體並不被釋放。因此，執行緒資料的釋放必須在釋放鍵之前完成。

寫了一個小例子，定義了一個程序全域性變數，即鍵，建立了兩個執行緒，每個執行緒內各定義了一個執行緒私有資料tsd,線上程內可視為全域性變數，可被執行緒內所有函式使用，但線上程之間是區域性變數，是為執行緒所私有的。

#include"apue.h"

#include<pthread.h>

pthread_key_tmykey;//定義一個鍵，執行緒全域性可見

voidprint_tsd(void * arg)

{

int *tsd_p=(int*)pthread_getspecific(mykey);

printf("%sprint_tsd : %d\n",(char*)arg,*tsd_p);//列印執行緒區域性變數tsd的值

}

void* tid2_func(void * arg)

{

        printf("thread2 starting in %s ,tid= %d\n",(char*)arg,(int)pthread_self());

        int tsd=1;//執行緒2私有資料

        pthread_setspecific(mykey,&tsd);

        printf("tid2 tsd's arr is%ld\n",(long int)pthread_getspecific(mykey));

        print_tsd("thread2");

}

void* tid1_func(void * arg)

{

printf("thread1starting in %s , tid= %d\n",(char*)arg,(int)pthread_self());

int tsd=0;//執行緒1私有資料

pthread_setspecific(mykey,&tsd);//與鍵關聯

printf("tid1tsd's arr is %ld\n",(long int)pthread_getspecific(mykey));//列印區域性變數地址

print_tsd("thread1");//在另一個函式中列印執行緒區域性變數的值

}

voidmydestr(void* arg)

{

printf("destroyTSD memory\n");

}

intmain(void)

{

pthread_ttid1,tid2;

pthread_key_create(&mykey,mydestr);//建立鍵

pthread_create(&tid1,NULL,tid1_func,"tid1_func");

sleep(3);

pthread_create(&tid2,NULL,tid2_func,"tid2_func");

sleep(3);

pthread_join(tid1,NULL);

pthread_join(tid2,NULL);

pthread_key_delete(mykey);

exit(0);

}

 

4.  執行緒和IO

pread和pwrite函式

偏移量的設定和資料操作為原子操作，可以解決併發執行緒對同一檔案的讀寫操作問題。

5.  執行緒和訊號

訊號的處理時程序中所有執行緒共享的，當執行緒修改了與某個訊號相關的處理行為後，所有執行緒必須共享這個處理行為的改變。

多執行緒中的訊號機制，與程序的訊號機制有著根本的區別：

在程序環境中，對訊號的處理是：先註冊訊號處理函式，當訊號非同步發生時，呼叫處理函式來處理訊號。它完全是非同步的（我們完全不知道訊號會在程序的那個執行點到來！）。

在多執行緒中處理訊號的原則卻完全不同，它的基本原則是：將對訊號的非同步處理，轉換成同步處理，也就是說用一個執行緒專門的來“同步等待”訊號的到來，而其它的執行緒可以完全不被該訊號中斷/打斷(interrupt)。這樣就在相當程度上簡化了在多執行緒環境中對訊號的處理。而且可以保證其它的執行緒不受訊號的影響。這樣我們對訊號就可以完全預測，因為它不再是非同步的，而是同步的（我們完全知道訊號會在哪個執行緒中的哪個執行點到來而被處理！）。

每個執行緒都可以擁有自己的訊號遮蔽集，可以使用pthread_sigmask函式設定該執行緒的遮蔽訊號集。為防止訊號中斷執行緒，可以把訊號加到每個執行緒的訊號遮蔽字中，然後安排一個專用的執行緒作訊號處理。實現方式是：利用執行緒訊號遮蔽集的繼承關係（在主執行緒中使用pthread_sigmask進行設定後，主執行緒創建出來的執行緒將繼承主執行緒的掩碼）。

int pthread_sigmask (int how,const sigset_t *set,sigset_t *oset);//設定執行緒遮蔽字

成功返回0，出錯返回錯誤編號。

訊號處理執行緒可以呼叫sigwait等待指定訊號發生：

int sigwait(const sigset_t *set, int *sig);

成功返回0，出錯返回錯誤編號。

set指定執行緒等待的訊號集，sig返回發生的訊號值。

執行緒在呼叫sigwait之前，必須阻塞它正在等待的訊號，sigwait呼叫後會自動取消其阻塞狀態，然後執行緒掛起直到等待的訊號被遞送，然後函式在返回之前，重新恢復執行緒訊號遮蔽字。而如果呼叫sigwait之前沒有阻塞要等待的訊號，則有可能在sigwait呼叫之前的時間視窗內到來訊號。

在多執行緒程式中，一個執行緒可以使用pthread_kill對同一個程序中指定的執行緒（包括自己）傳送訊號。注意在多執行緒中一般不使用kill函式傳送訊號，因為kill是對程序傳送訊號，結果是：正在執行的執行緒會處理該訊號，如果該執行緒沒有

 註冊訊號處理函式，那麼會導致整個程序退出。

int pthread_kill(pthread_t thread, intsig);

例：執行緒訊號處理程式框架

#include“apue.h”

#include<pthread.h>

sigset_tmask;

void*sig_handler(void *arg)

{

       int sig;

       for( ; ; )

       {

       if(sigwait(&mask, &sig) != 0)

              err_sys(“sigwait error\n”);

       switch(sig)

       {

              case SIGINT:

              {

       /* SIGINT訊號處理語句 */

       printf(“SIGINT\n”);

       break;

}

caseSIGUSR1:

              {

       /* SIGUSR1訊號處理語句 */

       printf(“SIGUSR1\n”);

       break;

}

caseSIGUSR2:

              {

       /* SIGUSR2訊號處理語句 */

       printf(“SIGUSR2\n”);

       break;

}

default:

{

       /* 其他語句 */

       printf(“unexpected signal: %d\n”,sig);

       break;

}

}

}

}

intmain(void)

{

       sigset_t oldmask;

       pthread_t tid;

       sigemptyset(&mask);

       sigaddset(&mask,SIGINT);

       sigaddset(&mask,SIGUSR1);

       sigaddset(&mask,SIGUSR2);

       if(pthread_sigmask(SIG_BLOCK, &mask,&oldmask)!=0)//設定執行緒訊號遮蔽字

              err_sys(“pthread_sigmask error\n”);

       if(pthread_create(&tid, NULL,sig_handler,0)!=0)//建立訊號處理專用執行緒

              err_sys(“pthread_create error\n”);

       /* 其他程式碼：主執行緒主要執行語句 */

       sleep(30);

       if(sigprocmask(SIG_SETMASK, &oldmask,NULL)<0)

              err_sys(“sigprocmask error\n”);

       exit(0);

}