?

在傳統(tǒng)的 Unix 模型中，當(dāng)一個(gè)進(jìn)程需要由另一個(gè)實(shí)體執(zhí)行某件事時(shí)，該進(jìn)程派生（fork）一個(gè)子進(jìn)程，讓子進(jìn)程去進(jìn)行處理。Unix 下的大多數(shù)網(wǎng)絡(luò)服務(wù)器程序都是這么編寫的，即父進(jìn)程接受連接，派生子進(jìn)程，子進(jìn)程處理與客戶的交互。

雖然這種模型很多年來使用得很好，但是 fork 時(shí)有一些問題：

fork 是昂貴的。內(nèi)存映像要從父進(jìn)程拷貝到子進(jìn)程，所有描述字要在子進(jìn)程中復(fù)制等等。目前有的 Unix 實(shí)現(xiàn)使用一種叫做寫時(shí)拷貝（copy－on－write）的技術(shù)，可避免父進(jìn)程數(shù)據(jù)空間向子進(jìn)程的拷貝。盡管有這種優(yōu)化技術(shù)，fork 仍然是昂貴的。

fork 子進(jìn)程后，需要用進(jìn)程間通信（IPC）在父子進(jìn)程之間傳遞信息。Fork 之前的信息容易傳遞，因?yàn)樽舆M(jìn)程從一開始就有父進(jìn)程數(shù)據(jù)空間及所有描述字的拷貝。但是從子進(jìn)程返回信息給父進(jìn)程需要做更多的工作。

線程有助于解決這兩個(gè)問題。線程有時(shí)被稱為輕權(quán)進(jìn)程（lightweight process），因?yàn)榫€程比進(jìn)程 “輕權(quán)”，一般來說，創(chuàng)建一個(gè)線程要比創(chuàng)建一個(gè)進(jìn)程快 10～100 倍。

一個(gè)進(jìn)程中的所有線程共享相同的全局內(nèi)存，這使得線程很容易共享信息，但是這種簡易性也帶來了同步問題。

一個(gè)進(jìn)程中的所有線程不僅共享全局變量，而且共享：進(jìn)程指令、大多數(shù)數(shù)據(jù)、打開的文件（如描述字）、信號(hào)處理程序和信號(hào)處置、當(dāng)前工作目錄、用戶 ID 和組 ID。但是每個(gè)線程有自己的線程 ID、寄存器集合（包括程序計(jì)數(shù)器和棧指針）、棧（用于存放局部變量和返回地址）、error、信號(hào)掩碼、優(yōu)先級(jí)。在 Linux 中線程編程符合 Posix.1 標(biāo)準(zhǔn)，稱為 Pthreads。所有的 pthread 函數(shù)都以 pthread開頭。在調(diào)用它們前均要包括 pthread.h 頭文件，一個(gè)函數(shù)庫 libpthread 實(shí)現(xiàn)。

線程基礎(chǔ)介紹：==========

數(shù)據(jù)結(jié)構(gòu)：

?

pthread_t:線程的ID
pthread_attr_t:線程的屬性

?

操作函數(shù)：

?

pthread_create()：創(chuàng)建一個(gè)線程
pthread_exit()：終止當(dāng)前線程
pthread_cancel()：中斷另外一個(gè)線程的運(yùn)行
pthread_join()：阻塞當(dāng)前的線程，直到另外一個(gè)線程運(yùn)行結(jié)束
pthread_attr_init()：初始化線程的屬性
pthread_attr_setdetachstate()：設(shè)置脫離狀態(tài)的屬性（決定這個(gè)線程在終止時(shí)是否可以被結(jié)合）
pthread_attr_getdetachstate()：獲取脫離狀態(tài)的屬性
pthread_attr_destroy()：刪除線程的屬性
pthread_kill()：向線程發(fā)送一個(gè)信號(hào)

?

同步函數(shù)：

?

