pthread多線程編程整理1 Introduction
不用介紹了吧…
2 Thread Concepts
1. Thread由下面部分組成：
a. ThreadID
b. Stack
c. Policy
d. Signalmask
e. Errno
f. Thread-SpecificData
3 Thread Identification
1. pthread_t用于表示Thread ID，具體內(nèi)容根據(jù)實現(xiàn)的不同而不同，有可能是一個Structure，因此不能將其看作為整數(shù)
2. pthread_equal函數(shù)用于比較兩個pthread_t是否相等
＃i nclude <pthread.h>
int pthread_equal(pthread_t tid1, pthread_t tid2)
3. pthread_self函數(shù)用于獲得本線程的thread id
＃i nclude <pthread.h>
pthread _t pthread_self(void);
4 Thread Creation
1. 創(chuàng)建線程可以調(diào)用pthread_create函數(shù)：
＃i nclude <pthread.h>
int pthread_create(
pthread_t *restrict tidp,
const pthread_attr_t *restrict attr,
void *(*start_rtn)(void *), void *restrict arg);
a. pthread_t*restrict tidp：返回最后創(chuàng)建出來的Thread的Thread ID
b. constpthread_attr_t *restrict attr：指定線程的Attributes，后面會講道，現(xiàn)在可以用NULL
c. void*(*start_rtn)(void *)：指定線程函數(shù)指針，該函數(shù)返回一個void *，參數(shù)也為void*
d. void*restrict arg：傳入給線程函數(shù)的參數(shù)
e. 返回錯誤值。
2. pthread函數(shù)在出錯的時候不會設置errno，而是直接返回錯誤值
3. 在Linux系統(tǒng)下面，在老的內(nèi)核中，由于Thread也被看作是一種特殊，可共享地址空間和資源的Process，因此在同一個Process中創(chuàng)建的不同Thread具有不同的Process ID（調(diào)用getpid獲得）。而在新的2.6內(nèi)核之中，Linux采用了NPTL(Native POSIXThread Library)線程模型（可以參考
http://en.wikipedia.org/wiki/Native_POSIX_Thread_Library和
http://www-128.ibm.com/developerworks/linux/library/l-threading.html?ca=dgr-lnxw07LinuxThreadsAndNPTL），在該線程模型下同一進程下不同線程調(diào)用getpid返回同一個PID。
4. 不能對創(chuàng)建的新線程和當前創(chuàng)建者線程的運行順序作出任何假設
5 Thread Termination
1. exit,_Exit, _exit用于中止當前進程，而非線程
2. 中止線程可以有三種方式：
a. 在線程函數(shù)中return
b. 被同一進程中的另外的線程Cancel掉
c. 線程調(diào)用pthread_exit函數(shù)
3. pthread_exit和pthread_join函數(shù)的用法：
a. 線程A調(diào)用pthread_join(B,&rval_ptr)，被Block，進入Detached狀態(tài)（如果已經(jīng)進入Detached狀態(tài)，則pthread_join函數(shù)返回EINVAL）。如果對B的結(jié)束代碼不感興趣，rval_ptr可以傳NULL。
b. 線程B調(diào)用pthread_exit(rval_ptr)，退出線程B，結(jié)束代碼為rval_ptr。注意rval_ptr指向的內(nèi)存的生命周期，不應該指向B的Stack中的數(shù)據(jù)。
c. 線程A恢復運行，pthread_join函數(shù)調(diào)用結(jié)束，線程B的結(jié)束代碼被保存到rval_ptr參數(shù)中去。如果線程B被Cancel，那么rval_ptr的值就是PTHREAD_CANCELLED。
兩個函數(shù)原型如下：
＃i nclude <pthread.h>
void pthread_exit(void *rval_ptr);
int pthread_join(pthread_t thread, void **rval_ptr);
4. 一個Thread可以要求另外一個Thread被Cancel，通過調(diào)用pthread_cancel函數(shù)：
＃i nclude <pthread.h>
void pthread_cancel(pthread_t tid)
該函數(shù)會使指定線程如同調(diào)用了pthread_exit(PTHREAD_CANCELLED)。不過，指定線程可以選擇忽略或者進行自己的處理，在后面會講到。此外，該函數(shù)不會導致Block，只是發(fā)送Cancel這個請求。
5. 線程可以安排在它退出的時候，某些函數(shù)自動被調(diào)用，類似atexit()函數(shù)。需要調(diào)用如下函數(shù)：
＃i nclude <pthread.h>
void pthread_cleanup_push(void (*rtn)(void *), void *arg);
void pthread_cleanup_pop(int execute);
這兩個函數(shù)維護一個函數(shù)指針的Stack，可以把函數(shù)指針和函數(shù)參數(shù)值push/pop。執(zhí)行的順序則是從棧頂?shù)綏５祝簿褪呛蚿ush的順序相反。
在下面情況下pthread_cleanup_push所指定的thread cleanup handlers會被調(diào)用：
a. 調(diào)用pthread_exit
b. 相應cancel請求
c. 以非0參數(shù)調(diào)用pthread_cleanup_pop()。（如果以0調(diào)用pthread_cleanup_pop()，那么handler不會被調(diào)用
有一個比較怪異的要求是，由于這兩個函數(shù)可能由宏的方式來實現(xiàn)，因此這兩個函數(shù)的調(diào)用必須得是在同一個Scope之中，并且配對，因為在pthread_cleanup_push的實現(xiàn)中可能有一個{，而 pthread_cleanup_pop可能有一個}。因此，一般情況下，這兩個函數(shù)是用于處理意外情況用的，舉例如下：
void *thread_func(void *arg)
{
pthread_cleanup_push(cleanup, “handler”)
// do something
Pthread_cleanup_pop(0);
return((void *)0)；
}
6. 進程函數(shù)和線程函數(shù)的相關性：
Process Primitive
Thread Primitive
Description
fork
pthread_create
創(chuàng)建新的控制流
exit
pthread_exit
退出已有的控制流
waitpid
pthread_join
等待控制流并獲得結(jié)束代碼
atexit
pthread_cleanup_push
注冊在控制流退出時候被調(diào)用的函數(shù)
getpid
pthread_self
獲得控制流的id
abort
pthread_cancel
請求非正常退出
7. 缺省情況下，一個線程A的結(jié)束狀態(tài)被保存下來直到pthread_join為該線程被調(diào)用過，也就是說即使線程A已經(jīng)結(jié)束，只要沒有線程B調(diào)用pthread_join(A)，A的退出狀態(tài)則一直被保存。而當線程處于Detached狀態(tài)之時，黨線程退出的時候，其資源可以立刻被回收，那么這個退出狀態(tài)也丟失了。在這個狀態(tài)下，無法為該線程調(diào)用pthread_join函數(shù)。我們可以通過調(diào)用pthread_detach函數(shù)來使指定線程進入Detach狀態(tài)：
＃i nclude <pthread.h>
int pthread_detach(pthread_t tid);
通過修改調(diào)用pthread_create函數(shù)的attr參數(shù)，我們可以指定一個線程在創(chuàng)建之后立刻就進入Detached狀態(tài)
6 Thread Synchronization
1. 互斥量：Mutex
a. 用于互斥訪問
b. 類型：pthread_mutex_t，必須被初始化為PTHREAD_MUTEX_INITIALIZER（用于靜態(tài)分配的mutex，等價于pthread_mutex_init(…,NULL)）或者調(diào)用pthread_mutex_init。Mutex也應該用pthread_mutex_destroy來銷毀。這兩個函數(shù)原型如下：（attr的具體含義下一章討論）
＃i nclude <pthread.h>
int pthread_mutex_init(
pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr)
int pthread_mutex_destroy(pthread_mutex_t *mutex);
c. pthread_mutex_lock用于Lock Mutex，如果Mutex已經(jīng)被Lock，該函數(shù)調(diào)用會Block直到Mutex被Unlock，然后該函數(shù)會LockMutex并返回。pthread_mutex_trylock類似，只是當Mutex被Lock的時候不會Block，而是返回一個錯誤值EBUSY。pthread_mutex_unlock則是unlock一個mutex。這三個函數(shù)原型如下：
＃i nclude <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
2. 讀寫鎖：Reader-Writer Locks
a. 多個線程可以同時獲得讀鎖(Reader-Writer lock in readmode)，但是只有一個線程能夠獲得寫鎖(Reader-writer lock in write mode)
b. 讀寫鎖有三種狀態(tài)
i. 一個或者多個線程獲得讀鎖，其他線程無法獲得寫鎖
ii. 一個線程獲得寫鎖，其他線程無法獲得讀鎖
iii. 沒有線程獲得此讀寫鎖
c. 類型為pthread_rwlock_t
d. 創(chuàng)建和關閉方法如下：
＃i nclude <pthread.h>
int pthread_rwlock_init(
pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr)
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
e. 獲得讀寫鎖的方法如下：
＃i nclude <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
pthread_rwlock_rdlock：獲得讀鎖
pthread_rwlock_wrlock：獲得寫鎖
pthread_rwlock_unlock：釋放鎖，不管是讀鎖還是寫鎖都是調(diào)用此函數(shù)
注意具體實現(xiàn)可能對同時獲得讀鎖的線程個數(shù)有限制，所以在調(diào)用 pthread_rwlock_rdlock的時候需要檢查錯誤值，而另外兩個pthread_rwlock_wrlock和pthread_rwlock_unlock則一般不用檢查，如果我們代碼寫的正確的話。
3. ConditionalVariable：條件
a. 條件必須被Mutex保護起來
b. 類型為：pthread_cond_t，必須被初始化為PTHREAD_COND_INITIALIZER（用于靜態(tài)分配的條件，等價于pthread_cond_init(…, NULL)）或者調(diào)用pthread_cond_init
＃i nclude <pthread.h>
int pthread_cond_init(
pthread_cond_t *restrict cond,
const pthread_condxattr_t *restrict attr)
int pthread_cond_destroy(pthread_cond_t *cond);
c. pthread_cond_wait函數(shù)用于等待條件發(fā)生（=true）。pthread_cond_timedwait類似，只是當?shù)却瑫r的時候返回一個錯誤值ETIMEDOUT。超時的時間用timespec結(jié)構(gòu)指定。此外，兩個函數(shù)都需要傳入一個Mutex用于保護條件
＃i nclude <pthread.h>
int pthread_cond_wait(
pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(
pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict timeout);
d. timespec結(jié)構(gòu)定義如下：
struct timespec {
time_t tv_sec; /* seconds */
long tv_nsec; /* nanoseconds */
};
注意timespec的時間是絕對時間而非相對時間，因此需要先調(diào)用gettimeofday函數(shù)獲得當前時間，再轉(zhuǎn)換成timespec結(jié)構(gòu)，加上偏移量。
e. 有兩個函數(shù)用于通知線程條件被滿足（=true）：
＃i nclude <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
兩者的區(qū)別是前者會喚醒單個線程，而后者會喚醒多個線程。
在傳統(tǒng)的Unix模型中，當一個進程需要由另一個實體執(zhí)行某件事時，該進程派生（fork）一個子進程，讓子進程去進行處理。Unix下的大多數(shù)網(wǎng)絡服務器程序都是這么編寫的，即父進程接受連接，派生子進程，子進程處理與客戶的交互。
雖然這種模型很多年來使用得很好，但是fork時有一些問題：
1.fork是昂貴的。內(nèi)存映像要從父進程拷貝到子進程，所有描述字要在子進程中復制等等。目前有的Unix實現(xiàn)使用一種叫做寫時拷貝（copy－on－write）的技術，可避免父進程數(shù)據(jù)空間向子進程的拷貝。盡管有這種優(yōu)化技術，fork仍然是昂貴的。
2.fork子進程后，需要用進程間通信（IPC）在父子進程之間傳遞信息。Fork之前的信息容易傳遞，因為子進程從一開始就有父進程數(shù)據(jù)空間及所有描述字的拷貝。但是從子進程返回信息給父進程需要做更多的工作。
線程有助于解決這兩個問題。線程有時被稱為輕權進程（lightweight process），因為線程比進程“輕權”，一般來說，創(chuàng)建一個線程要比創(chuàng)建一個進程快10～100倍。
一個進程中的所有線程共享相同的全局內(nèi)存，這使得線程很容易共享信息，但是這種簡易性也帶來了同步問題。
一個進程中的所有線程不僅共享全局變量，而且共享：進程指令、大多數(shù)數(shù)據(jù)、打開的文件（如描述字）、信號處理程序和信號處置、當前工作目錄、用戶ID和組ID。但是每個線程有自己的線程ID、寄存器集合（包括程序計數(shù)器和棧指針）、棧（用于存放局部變量和返回地址）、error、信號掩碼、優(yōu)先級。在Linux中線程編程符合Posix.1標準，稱為Pthreads。所有的pthread函數(shù)都以pthread_開頭。以下先講述5個基本線程函數(shù)，在調(diào)用它們前均要包括pthread.h頭文件。然后再給出用它們編寫的一個TCP客戶/服務器程序例子。
第一個函數(shù)：
int pthread_create (pthread_t ＊tid,const pthread_attr_t ＊attr,void ＊ (＊func)(void ＊),void ＊arg)；
一個進程中的每個線程都由一個線程ID（threadID）標識，其數(shù)據(jù)類型是pthread_t（常常是unsigned int）。如果新的線程創(chuàng)建成功，其ID將通過tid指針返回。
每個線程都有很多屬性：優(yōu)先級、起始棧大小、是否應該是一個守護線程等等，當創(chuàng)建線程時，我們可通過初始化一個pthread_attr_t變量說明這些屬性以覆蓋缺省值。我們通常使用缺省值，在這種情況下，我們將attr參數(shù)說明為空指針。
最后，當創(chuàng)建一個線程時，我們要說明一個它將執(zhí)行的函數(shù)。線程以調(diào)用該函數(shù)開始，然后或者顯式地終止（調(diào)用pthread_exit）或者隱式地終止（讓該函數(shù)返回）。函數(shù)的地址由func參數(shù)指定，該函數(shù)的調(diào)用參數(shù)是一個指針arg，如果我們需要多個調(diào)用參數(shù)，我們必須將它們打包成一個結(jié)構(gòu)，然后將其地址當作唯一的參數(shù)傳遞給起始函數(shù)。
在func和arg的聲明中，func函數(shù)取一個通用指針（void ＊）參數(shù)，并返回一個通用指針（void＊），這就使得我們可以傳遞一個指針（指向任何我們想要指向的東西）給線程，由線程返回一個指針（同樣指向任何我們想要指向的東西）。調(diào)用成功，返回0，出錯時返回正Exxx值。Pthread函數(shù)不設置errno。
第二個函數(shù)：
int pthread_join(pthread_t tid,void ＊＊status);
該函數(shù)等待一個線程終止。把線程和進程相比，pthread_creat類似于fork，而pthread_join類似于waitpid。我們必須要等待線程的tid，很可惜，我們沒有辦法等待任意一個線程結(jié)束。如果status指針非空，線程的返回值（一個指向某個對象的指針）將存放在status指向的位置。
第三個函數(shù)：
pthread_t pthread_self(void);
線程都有一個ID以在給定的進程內(nèi)標識自己。線程ID由pthread_creat返回，我們可以pthread_self取得自己的線程ID。
第四個函數(shù)：
int pthread_detach(pthread_t tid);
線程或者是可匯合的（joinable）或者是脫離的（detached）。當可匯合的線程終止時，其線程ID和退出狀態(tài)將保留，直到另外一個線程調(diào)用pthread_join。脫離的線程則像守護進程：當它終止時，所有的資源都釋放，我們不能等待它終止。如果一個線程需要知道另一個線程什么時候終止，最好保留第二個線程的可匯合性。Pthread_detach函數(shù)將指定的線程變?yōu)槊撾x的。該函數(shù)通常被想脫離自己的線程調(diào)用，如：pthread_detach(pthread_self ( ));
第五個函數(shù)：
void pthread_exit(void ＊status);
該函數(shù)終止線程。如果線程未脫離，其線程ID和退出狀態(tài)將一直保留到調(diào)用進程中的某個其他線程調(diào)用pthread_join函數(shù)。指針status不能指向局部于調(diào)用線程的對象，因為線程終止時這些對象也消失。有兩種其他方法可使線程終止：
1.啟動線程的函數(shù)（pthread_creat的第3個參數(shù)）返回。既然該函數(shù)必須說明為返回一個void指針，該返回值便是線程的終止狀態(tài)。
2.如果進程的main函數(shù)返回或者任何線程調(diào)用了exit，進程將終止，線程將隨之終止。
一.pthread_create()之前的屬性設置
1．線程屬性設置
我們用pthread_create函數(shù)創(chuàng)建一個線程，在這個線程中，我們使用默認參數(shù)，即將該函數(shù)的第二個參數(shù)設為NULL。的確，對大多數(shù)程序來說，使用默認屬性就夠了，但我們還是有必要來了解一下線程的有關屬性。
屬性結(jié)構(gòu)為pthread_attr_t，它同樣在頭文件pthread.h中定義，屬性值不能直接設置，須使用相關函數(shù)進行操作，初始化的函數(shù)為
pthread_attr_init，這個函數(shù)必須在pthread_create函數(shù)之前調(diào)用。屬性對象主要包括是否綁定、是否分離、
堆棧地址、堆棧大小、優(yōu)先級。默認的屬性為非綁定、非分離、缺省的堆棧、與父進程同樣級別的優(yōu)先級。
2．綁定
關于線程的綁定，牽涉到另外一個概念：輕進程（LWP：Light WeightProcess）。輕進程可以理解為內(nèi)核線程，它位于用戶層和系統(tǒng)層之間。系統(tǒng)對線程資源的分配、對線程的控制是通過輕進程來實現(xiàn)的，一個輕進程可以控制一個或多個線程。默認狀況下，啟動多少輕進程、哪些輕進程來控制哪些線程是由系統(tǒng)來控制的，這種狀況即稱為非綁定的。綁定狀況下，則顧名思義，即某個線程固定的"綁"在一個輕進程之上。被綁定的線程具有較高的響應速度，這是因為CPU時間片的調(diào)度是面向輕進程的，綁定的線程可以保證在需要的時候它總有一個輕進程可用。通過設置被綁定的輕進程的優(yōu)先級和調(diào)度級可以使得綁定的線程滿足諸如實時反應之類的要求。
設置線程綁定狀態(tài)的函數(shù)為pthread_attr_setscope，它有兩個參數(shù)，第一個是指向?qū)傩越Y(jié)構(gòu)的指針，第二個是綁定類型，它有兩個取值：PTHREAD_SCOPE_SYSTEM（綁定的）和PTHREAD_SCOPE_PROCESS（非綁定的）。下面的代碼即創(chuàng)建了一個綁定的線程。
＃include <pthread.h>
pthread_attr_t attr;
pthread_t tid;
/*初始化屬性值，均設為默認值*/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr,PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, (void *)my_function, NULL);
3．線程分離狀態(tài) 線程的分離狀態(tài)決定一個線程以什么樣的方式來終止自己。非分離的線程終止時，其線程ID和退出狀態(tài)將保留，直到另外一個線程調(diào)用pthread_join.分離的線程在當它終止時，所有的資源將釋放，我們不能等待它終止。 設置線程分離狀態(tài)的函數(shù)為 pthread_attr_setdetachstate（pthread_attr_t *attr, intdetachstate）。第二個參數(shù)可選為PTHREAD_CREATE_DETACHED（分離線程）和 PTHREAD_CREATE_JOINABLE（非分離線程）。這里要注意的一點是，如果設置一個線程為分離線程，而這個線程運行又非常快，它很可能在pthread_create函數(shù)返回之前就終止了，它終止以后就可能將線程號和系統(tǒng)資源移交給其他的線程使用，這樣調(diào)用pthread_create的線程就得到了錯誤的線程號。要避免這種情況可以采取一定的同步措施，最簡單的方法之一是可以在被創(chuàng)建的線程里調(diào)用pthread_cond_timewait函數(shù)，讓這個線程等待一會兒，留出足夠的時間讓函數(shù)pthread_create返回。設置一段等待時間，是在多線程編程里常用的方法。
4．優(yōu)先級 它存放在結(jié)構(gòu)sched_param中。用函數(shù)pthread_attr_getschedparam和函數(shù)pthread_attr_setschedparam進行存放，一般說來，我們總是先取優(yōu)先級，對取得的值修改后再存放回去。下面即是一段簡單的例子。
＃include <pthread.h>
＃i nclude <sched.h>
pthread_attr_tattr; pthread_t tid;
sched_param param;
int newprio=20;
/*初始化屬性*/
pthread_attr_init(&attr);
/*設置優(yōu)先級*/
pthread_attr_getschedparam(&attr,¶m);
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr,¶m);
pthread_create(&tid, &attr, (void *)myfunction,myarg);
二．線程數(shù)據(jù)處理 和進程相比，線程的最大優(yōu)點之一是數(shù)據(jù)的共享性，各個進程共享父進程處沿襲的數(shù)據(jù)段，可以方便的獲得、修改數(shù)據(jù)。但這也給多線程編程帶來了許多問題。我們必須當心有多個不同的進程訪問相同的變量。許多函數(shù)是不可重入的，即同時不能運行一個函數(shù)的多個拷貝（除非使用不同的數(shù)據(jù)段）。在函數(shù)中聲明的靜態(tài)變量常常帶來問題，函數(shù)的返回值也會有問題。因為如果返回的是函數(shù)內(nèi)部靜態(tài)聲明的空間的地址，則在一個線程調(diào)用該函數(shù)得到地址后使用該地址指向的數(shù)據(jù)時，別的線程可能調(diào)用此函數(shù)并修改了這一段數(shù)據(jù)。在進程中共享的變量必須用關鍵字volatile來定義，這是為了防止編譯器在優(yōu)化時（如gcc中使用-OX參數(shù)）改變它們的使用方式。為了保護變量，我們必須使用信號量、互斥等方法來保證我們對變量的正確使用。
1．線程數(shù)據(jù) 在單線程的程序里，有兩種基本的數(shù)據(jù)：全局變量和局部變量。但在多線程程序里，還有第三種數(shù)據(jù)類型：線程數(shù)據(jù)（TSD: Thread-SpecificData）。它和全局變量很象，在線程內(nèi)部，各個函數(shù)可以象使用全局變量一樣調(diào)用它，但它對線程外部的其它線程是不可見的。例如我們常見的變量errno，它返回標準的出錯信息。它顯然不能是一個局部變量，幾乎每個函數(shù)都應該可以調(diào)用它；但它又不能是一個全局變量，否則在A線程里輸出的很可能是B線程的出錯信息。要實現(xiàn)諸如此類的變量，我們就必須使用線程數(shù)據(jù)。我們?yōu)槊總€線程數(shù)據(jù)創(chuàng)建一個鍵，它和這個鍵相關聯(lián)，在各個線程里，都使用這個鍵來指代線程數(shù)據(jù)，但在不同的線程里，這個鍵代表的數(shù)據(jù)是不同的，在同一個線程里，它代表同樣的數(shù)據(jù)內(nèi)容。
和線程數(shù)據(jù)相關的函數(shù)主要有4個：創(chuàng)建一個鍵；為一個鍵指定線程數(shù)據(jù)；從一個鍵讀取線程數(shù)據(jù)；刪除鍵。
創(chuàng)建鍵的函數(shù)原型為：
intpthread_key_create __P ((pthread_key_t *__key,void (*__destr_function)(void *))); 第一個參數(shù)為指向一個鍵值的指針，第二個參數(shù)指明了一個destructor函數(shù)，如果這個參數(shù)不為空，那么當每個線程結(jié)束時，系統(tǒng)將調(diào)用這個函數(shù)來釋放綁定在這個鍵上的內(nèi)存塊。這個函數(shù)常和函數(shù)pthread_once ((pthread_once_t*once_control, void(*initroutine)(void)))一起使用，為了讓這個鍵只被創(chuàng)建一次。函數(shù)pthread_once聲明一個初始化函數(shù)，第一次調(diào)用pthread_once時它執(zhí)行這個函數(shù)，以后的調(diào)用將被它忽略。
int pthread_key_delete(pthread_key_t *key);
該函數(shù)用于刪除一個由pthread_key_create 函數(shù)調(diào)用創(chuàng)建的鍵。調(diào)用成功返回值為0，否則返回錯誤代碼。
在下面的例子中，我們創(chuàng)建一個鍵，并將它和某個數(shù)據(jù)相關聯(lián)。我們要定義一個函數(shù) createWindow，這個函數(shù)定義一個圖形窗口（數(shù)據(jù)類型為Fl_Window*，這是圖形界面開發(fā)工具FLTK中的數(shù)據(jù)類型）。由于各個線程都會調(diào)用這個函數(shù)，所以我們使用線程數(shù)據(jù)。
/* 聲明一個鍵*/
pthread_key_tmyWinKey;
/* 函數(shù) createWindow */
void createWindow ( void ) {
Fl_Window* win;
static pthread_once_t once= PTHREAD_ONCE_INIT;
/*調(diào)用函數(shù)createMyKey，創(chuàng)建鍵*/
pthread_once ( & once, createMyKey) ;
/*win指向一個新建立的窗口*/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/*對此窗口作一些可能的設置工作，如大小、位置、名稱等*/
setWindow(win);
/*將窗口指針值綁定在鍵myWinKey上*/
pthread_setpecific ( myWinKey, win);
}
/*函數(shù) createMyKey，創(chuàng)建一個鍵，并指定了destructor */
void createMyKey ( void ) {
pthread_keycreate(&myWinKey,freeWinKey);
}
/* 函數(shù) freeWinKey，釋放空間*/
void freeWinKey (Fl_Window * win){
delete win;
}
這樣，在不同的線程中調(diào)用函數(shù)createMyWin，都可以得到在線程內(nèi)部均可見的窗口變量，這個變量通過函數(shù)pthread_getspecific得到。在上面的例子中，我們已經(jīng)使用了函數(shù)pthread_setspecific來將線程數(shù)據(jù)和一個鍵綁定在一起。這兩個函數(shù)的原型如下：
int pthread_setspecific __P ((pthread_key_t__key,__const void *__pointer)); 該函數(shù)設置一個線程專有數(shù)據(jù)的值，賦給由pthread_key_create創(chuàng)建的鍵，調(diào)用成功返回值為0，否則返回錯誤代碼。
void *pthread_getspecific __P((pthread_key_t __key)); 該函數(shù)獲得綁定到指定鍵上的值。調(diào)用成功，返回給定參數(shù)key 所對應的數(shù)據(jù)。如果沒有數(shù)據(jù)連接到該鍵，則返回NULL。
這兩個函數(shù)的參數(shù)意義和使用方法是顯而易見的。要注意的是，用pthread_setspecific為一個鍵指定新的線程數(shù)據(jù)時，必須自己釋放原有的線程數(shù)據(jù)以回收空間。這個過程函數(shù)pthread_key_delete用來刪除一個鍵，這個鍵占用的內(nèi)存將被釋放，但同樣要注意的是，它只釋放鍵占用的內(nèi)存，并不釋放該鍵關聯(lián)的線程數(shù)據(jù)所占用的內(nèi)存資源，而且它也不會觸發(fā)函數(shù)pthread_key_create中定義的destructor函數(shù)。線程數(shù)據(jù)的釋放必須在釋放鍵之前完成。
2．互斥鎖 假設各個現(xiàn)成向同一個文件順序?qū)懭霐?shù)據(jù)，最后得到的結(jié)果是不可想象的。所以用互斥鎖來保證一段時間內(nèi)只有一個線程在執(zhí)行一段代碼。
使用int pthread_mutex_lock鎖住互斥鎖，使用int pthread_mutex_unlock解瑣。
如果我們試圖為一個已被其他線程鎖住的互斥鎖加鎖，程序便會阻塞直到該互斥對象解鎖。
如果在共享內(nèi)存中分配一個互斥鎖，我們必須在運行時調(diào)用ptgread_mutex_init函數(shù)盡心初始化。
void reader_function ( void );
voidwriter_function ( void );
char buffer;
int buffer_has_item=0;
pthread_mutex_tmutex;
struct timespec delay;
void main ( void ){
pthread_treader;
/* 定義延遲時間*/
delay.tv_sec = 2;
delay.tv_nec = 0;
/*用默認屬性初始化一個互斥鎖對象*/
pthread_mutex_init (&mutex,NULL);
pthread_create(&reader,pthread_attr_default, (void *)&reader_function), NULL);
writer_function();
}
void writer_function (void){
while(1){
/* 鎖定互斥鎖*/
pthread_mutex_lock(&mutex);
if (buffer_has_item==0){
buffer=make_new_item( );
buffer_has_item=1;
}
/*打開互斥鎖*/
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
voidreader_function(void){
while(1){
pthread_mutex_lock(&mutex);
if(buffer_has_item==1){
consume_item(buffer);
buffer_has_item=0;
}
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
函數(shù) pthread_mutex_init用來生成一個互斥鎖。NULL參數(shù)表明使用默認屬性。如果需要聲明特定屬性的互斥鎖，須調(diào)用函數(shù)pthread_mutexattr_init。函數(shù)pthread_mutexattr_setpshared和函數(shù)pthread_mutexattr_settype用來設置互斥鎖屬性。前一個函數(shù)設置屬性pshared，它有兩個取值，PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用來不同進程中的線程同步，后者用于同步本進程的不同線程。在上面的例子中，我們使用的是默認屬性PTHREAD_PROCESS_PRIVATE。后者用來設置互斥鎖類型，可選的類型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、PTHREAD_MUTEX_RECURSIVE和PTHREAD_MUTEX_DEFAULT。它們分別定義了不同的上所、解鎖機制，一般情況下，選用最后一個默認屬性。
需要注意的是在使用互斥鎖的過程中很有可能會出現(xiàn)死鎖：兩個線程試圖同時占用兩個資源，并按不同的次序鎖定相應的互斥鎖，例如兩個線程都需要鎖定互斥鎖1和互斥鎖2，a線程先鎖定互斥鎖1，b線程先鎖定互斥鎖2，這時就出現(xiàn)了死鎖。此時我們可以使用函數(shù)pthread_mutex_trylock，它是函數(shù)pthread_mutex_lock的非阻塞版本，當它發(fā)現(xiàn)死鎖不可避免時，它會返回相應的信息，程序員可以針對死鎖做出相應的處理。另外不同的互斥鎖類型對死鎖的處理不一樣，但最主要的還是要程序員自己在程序設計注意這一點。
3．條件變量
互斥鎖一個明顯的缺點是它只有兩種狀態(tài)：鎖定和非鎖定。而條件變量通過允許線程阻塞和等待另一個線程發(fā)送信號的方法彌補了互斥鎖的不足，它常和互斥鎖一起使用。使用時，條件變量被用來阻塞一個線程，當條件不滿足時，線程往往解開相應的互斥鎖并等待條件發(fā)生變化。一旦其它的某個線程改變了條件變量，它將通知相應的條件變量喚醒一個或多個正被此條件變量阻塞的線程。這些線程將重新鎖定互斥鎖并重新測試條件是否滿足。一般說來，條件變量被用來進行線承間的同步。
條件變量的結(jié)構(gòu)為pthread_cond_t，函數(shù)pthread_cond_init（）被用來初始化一個條件變量。它的原型為：
int pthread_cond_init __P ((pthread_cond_t *__cond,__constpthread_condattr_t *__cond_attr));
其中cond是一個指向結(jié)構(gòu)pthread_cond_t的指針，cond_attr是一個指向結(jié)構(gòu)pthread_condattr_t的指針。結(jié)構(gòu)pthread_condattr_t是條件變量的屬性結(jié)構(gòu)，和互斥鎖一樣我們可以用它來設置條件變量是進程內(nèi)可用還是進程間可用，默認值是PTHREAD_PROCESS_PRIVATE，即此條件變量被同一進程內(nèi)的各個線程使用。注意初始化條件變量只有未被使用時才能重新初始化或被釋放。
在pthread中，條件變量是一個pthread_cond_t類型的變量，條件變量使用下面兩個函數(shù)：
pthread_cond_wait函數(shù)用于阻塞，線程可以被函數(shù)pthread_cond_signal和函數(shù) pthread_cond_broadcast喚醒，但是要注意的是，條件變量只是起阻塞和喚醒線程的作用，具體的判斷條件還需用戶給出，例如一個變量是否為0等等，這一點我們從后面的例子中可以看到。線程被喚醒后，它將重新檢查判斷條件是否滿足，如果還不滿足，一般說來線程應該仍阻塞在這里，被等待被下一次喚醒。這個過程一般用while語句實現(xiàn)。
另一個用來阻塞線程的函數(shù)是pthread_cond_timedwait（）它比函數(shù)pthread_cond_wait（）多了一個時間參數(shù)，經(jīng)歷abstime段時間后，即使條件變量不滿足，阻塞也被解除。
函數(shù)pthread_cond_signal（）用來釋放被阻塞在條件變量cond上的一個線程。
函數(shù)pthread_cond_broadcast（pthread_cond_t*cond）用來喚醒所有被阻塞在條件變量cond上的線程。這些線程被喚醒后將再次競爭相應的互斥鎖，所以必須小心使用這個函數(shù)。
下面是使用函數(shù)pthread_cond_wait（）和函數(shù)pthread_cond_signal（）的一個簡單的例子:
pthread_mutex_tcount_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count() {
pthread_mutex_lock (&count_lock);
while(count==0)
pthread_cond_wait(&count_nonzero, &count_lock);
count=count -1;
pthread_mutex_unlock(&count_lock);
}
increment_count(){
pthread_mutex_lock(&count_lock);
if(count==0)
pthread_cond_signal(&count_nonzero);
count=count+1;
pthread_mutex_unlock(&count_lock);
}
count值為0時， decrement函數(shù)在pthread_cond_wait處被阻塞，并打開互斥鎖count_lock。此時，當調(diào)用到函數(shù)increment_count時，pthread_cond_signal（）函數(shù)改變條件變量，告知decrement_count（）停止阻塞。
