Linux 多線程全面解析

在傳統的 Unix 模型中，當一個進程需要由另一個實體執行某件事時，該進程派生（fork）一個子進程，讓子進程去進行處理。Unix 下的大多數網絡服務器程序都是這麼編寫的，即父進程接受連接，派生子進程，子進程處理與客戶的交互。

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

線程有助於解決這兩個問題。線程有時被稱爲輕權進程（lightweight process），因爲線程比進程 “輕權”，一般來說，創建一個線程要比創建一個進程快 10～100 倍。

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

一個進程中的所有線程不僅共享全局變量，而且共享：進程指令、大多數數據、打開的文件（如描述字）、信號處理程序和信號處置、當前工作目錄、用戶 ID 和組 ID。但是每個線程有自己的線程 ID、寄存器集合（包括程序計數器和棧指針）、棧（用於存放局部變量和返回地址）、error、信號掩碼、優先級。在 Linux 中線程編程符合 Posix.1 標準，稱爲 Pthreads。所有的 pthread 函數都以 pthread_開頭。在調用它們前均要包括 pthread.h 頭文件，一個函數庫 libpthread 實現。

1. 線程基礎介紹：

數據結構：

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

操作函數：

pthread_create()：創建一個線程
pthread_exit()：終止當前線程
pthread_cancel()：中斷另外一個線程的運行
pthread_join()：阻塞當前的線程，直到另外一個線程運行結束
pthread_attr_init()：初始化線程的屬性
pthread_attr_setdetachstate()：設置脫離狀態的屬性（決定這個線程在終止時是否可以被結合）
pthread_attr_getdetachstate()：獲取脫離狀態的屬性
pthread_attr_destroy()：刪除線程的屬性
pthread_kill()：向線程發送一個信號

同步函數：

用於 mutex 和條件變量
pthread_mutex_init()初始化互斥鎖
pthread_mutex_destroy()刪除互斥鎖
pthread_mutex_lock()：佔有互斥鎖（阻塞操作）
pthread_mutex_trylock()：試圖佔有互斥鎖（不阻塞操作）。即，當互斥鎖空閒時，將佔有該鎖；否則，立即返回。
pthread_mutex_unlock():釋放互斥鎖
pthread_cond_init()：初始化條件變量
pthread_cond_destroy()：銷燬條件變量
pthread_cond_signal():喚醒第一個調用pthread_cond_wait()而進入睡眠的線程
pthread_cond_wait():等待條件變量的特殊條件發生
Thread-local storage（或者以Pthreads術語，稱作線程特有數據）：
pthread_key_create():分配用於標識進程中線程特定數據的鍵
pthread_setspecific():爲指定線程特定數據鍵設置線程特定綁定
pthread_getspecific():獲取調用線程的鍵綁定，並將該綁定存儲在 value 指向的位置中
pthread_key_delete():銷燬現有線程特定數據鍵
pthread_attr_getschedparam();獲取線程優先級
pthread_attr_setschedparam();設置線程優先級

2. 概念：

線程的組成部分：

3. 線程定義

pthread_t pthread_ID , 用於標識一個線程，不能單純看成整數，可能是結構體，與實現有關

pthread_equal 函數用於比較兩個 pthread_t 是否相等

＃include <pthread.h>
  
int pthread_equal(pthread_t tid1,pthread_t tid2)

pthread_self 函數用於獲得本線程的 thread id

＃include <pthread.h>
  
pthread _t pthread_self(void);

4. 線程的創建

創建線程調用 pthread_create 函數：

＃include <pthread.h>
  
 int pthread_create(
        pthread_t*restrict tidp,
        constpthread_attr_t*restrict attr,
        void*(*start_rtn)(void*),void*restrict arg);

參數說明：

一個進程中的每個線程都由一個線程 ID（thread ID）標識，其數據類型是 pthread_t（常常是 unsigned int）。如果新的線程創建成功，其 ID 將通過 tid 指針返回。

每個線程都有很多屬性：優先級、起始棧大小、是否應該是一個守護線程等等，當創建線程時，我們可通過初始化一個 pthread_attr_t 變量說明這些屬性以覆蓋缺省值。我們通常使用缺省值，在這種情況下，我們將 attr 參數說明爲空指針。

最後，當創建一個線程時，我們要說明一個它將執行的函數。線程以調用該函數開始，然後或者顯式地終止（調用 pthread_exit）或者隱式地終止（讓該函數返回）。函數的地址由 func 參數指定，該函數的調用參數是一個指針 arg，如果我們需要多個調用參數，我們必須將它們打包成一個結構，然後將其地址當作唯一的參數傳遞給起始函數。

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

pthread 函數在出錯的時候不會設置 errno，而是直接返回錯誤值

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

不能對創建的新線程和當前創建者線程的運行順序作出任何假設

5. 線程的退出

兩個函數原型如下：

＃include <pthread.h>
 
void pthread_exit(void*rval_ptr);
 
int pthread_join(pthread_t thread,void**rval_ptr);

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

＃include <pthread.h>
 
void pthread_cancel(pthread_t tid)