用于?mutex?和條件變量
pthread_mutex_init()初始化互斥鎖
pthread_mutex_destroy()刪除互斥鎖
pthread_mutex_lock()：占有互斥鎖（阻塞操作）
pthread_mutex_trylock()：試圖占有互斥鎖（不阻塞操作）。即，當(dāng)互斥鎖空閑時(shí)，將占有該鎖；否則，立即返回。
pthread_mutex_unlock():釋放互斥鎖
pthread_cond_init()：初始化條件變量
pthread_cond_destroy()：銷毀條件變量
pthread_cond_signal():喚醒第一個(gè)調(diào)用pthread_cond_wait()而進(jìn)入睡眠的線程
pthread_cond_wait():等待條件變量的特殊條件發(fā)生
Thread-local storage（或者以Pthreads術(shù)語，稱作線程特有數(shù)據(jù)）：
pthread_key_create():分配用于標(biāo)識(shí)進(jìn)程中線程特定數(shù)據(jù)的鍵
pthread_setspecific():為指定線程特定數(shù)據(jù)鍵設(shè)置線程特定綁定
pthread_getspecific():獲取調(diào)用線程的鍵綁定，并將該綁定存儲(chǔ)在?value?指向的位置中
pthread_key_delete():銷毀現(xiàn)有線程特定數(shù)據(jù)鍵
pthread_attr_getschedparam();獲取線程優(yōu)先級(jí)
pthread_attr_setschedparam();設(shè)置線程優(yōu)先級(jí)

?

概念：======

線程的組成部分：

Thread ID 線程 ID

Stack 棧

Policy 優(yōu)先級(jí)

Signal mask 信號(hào)碼

Errno 錯(cuò)誤碼

Thread-Specific Data 特殊數(shù)據(jù)

線程定義=======

pthread_t pthread_ID , 用于標(biāo)識(shí)一個(gè)線程，不能單純看成整數(shù)，可能是結(jié)構(gòu)體，與實(shí)現(xiàn)有關(guān)

pthread_equal 函數(shù)用于比較兩個(gè) pthread_t 是否相等

?

＃include?
??
int?pthread_equal(pthread_t?tid1,pthread_t?tid2)

?

pthread_self 函數(shù)用于獲得本線程的 thread id

?

＃include?
??
pthread?_t?pthread_self(void);

?

線程的創(chuàng)建========

創(chuàng)建線程調(diào)用 pthread_create 函數(shù)：

?

＃include?
??
?int?pthread_create(
????????pthread_t*restrict?tidp,
????????constpthread_attr_t*restrict?attr,
????????void*(*start_rtn)(void*),void*restrict?arg);

?

參數(shù)說明：

pthread_t *restrict tidp：返回最后創(chuàng)建出來的 Thread 的 Thread ID

const pthread_attr_t *restrict attr：指定線程的 Attributes，后面會(huì)講道，現(xiàn)在可以用 NULL

void *(*start_rtn)(void *)：指定線程函數(shù)指針，該函數(shù)返回一個(gè) void ，參數(shù)也為 void

void *restrict arg：傳入給線程函數(shù)的參數(shù)

返回錯(cuò)誤值。

一個(gè)進(jìn)程中的每個(gè)線程都由一個(gè)線程 ID（thread ID）標(biāo)識(shí)，其數(shù)據(jù)類型是 pthread_t（常常是 unsigned int）。如果新的線程創(chuàng)建成功，其 ID 將通過 tid 指針返回。

每個(gè)線程都有很多屬性：優(yōu)先級(jí)、起始棧大小、是否應(yīng)該是一個(gè)守護(hù)線程等等，當(dāng)創(chuàng)建線程時(shí)，我們可通過初始化一個(gè) pthread_attr_t 變量說明這些屬性以覆蓋缺省值。我們通常使用缺省值，在這種情況下，我們將 attr 參數(shù)說明為空指針。

最后，當(dāng)創(chuàng)建一個(gè)線程時(shí)，我們要說明一個(gè)它將執(zhí)行的函數(shù)。線程以調(diào)用該函數(shù)開始，然后或者顯式地終止（調(diào)用 pthread_exit）或者隱式地終止（讓該函數(shù)返回）。函數(shù)的地址由 func 參數(shù)指定，該函數(shù)的調(diào)用參數(shù)是一個(gè)指針 arg，如果我們需要多個(gè)調(diào)用參數(shù)，我們必須將它們打包成一個(gè)結(jié)構(gòu)，然后將其地址當(dāng)作唯一的參數(shù)傳遞給起始函數(shù)。

在 func 和 arg 的聲明中，func 函數(shù)取一個(gè)通用指針（void ＊）參數(shù)，并返回一個(gè)通用指針（void ＊），這就使得我們可以傳遞一個(gè)指針（指向任何我們想要指向的東西）給線程，由線程返回一個(gè)指針（同樣指向任何我們想要指向的東西）。調(diào)用成功，返回 0，出錯(cuò)時(shí)返回正 Exxx 值。

pthread 函數(shù)在出錯(cuò)的時(shí)候不會(huì)設(shè)置 errno，而是直接返回錯(cuò)誤值

在 Linux 系統(tǒng)下面，在老的內(nèi)核中，由于 Thread 也被看作是一種特殊，可共享地址空間和資源的 Process，因此在同一個(gè) Process 中創(chuàng)建的不同 Thread 具有不同的 Process ID（調(diào)用 getpid 獲得）。而在新的 2.6 內(nèi)核之中，Linux 采用了 NPTL(Native POSIX Thread Library) 線程模型，在該線程模型下同一進(jìn)程下不同線程調(diào)用 getpid 返回同一個(gè) PID。

不能對(duì)創(chuàng)建的新線程和當(dāng)前創(chuàng)建者線程的運(yùn)行順序作出任何假設(shè)

線程的退出========

exit, _Exit, _exit 用于中止當(dāng)前進(jìn)程，而非線程

中止線程可以有三種方式：
a.在線程函數(shù)中 return
b.被同一進(jìn)程中的另外的線程 Cancel 掉
c. 線程調(diào)用 pthread_exit 函數(shù)

pthread_exit 和 pthread_join 函數(shù)的用法：
a.線程 A 調(diào)用 pthread_join(B, &rval_ptr)，被 Block，進(jìn)入 Detached 狀態(tài)（如果已經(jīng)進(jìn)入 Detached 狀態(tài)，則 pthread_join 函數(shù)返回 EINVAL）。如果對(duì) B 的結(jié)束代碼不感興趣，rval_ptr 可以傳 NULL。
b. 線程 B 調(diào)用 pthread_exit(rval_ptr)，退出線程 B，結(jié)束代碼為 rval_ptr。注意 rval_ptr 指向的內(nèi)存的生命周期，不應(yīng)該指向 B 的 Stack 中的數(shù)據(jù)。
c. 線程 A 恢復(fù)運(yùn)行，pthread_join 函數(shù)調(diào)用結(jié)束，線程 B 的結(jié)束代碼被保存到 rval_ptr 參數(shù)中去。如果線程 B 被 Cancel，那么 rval_ptr 的值就是 PTHREAD_CANCELLED。

兩個(gè)函數(shù)原型如下：

?

＃include?
?
void?pthread_exit(void*rval_ptr);
?
int?pthread_join(pthread_t?thread,void**rval_ptr);

?

該函數(shù)等待一個(gè)線程終止。把線程和進(jìn)程相比，pthread_creat 類似于 fork，而 pthread_join 類似于 waitpid。我們必須要等待線程的 tid，很可惜，我們沒有辦法等待任意一個(gè)線程結(jié)束。如果 status 指針非空，線程的返回值（一個(gè)指向某個(gè)對(duì)象的指針）將存放在 status 指向的位置。

一個(gè) Thread 可以要求另外一個(gè) Thread 被 Cancel，通過調(diào)用 pthread_cancel 函數(shù)：

?

＃include?
?
void?pthread_cancel(pthread_t?tid)

?

該函數(shù)會(huì)使指定線程如同調(diào)用了 pthread_exit(PTHREAD_CANCELLED)。不過，指定線程可以選擇忽略或者進(jìn)行自己的處理，在后面會(huì)講到。此外，該函數(shù)不會(huì)導(dǎo)致 Block，只是發(fā)送 Cancel 這個(gè)請(qǐng)求。