該函數會使指定線程如同調用了 pthread_exit(PTHREAD_CANCELLED)。不過，指定線程可以選擇忽略或者進行自己的處理，在後面會講到。此外，該函數不會導致 Block，只是發送 Cancel 這個請求。

＃include <pthread.h>
 
void pthread_cleanup_push(void(*rtn)(void*),void*arg);
void pthread_cleanup_pop(int execute);

這兩個函數維護一個函數指針的 Stack，可以把函數指針和函數參數值 push/pop。執行的順序則是從棧頂到棧底，也就是和 push 的順序相反。

在下面情況下 pthread_cleanup_push 所指定的 thread cleanup handlers 會被調用：
a. 調用 pthread_exit
b. 相應 cancel 請求
c. 以非 0 參數調用 pthread_cleanup_pop()。（如果以 0 調用 pthread_cleanup_pop()，那麼 handler 不會被調用

有一個比較怪異的要求是，由於這兩個函數可能由宏的方式來實現，因此這兩個函數的調用必須得是在同一個 Scope 之中，並且配對，因爲在 pthread_cleanup_push 的實現中可能有一個 {，而 pthread_cleanup_pop 可能有一個}。因此，一般情況下，這兩個函數是用於處理意外情況用的，舉例如下：

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

進程函數和線程函數的相關性：

缺省情況下，一個線程 A 的結束狀態被保存下來直到 pthread_join 爲該線程被調用過，也就是說即使線程 A 已經結束，只要沒有線程 B 調用 pthread_join(A)，A 的退出狀態則一直被保存。而當線程處於 Detached 狀態之時，當線程退出的時候，其資源可以立刻被回收，那麼這個退出狀態也丟失了。在這個狀態下，無法爲該線程調用 pthread_join 函數。我們可以通過調用 pthread_detach 函數來使指定線程進入 Detach 狀態：

＃include <pthread.h>
int pthread_detach(pthread_t tid);

通過修改調用 pthread_create 函數的 attr 參數，我們可以指定一個線程在創建之後立刻就進入 Detached 狀態

6. 線程同步

互斥量：Mutex

各個現成向同一個文件順序寫入數據，最後得到的結果是不可想象的。所以用互斥鎖來保證一段時間內只有一個線程在執行一段代碼。

（用於靜態分配的 mutex，等價於 pthread_mutex_init(…, NULL)）或者調用 pthread_mutex_init。Mutex 也應該用 pthread_mutex_destroy 來銷燬。這兩個函數原型如下：（attr 的具體含義下一章討論）

＃include <pthread.h>
 
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 已經被 Lock，該函數調用會 Block 直到 Mutex 被 Unlock，然後該函數會 Lock Mutex 並返回。pthread_mutex_trylock 類似，只是當 Mutex 被 Lock 的時候不會 Block，而是返回一個錯誤值 EBUSY。

pthread_mutex_unlock 則是 unlock 一個 mutex。這三個函數原型如下：

＃include <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);

舉例說明

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;
/* 定義延遲時間*/
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);
}
}
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);
}
}

需要注意的是在使用互斥鎖的過程中很有可能會出現死鎖：兩個線程試圖同時佔用兩個資源，並按不同的次序鎖定相應的互斥鎖，例如兩個線程都需要鎖定互斥鎖 1 和互斥鎖 2，a 線程先鎖定互斥鎖 1，b 線程先鎖定互斥鎖 2，這時就出現了死鎖。此時我們可以使用函數 pthread_mutex_trylock，它是函數 pthread_mutex_lock 的非阻塞版本，當它發現死鎖不可避免時，它會返回相應的信息，程序員可以針對死鎖做出相應的處理。另外不同的互斥鎖類型對死鎖的處理不一樣，但最主要的還是要程序員自己在程序設計注意這一點

讀寫鎖：Reader-Writer Locks

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

讀寫鎖有三種狀態

類型爲 pthread_rwlock_t

創建和關閉方法如下：

＃include <pthread.h>
 
int pthread_rwlock_init(
       pthread_rwlock_t*restrict rwlock,
       constpthread_rwlockattr_t*restrict attr)
 
int pthread_rwlock_destroy(pthread_rwlock_t*rwlock);

獲得讀寫鎖的方法如下：

＃include <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：釋放鎖，不管是讀鎖還是寫鎖都是調用此函數

注意具體實現可能對同時獲得讀鎖的線程個數有限制，所以在調用 pthread_rwlock_rdlock 的時候需要檢查錯誤值，而另外兩個 pthread_rwlock_wrlock 和 pthread_rwlock_unlock 則一般不用檢查，如果我們代碼寫的正確的話。

互斥鎖一個明顯的缺點是它只有兩種狀態：鎖定和非鎖定。而條件變量通過允許線程阻塞和等待另一個線程發送信號的方法彌補了互斥鎖的不足，它常和互斥鎖一起使用。使用時，條件變量被用來阻塞一個線程，當條件不滿足時，線程往往解開相應的互斥鎖並等待條件發生變化。一旦其它的某個線程改變了條件變量，它將通知相應的條件變量喚醒一個或多個正被此條件變量阻塞的線程。這些線程將重新鎖定互斥鎖並重新測試條件是否滿足。一般說來，條件變量被用來進行線程間的同步。