線程可以安排在它退出的時(shí)候，某些函數(shù)自動(dòng)被調(diào)用，類似 atexit() 函數(shù)。需要調(diào)用如下函數(shù)：

?

＃include?
?
void?pthread_cleanup_push(void(*rtn)(void*),void*arg);
void?pthread_cleanup_pop(int?execute);

?

這兩個(gè)函數(shù)維護(hù)一個(gè)函數(shù)指針的 Stack，可以把函數(shù)指針和函數(shù)參數(shù)值 push/pop。執(zhí)行的順序則是從棧頂?shù)綏５祝簿褪呛?push 的順序相反。

在下面情況下 pthread_cleanup_push 所指定的 thread cleanup handlers 會(huì)被調(diào)用：
a.調(diào)用 pthread_exit
b.相應(yīng) cancel 請(qǐng)求
c.以非 0 參數(shù)調(diào)用 pthread_cleanup_pop()。（如果以 0 調(diào)用 pthread_cleanup_pop()，那么 handler 不會(huì)被調(diào)用

有一個(gè)比較怪異的要求是，由于這兩個(gè)函數(shù)可能由宏的方式來實(shí)現(xiàn)，因此這兩個(gè)函數(shù)的調(diào)用必須得是在同一個(gè) Scope 之中，并且配對(duì)，因?yàn)樵?pthread_cleanup_push 的實(shí)現(xiàn)中可能有一個(gè) {，而 pthread_cleanup_pop 可能有一個(gè)}。因此，一般情況下，這兩個(gè)函數(shù)是用于處理意外情況用的，舉例如下：

?

void*thread_func(void*arg)
{
????pthread_cleanup_push(cleanup,“handler”)
?
????//?do?something
?
????Pthread_cleanup_pop(0);
????return((void*)0)；
}

?

進(jìn)程函數(shù)和線程函數(shù)的相關(guān)性：

缺省情況下，一個(gè)線程 A 的結(jié)束狀態(tài)被保存下來直到 pthread_join 為該線程被調(diào)用過，也就是說即使線程 A 已經(jīng)結(jié)束，只要沒有線程 B 調(diào)用 pthread_join(A)，A 的退出狀態(tài)則一直被保存。而當(dāng)線程處于 Detached 狀態(tài)之時(shí)，當(dāng)線程退出的時(shí)候，其資源可以立刻被回收，那么這個(gè)退出狀態(tài)也丟失了。在這個(gè)狀態(tài)下，無法為該線程調(diào)用 pthread_join 函數(shù)。我們可以通過調(diào)用 pthread_detach 函數(shù)來使指定線程進(jìn)入 Detach 狀態(tài)：

?

＃include?
int?pthread_detach(pthread_t?tid);

?

通過修改調(diào)用 pthread_create 函數(shù)的 attr 參數(shù)，我們可以指定一個(gè)線程在創(chuàng)建之后立刻就進(jìn)入 Detached 狀態(tài)

線程同步=======

互斥量：Mutex

各個(gè)現(xiàn)成向同一個(gè)文件順序?qū)懭霐?shù)據(jù)，最后得到的結(jié)果是不可想象的。所以用互斥鎖來保證一段時(shí)間內(nèi)只有一個(gè)線程在執(zhí)行一段代碼。

用于互斥訪問

類型：pthread_mutex_t，必須被初始化為 PTHREAD_MUTEX_INITIALIZER

（用于靜態(tài)分配的 mutex，等價(jià)于 pthread_mutex_init(…, NULL)）或者調(diào)用 pthread_mutex_init。Mutex 也應(yīng)該用 pthread_mutex_destroy 來銷毀。這兩個(gè)函數(shù)原型如下：（attr 的具體含義下一章討論）

?

＃include?
?
int?pthread_mutex_init(
???????pthread_mutex_t*restrict?mutex,
???????constpthread_mutexattr_t*restrict?attr)
?
int?pthread_mutex_destroy(pthread_mutex_t*mutex);

?

pthread_mutex_lock 用于 Lock Mutex，如果 Mutex 已經(jīng)被 Lock，該函數(shù)調(diào)用會(huì) Block 直到 Mutex 被 Unlock，然后該函數(shù)會(huì) Lock Mutex 并返回。pthread_mutex_trylock 類似，只是當(dāng) Mutex 被 Lock 的時(shí)候不會(huì) Block，而是返回一個(gè)錯(cuò)誤值 EBUSY。

pthread_mutex_unlock 則是 unlock 一個(gè) mutex。這三個(gè)函數(shù)原型如下：

?

＃include?
?
int?pthread_mutex_lock(pthread_mutex_t*mutex);
?
int?pthread_mutex_trylock(pthread_mutex_t*mutex);
?
int?pthread_mutex_unlock(pthread_mutex_t*mutex);

?

舉例說明

?

void?reader_function?(void);
void?writer_function?(void);
char?buffer;
int?buffer_has_item=0;
pthread_mutex_t?mutex;
struct?timespec?delay;
void?main?(void)
{
pthread_t?reader;
/*?定義延遲時(shí)間*/
delay.tv_sec?=2;
delay.tv_nec?=0;
/*?用默認(rèn)屬性初始化一個(gè)互斥鎖對(duì)象*/
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);
}
}
void?reader_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);
}
}

?

需要注意的是在使用互斥鎖的過程中很有可能會(huì)出現(xiàn)死鎖：兩個(gè)線程試圖同時(shí)占用兩個(gè)資源，并按不同的次序鎖定相應(yīng)的互斥鎖，例如兩個(gè)線程都需要鎖定互斥鎖 1 和互斥鎖 2，a 線程先鎖定互斥鎖 1，b 線程先鎖定互斥鎖 2，這時(shí)就出現(xiàn)了死鎖。此時(shí)我們可以使用函數(shù) pthread_mutex_trylock，它是函數(shù) pthread_mutex_lock 的非阻塞版本，當(dāng)它發(fā)現(xiàn)死鎖不可避免時(shí)，它會(huì)返回相應(yīng)的信息，程序員可以針對(duì)死鎖做出相應(yīng)的處理。另外不同的互斥鎖類型對(duì)死鎖的處理不一樣，但最主要的還是要程序員自己在程序設(shè)計(jì)注意這一點(diǎn)

讀寫鎖：Reader-Writer Locks

多個(gè)線程可以同時(shí)獲得讀鎖 (Reader-Writer lock in read mode)，但是只有一個(gè)線程能夠獲得寫鎖 (Reader-writer lock in write mode)

讀寫鎖有三種狀態(tài)

一個(gè)或者多個(gè)線程獲得讀鎖，其他線程無法獲得寫鎖

一個(gè)線程獲得寫鎖，其他線程無法獲得讀鎖

沒有線程獲得此讀寫鎖

類型為 pthread_rwlock_t

創(chuàng)建和關(guān)閉方法如下：

?

＃include?
?
int?pthread_rwlock_init(
???????pthread_rwlock_t*restrict?rwlock,
???????constpthread_rwlockattr_t*restrict?attr)
?
int?pthread_rwlock_destroy(pthread_rwlock_t*rwlock);

?

獲得讀寫鎖的方法如下：

?

＃include?
?
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ù)

注意具體實(shí)現(xiàn)可能對(duì)同時(shí)獲得讀鎖的線程個(gè)數(shù)有限制，所以在調(diào)用 pthread_rwlock_rdlock 的時(shí)候需要檢查錯(cuò)誤值，而另外兩個(gè) pthread_rwlock_wrlock 和 pthread_rwlock_unlock 則一般不用檢查，如果我們代碼寫的正確的話。

Conditional Variable：條件變量

互斥鎖一個(gè)明顯的缺點(diǎn)是它只有兩種狀態(tài)：鎖定和非鎖定。而條件變量通過允許線程阻塞和等待另一個(gè)線程發(fā)送信號(hào)的方法彌補(bǔ)了互斥鎖的不足，它常和互斥鎖一起使用。使用時(shí)，條件變量被用來阻塞一個(gè)線程，當(dāng)條件不滿足時(shí)，線程往往解開相應(yīng)的互斥鎖并等待條件發(fā)生變化。一旦其它的某個(gè)線程改變了條件變量，它將通知相應(yīng)的條件變量喚醒一個(gè)或多個(gè)正被此條件變量阻塞的線程。這些線程將重新鎖定互斥鎖并重新測試條件是否滿足。一般說來，條件變量被用來進(jìn)行線程間的同步。