＃include <pthread.h>
 
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 函數用於等待條件發生（=true）。pthread_cond_timedwait 類似，只是當等待超時的時候返回一個錯誤值 ETIMEDOUT。超時的時間用 timespec 結構指定。此外，兩個函數都需要傳入一個 Mutex 用於保護條件

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

一個簡單例子：

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 時， decrement 函數在 pthread_cond_wait 處被阻塞，並打開互斥鎖 count_lock。此時，當調用到函數 increment_count 時，pthread_cond_signal（）函數改變條件變量，告知 decrement_count（）停止阻塞。

timespec 結構定義如下：

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

注意 timespec 的時間是絕對時間而非相對時間，因此需要先調用 gettimeofday 函數獲得當前時間，再轉換成 timespec 結構，加上偏移量。

有兩個函數用於通知線程條件被滿足（=true）：

＃include <pthread.h>
 
int pthread_cond_signal(pthread_cond_t*cond);
 
int pthread_cond_broadcast(pthread_cond_t*cond);

兩者的區別是前者會喚醒單個線程，而後者會喚醒多個線程。

7. 線程屬性

我們用 pthread_create 函數創建一個線程，在這個線程中，我們使用默認參數，即將該函數的第二個參數設爲 NULL。的確，對大多數程序來說，使用默認屬性就夠了，但我們還是有必要來了解一下線程的有關屬性。

屬性結構爲 pthread_attr_t，它同樣在頭文件 pthread.h 中定義，屬性值不能直接設置，須使用相關函數進行操作，初始化的函數爲 pthread_attr_init，這個函數必須在 pthread_create 函數之前調用。屬性對象主要包括是否綁定、是否分離、

堆棧地址、堆棧大小、優先級。默認的屬性爲非綁定、非分離、缺省的堆棧、與父進程同樣級別的優先級。

關於線程的綁定，牽涉到另外一個概念：輕進程（LWP：Light Weight Process）。輕進程可以理解爲內核線程，它位於用戶層和系統層之間。系統對線程資源的分配、對線程的控制是通過輕進程來實現的，一個輕進程可以控制一個或多個線程。默認狀況下，啓動多少輕進程、哪些輕進程來控制哪些線程是由系統來控制的，這種狀況即稱爲非綁定的。綁定狀況下，則顧名思義，即某個線程固定的 "綁" 在一個輕進程之上。被綁定的線程具有較高的響應速度，這是因爲 CPU 時間片的調度是面向輕進程的，綁定的線程可以保證在需要的時候它總有一個輕進程可用。通過設置被綁定的輕進程的優先級和調度級可以使得綁定的線程滿足諸如實時反應之類的要求。

設置線程綁定狀態的函數爲 pthread_attr_setscope，它有兩個參數，第一個是指向屬性結構的指針，第二個是綁定類型，它有兩個取值：PTHREAD_SCOPE_SYSTEM（綁定的）和 PTHREAD_SCOPE_PROCESS（非綁定的）。下面的代碼即創建了一個綁定的線程。

＃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);

線程分離狀態

線程的分離狀態決定一個線程以什麼樣的方式來終止自己。非分離的線程終止時，其線程 ID 和退出狀態將保留，直到另外一個線程調用 pthread_join. 分離的線程在當它終止時，所有的資源將釋放，我們不能等待它終止。

設置線程分離狀態的函數爲

pthread_attr_setdetachstate（pthread_attr_t *attr, int detachstate）

第二個參數可選爲 PTHREAD_CREATE_DETACHED（分離線程）或 PTHREAD _CREATE_JOINABLE（非分離線程）。

這裏要注意的一點是，如果設置一個線程爲分離線程，而這個線程運行又非常快，它很可能在 pthread_create 函數返回之前就終止了，它終止以後就可能將線程號和系統資源移交給其他的線程使用，這樣調用 pthread_create 的線程就得到了錯誤的線程號。要避免這種情況可以採取一定的同步措施，最簡單的方法之一是可以在被創建的線程裏調用 pthread_cond_timewait 函數，讓這個線程等待一會兒，留出足夠的時間讓函數 pthread_create 返回。設置一段等待時間，是在多線程編程裏常用的方法。

它存放在結構 sched_param 中。用函數
pthread_attr_getschedparam 和函數 pthread_attr_setschedparam 進行存放，一般說來，我們總是先取優先級，對取得的值修改後再存放回去。下面即是一段簡單的例子。

＃include <pthread.h>
＃include <sched.h>
pthread_attr_t attr;pthread_t tid;
sched_param param;
int newprio=20;
/*初始化屬性*/
pthread_attr_init(&attr);
/*設置優先級*/
pthread_attr_getschedparam(&attr,m); 
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr,m);
pthread_create(&tid,&attr,(void*)myfunction, myarg);
本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/2eetiUAtedavND8c-sQM5w

猜你喜歡