條件必須被 Mutex 保護(hù)起來

類型為：pthread_cond_t，必須被初始化為 PTHREAD_COND_INITIALIZER（用于靜態(tài)分配的條件，等價(jià)于 pthread_cond_init(…, NULL)）或者調(diào)用 pthread_cond_init

?

＃include?
?
int?pthread_cond_init(
???????pthread_cond_t*restrict?cond,
???????constpthread_condxattr_t*restrict?attr)
?
int?pthread_cond_destroy(pthread_cond_t*cond);

?

pthread_cond_wait 函數(shù)用于等待條件發(fā)生（=true）。pthread_cond_timedwait 類似，只是當(dāng)?shù)却瑫r(shí)的時(shí)候返回一個(gè)錯(cuò)誤值 ETIMEDOUT。超時(shí)的時(shí)間用 timespec 結(jié)構(gòu)指定。此外，兩個(gè)函數(shù)都需要傳入一個(gè) Mutex 用于保護(hù)條件

?

＃include?
?
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,
???????conststruct?timespec?*restrict?timeout);

?

一個(gè)簡單例子：

?

pthread_mutex_t?count_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 時(shí)， decrement 函數(shù)在 pthread_cond_wait 處被阻塞，并打開互斥鎖 count_lock。此時(shí)，當(dāng)調(diào)用到函數(shù) increment_count 時(shí)，pthread_cond_signal（）函數(shù)改變條件變量，告知 decrement_count（）停止阻塞。

timespec 結(jié)構(gòu)定義如下：

?

struct?timespec?{
???????time_t?tv_sec;???????/*?seconds?*/
???????long???tv_nsec;??????/*?nanoseconds?*/
};

?

注意 timespec 的時(shí)間是絕對(duì)時(shí)間而非相對(duì)時(shí)間，因此需要先調(diào)用 gettimeofday 函數(shù)獲得當(dāng)前時(shí)間，再轉(zhuǎn)換成 timespec 結(jié)構(gòu)，加上偏移量。

有兩個(gè)函數(shù)用于通知線程條件被滿足（=true）：

?

＃include?
?
int?pthread_cond_signal(pthread_cond_t*cond);
?
int?pthread_cond_broadcast(pthread_cond_t*cond);

?

兩者的區(qū)別是前者會(huì)喚醒單個(gè)線程，而后者會(huì)喚醒多個(gè)線程。

線程屬性=======

線程屬性設(shè)置

我們用 pthread_create 函數(shù)創(chuàng)建一個(gè)線程，在這個(gè)線程中，我們使用默認(rèn)參數(shù)，即將該函數(shù)的第二個(gè)參數(shù)設(shè)為 NULL。的確，對(duì)大多數(shù)程序來說，使用默認(rèn)屬性就夠了，但我們還是有必要來了解一下線程的有關(guān)屬性。

屬性結(jié)構(gòu)為 pthread_attr_t，它同樣在頭文件 pthread.h 中定義，屬性值不能直接設(shè)置，須使用相關(guān)函數(shù)進(jìn)行操作，初始化的函數(shù)為 pthread_attr_init，這個(gè)函數(shù)必須在 pthread_create 函數(shù)之前調(diào)用。屬性對(duì)象主要包括是否綁定、是否分離、

堆棧地址、堆棧大小、優(yōu)先級(jí)。默認(rèn)的屬性為非綁定、非分離、缺省的堆棧、與父進(jìn)程同樣級(jí)別的優(yōu)先級(jí)。

綁定

關(guān)于線程的綁定，牽涉到另外一個(gè)概念：輕進(jìn)程（LWP：Light Weight Process）。輕進(jìn)程可以理解為內(nèi)核線程，它位于用戶層和系統(tǒng)層之間。系統(tǒng)對(duì)線程資源的分配、對(duì)線程的控制是通過輕進(jìn)程來實(shí)現(xiàn)的，一個(gè)輕進(jìn)程可以控制一個(gè)或多個(gè)線程。默認(rèn)狀況下，啟動(dòng)多少輕進(jìn)程、哪些輕進(jìn)程來控制哪些線程是由系統(tǒng)來控制的，這種狀況即稱為非綁定的。綁定狀況下，則顧名思義，即某個(gè)線程固定的 "綁" 在一個(gè)輕進(jìn)程之上。被綁定的線程具有較高的響應(yīng)速度，這是因?yàn)?CPU 時(shí)間片的調(diào)度是面向輕進(jìn)程的，綁定的線程可以保證在需要的時(shí)候它總有一個(gè)輕進(jìn)程可用。通過設(shè)置被綁定的輕進(jìn)程的優(yōu)先級(jí)和調(diào)度級(jí)可以使得綁定的線程滿足諸如實(shí)時(shí)反應(yīng)之類的要求。

設(shè)置線程綁定狀態(tài)的函數(shù)為 pthread_attr_setscope，它有兩個(gè)參數(shù)，第一個(gè)是指向?qū)傩越Y(jié)構(gòu)的指針，第二個(gè)是綁定類型，它有兩個(gè)取值：PTHREAD_SCOPE_SYSTEM（綁定的）和 PTHREAD_SCOPE_PROCESS（非綁定的）。下面的代碼即創(chuàng)建了一個(gè)綁定的線程。

?

＃include?
pthread_attr_t?attr;
pthread_t?tid;
/*初始化屬性值，均設(shè)為默認(rèn)值*/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr,?PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid,&attr,(void*)?my_function,?NULL);

?

線程分離狀態(tài)

線程的分離狀態(tài)決定一個(gè)線程以什么樣的方式來終止自己。非分離的線程終止時(shí)，其線程 ID 和退出狀態(tài)將保留，直到另外一個(gè)線程調(diào)用 pthread_join. 分離的線程在當(dāng)它終止時(shí)，所有的資源將釋放，我們不能等待它終止。

設(shè)置線程分離狀態(tài)的函數(shù)為

pthread_attr_setdetachstate（pthread_attr_t *attr, int detachstate）

第二個(gè)參數(shù)可選為 PTHREAD_CREATE_DETACHED（分離線程）或 PTHREAD _CREATE_JOINABLE（非分離線程）。

這里要注意的一點(diǎn)是，如果設(shè)置一個(gè)線程為分離線程，而這個(gè)線程運(yùn)行又非?？欤芸赡茉?pthread_create 函數(shù)返回之前就終止了，它終止以后就可能將線程號(hào)和系統(tǒng)資源移交給其他的線程使用，這樣調(diào)用 pthread_create 的線程就得到了錯(cuò)誤的線程號(hào)。要避免這種情況可以采取一定的同步措施，最簡單的方法之一是可以在被創(chuàng)建的線程里調(diào)用 pthread_cond_timewait 函數(shù)，讓這個(gè)線程等待一會(huì)兒，留出足夠的時(shí)間讓函數(shù) pthread_create 返回。設(shè)置一段等待時(shí)間，是在多線程編程里常用的方法。

4．優(yōu)先級(jí)

它存放在結(jié)構(gòu) sched_param 中。用函數(shù)pthread_attr_getschedparam 和函數(shù) pthread_attr_setschedparam 進(jìn)行存放，一般說來，我們總是先取優(yōu)先級(jí)，對(duì)取得的值修改后再存放回去。下面即是一段簡單的例子。

?

＃include?
＃include?
pthread_attr_t?attr;pthread_t?tid;
sched_param?param;
int?newprio=20;
/*初始化屬性*/
pthread_attr_init(&attr);
/*設(shè)置優(yōu)先級(jí)*/
pthread_attr_getschedparam(&attr,?m);?
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr,?m);
pthread_create(&tid,&attr,(void*)myfunction,?myarg);

?