pthread多線程編程整理
|
＃i nclude <pthread.h>
int pthread_equal(pthread_t tid1, pthread_t tid2)
|
|
＃i nclude <pthread.h>
pthread _t pthread_self(void);
|
|
＃i nclude <pthread.h>
int pthread_create(
pthread_t *restrict tidp,
const pthread_attr_t *restrict attr,
void *(*start_rtn)(void *), void *restrict arg);
|
|
＃i nclude <pthread.h>
void pthread_exit(void *rval_ptr);
int pthread_join(pthread_t thread, void **rval_ptr);
|
|
＃i nclude <pthread.h>
void pthread_cancel(pthread_t tid)
|
|
＃i nclude <pthread.h>
void pthread_cleanup_push(void (*rtn)(void *), void *arg);
void pthread_cleanup_pop(int execute);
|
|
void *thread_func(void *arg)
{
pthread_cleanup_push(cleanup, “handler”)
// do something
Pthread_cleanup_pop(0);
return((void *)0)；
}
|
|
Process Primitive
|
Thread Primitive
|
Description
|
|
fork
|
pthread_create
|
創建新的控制流
|
|
exit
|
pthread_exit
|
退出已有的控制流
|
|
waitpid
|
pthread_join
|
等待控制流并獲得結束代碼
|
|
atexit
|
pthread_cleanup_push
|
注冊在控制流退出時候被調用的函數
|
|
getpid
|
pthread_self
|
獲得控制流的id
|
|
abort
|
pthread_cancel
|
請求非正常退出
|
|
＃i nclude <pthread.h>
int pthread_detach(pthread_t tid);
|
|
＃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);
|
|
＃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);
|
|
＃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);
|
|
＃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);
|
|
＃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);
|
|
＃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);
|
|
struct timespec {
time_t tv_sec; /* seconds */
long tv_nsec; /* nanoseconds */
};
|
|
＃i nclude <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
|
在傳統的Unix模型中，當一個進程需要由另一個實體執行某件事時，該進程派生（fork）一個子進程，讓子進程去進行處理。Unix下的大多數網絡服務器程序都是這么編寫的，即父進程接受連接，派生子進程，子進程處理與客戶的交互。
雖然這種模型很多年來使用得很好，但是fork時有一些問題：
1. fork是昂貴的。內存映像要從父進程拷貝到子進程，所有描述字要在子進程中復制等等。目前有的Unix實現使用一種叫做寫時拷貝（copy－on－write）的技術，可避免父進程數據空間向子進程的拷貝。盡管有這種優化技術，fork仍然是昂貴的。
2. fork子進程后，需要用進程間通信（IPC）在父子進程之間傳遞信息。Fork之前的信息容易傳遞，因為子進程從一開始就有父進程數據空間及所有描述字的拷貝。但是從子進程返回信息給父進程需要做更多的工作。
線程有助于解決這兩個問題。線程有時被稱為輕權進程（lightweight process），因為線程比進程“輕權”，一般來說，創建一個線程要比創建一個進程快10～100倍。
一個進程中的所有線程共享相同的全局內存，這使得線程很容易共享信息，但是這種簡易性也帶來了同步問題。
一個進程中的所有線程不僅共享全局變量，而且共享：進程指令、大多數數據、打開的文件（如描述字）、信號處理程序和信號處置、當前工作目錄、用戶ID和組ID。但是每個線程有自己的線程ID、寄存器集合（包括程序計數器和棧指針）、棧（用于存放局部變量和返回地址）、error、信號掩碼、優先級。在Linux中線程編程符合Posix.1標準，稱為Pthreads。所有的pthread函數都以pthread_開頭。以下先講述5個基本線程函數，在調用它們前均要包括pthread.h頭文件。然后再給出用它們編寫的一個TCP客戶/服務器程序例子。
第一個函數：
int pthread_create (pthread_t ＊tid,const pthread_attr_t ＊attr,void ＊ (＊func)(void ＊),void ＊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。
第二個函數：
int pthread_join(pthread_t tid,void ＊＊status);
|
該函數等待一個線程終止。把線程和進程相比，pthread_creat類似于fork，而 pthread_join類似于waitpid。我們必須要等待線程的tid，很可惜，我們沒有辦法等待任意一個線程結束。如果status指針非空，線程的返回值（一個指向某個對象的指針）將存放在status指向的位置。
第三個函數：
pthread_t pthread_self(void);
|
線程都有一個ID以在給定的進程內標識自己。線程ID由pthread_creat返回，我們可以pthread_self取得自己的線程ID。
第四個函數：
int
pthread_detach
(pthread_t tid);
|
線程或者是可匯合的（joinable）或者是脫離的（detached）。當可匯合的線程終止時，其線程ID和退出狀態將保留，直到另外一個線程調用pthread_join。脫離的線程則像守護進程：當它終止時，所有的資源都釋放，我們不能等待它終止。如果一個線程需要知道另一個線程什么時候終止，最好保留第二個線程的可匯合性。 Pthread_detach 函數將指定的線程變為脫離的。該函數通常被想脫離自己的線程調用，如： pthread_detach (pthread_self ( ));
第五個函數：
void pthread_exit(void ＊status);
|
該函數終止線程。如果線程未脫離，其線程ID和退出狀態將一直保留到調用進程中的某個其他線程調用pthread_join函數。指針status不能指向局部于調用線程的對象，因為線程終止時這些對象也消失。有兩種其他方法可使線程終止：
1. 啟動線程的函數（pthread_creat的第3個參數）返回。既然該函數必須說明為返回一個void指針，該返回值便是線程的終止狀態。
2. 如果進程的main函數返回或者任何線程調用了exit，進程將終止，線程將隨之終止。
一.pthread_create()之前的屬性設置
1．線程屬性設置
我們用pthread_create函數創建一個線程，在這個線程中，我們使用默認參數，即將該函數的第二個參數設為NULL。的確，對大多數程序來說，使用默認屬性就夠了，但我們還是有必要來了解一下線程的有關屬性。
屬性結構為pthread_attr_t，它同樣在頭文件pthread.h中定義，屬性值不能直接設置，須使用相關函數進行操作，初始化的函數為
pthread_attr_init
，這個函數必須在pthread_create函數之前調用。屬性對象主要包括是否綁定、是否分離、
堆棧地址、堆棧大小、優先級。默認的屬性為非綁定、非分離、缺省的堆棧、與父進程同樣級別的優先級。
2．綁定
關于線程的綁定，牽涉到另外一個概念：輕進程（LWP：Light Weight Process）。輕進程可以理解為內核線程，它位于用戶層和系統層之間。系統對線程資源的分配、對線程的控制是通過輕進程來實現的，一個輕進程可以控制一個或多個線程。默認狀況下，啟動多少輕進程、哪些輕進程來控制哪些線程是由系統來控制的，這種狀況即稱為非綁定的。綁定狀況下，則顧名思義，即某個線程固定的"綁"在一個輕進程之上。被綁定的線程具有較高的響應速度，這是因為CPU時間片的調度是面向輕進程的，綁定的線程可以保證在需要的時候它總有一個輕進程可用。通過設置被綁定的輕進程的優先級和調度級可以使得綁定的線程滿足諸如實時反應之類的要求。
設置線程綁定狀態的函數為 pthread_attr_setscope，它有兩個參數，第一個是指向屬性結構的指針，第二個是綁定類型，它有兩個取值： PTHREAD_SCOPE_SYSTEM（綁定的）和PTHREAD_SCOPE_PROCESS（非綁定的）。下面的代碼即創建了一個綁定的線程。
＃i nclude <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．線程分離狀態 線程的分離狀態決定一個線程以什么樣的方式來終止自己。非分離的線程終止時，其線程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返回。設置一段等待時間，是在多線程編程里常用的方法。
4．優先級 它存放在結構sched_param中。用函數pthread_attr_getschedparam和函數 pthread_attr_setschedparam進行存放，一般說來，我們總是先取優先級，對取得的值修改后再存放回去。下面即是一段簡單的例子。
＃i nclude <pthread.h>
＃i nclude <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);
二．線程數據處理 和進程相比，線程的最大優點之一是數據的共享性，各個進程共享父進程處沿襲的數據段，可以方便的獲得、修改數據。但這也給多線程編程帶來了許多問題。我們必須當心有多個不同的進程訪問相同的變量。許多函數是不可重入的，即同時不能運行一個函數的多個拷貝（除非使用不同的數據段）。在函數中聲明的靜態變量常常帶來問題，函數的返回值也會有問題。因為如果返回的是函數內部靜態聲明的空間的地址，則在一個線程調用該函數得到地址后使用該地址指向的數據時，別的線程可能調用此函數并修改了這一段數據。在進程中共享的變量必須用關鍵字volatile來定義，這是為了防止編譯器在優化時（如gcc中使用-OX參數）改變它們的使用方式。為了保護變量，我們必須使用信號量、互斥等方法來保證我們對變量的正確使用。
1．線程數據 在單線程的程序里，有兩種基本的數據：全局變量和局部變量。但在多線程程序里，還有第三種數據類型：線程數據（TSD: Thread-Specific Data）。它和全局變量很象，在線程內部，各個函數可以象使用全局變量一樣調用它，但它對線程外部的其它線程是不可見的。例如我們常見的變量 errno，它返回標準的出錯信息。它顯然不能是一個局部變量，幾乎每個函數都應該可以調用它；但它又不能是一個全局變量，否則在 A線程里輸出的很可能是B線程的出錯信息。要實現諸如此類的變量，我們就必須使用線程數據。我們為每個線程數據創建一個鍵，它和這個鍵相關聯，在各個線程里，都使用這個鍵來指代線程數據，但在不同的線程里，這個鍵代表的數據是不同的，在同一個線程里，它代表同樣的數據內容。
和線程數據相關的函數主要有4個：創建一個鍵；為一個鍵指定線程數據；從一個鍵讀取線程數據；刪除鍵。
創建鍵的函數原型為：
int pthread_key_create __P ((pthread_key_t *__key,void (*__destr_function) (void *))); 第一個參數為指向一個鍵值的指針，第二個參數指明了一個destructor函數，如果這個參數不為空，那么當每個線程結束時，系統將調用這個函數來釋放綁定在這個鍵上的內存塊。這個函數常和函數pthread_once ((pthread_once_t*once_control, void (*initroutine) (void)))一起使用，為了讓這個鍵只被創建一次。函數pthread_once聲明一個初始化函數，第一次調用pthread_once時它執行這個函數，以后的調用將被它忽略。
int pthread_key_delete(pthread_key_t *key);
該函數用于刪除一個由pthread_key_create 函數調用創建的鍵。調用成功返回值為0，否則返回錯誤代碼。
在下面的例子中，我們創建一個鍵，并將它和某個數據相關聯。我們要定義一個函數 createWindow，這個函數定義一個圖形窗口（數據類型為Fl_Window *，這是圖形界面開發工具FLTK中的數據類型）。由于各個線程都會調用這個函數，所以我們使用線程數據。
/* 聲明一個鍵*/
pthread_key_t myWinKey;
/* 函數 createWindow */
void createWindow ( void ) {
Fl_Window * win;
static pthread_once_t once= PTHREAD_ONCE_INIT;
/* 調用函數createMyKey，創建鍵*/
pthread_once ( & once, createMyKey) ;
/*win指向一個新建立的窗口*/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/* 對此窗口作一些可能的設置工作，如大小、位置、名稱等*/
setWindow(win);
/* 將窗口指針值綁定在鍵myWinKey上*/
pthread_setpecific ( myWinKey, win);
}
/* 函數 createMyKey，創建一個鍵，并指定了destructor */
void createMyKey ( void ) {
pthread_keycreate(&myWinKey, freeWinKey);
}
/* 函數 freeWinKey，釋放空間*/
void freeWinKey ( Fl_Window * win){
delete win;
}
這樣，在不同的線程中調用函數createMyWin，都可以得到在線程內部均可見的窗口變量，這個變量通過函數 pthread_getspecific得到。在上面的例子中，我們已經使用了函數pthread_setspecific來將線程數據和一個鍵綁定在一起。這兩個函數的原型如下：
int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer)); 該函數設置一個線程專有數據的值，賦給由pthread_key_create 創建的鍵，調用成功返回值為0，否則返回錯誤代碼。
void *pthread_getspecific __P ((pthread_key_t __key)); 該函數獲得綁定到指定鍵上的值。調用成功，返回給定參數key 所對應的數據。如果沒有數據連接到該鍵，則返回NULL。
這兩個函數的參數意義和使用方法是顯而易見的。要注意的是，用pthread_setspecific為一個鍵指定新的線程數據時，必須自己釋放原有的線程數據以回收空間。這個過程函數pthread_key_delete用來刪除一個鍵，這個鍵占用的內存將被釋放，但同樣要注意的是，它只釋放鍵占用的內存，并不釋放該鍵關聯的線程數據所占用的內存資源，而且它也不會觸發函數pthread_key_create中定義的destructor函數。線程數據的釋放必須在釋放鍵之前完成。
2．互斥鎖 假設各個現成向同一個文件順序寫入數據，最后得到的結果是不可想象的。所以用互斥鎖來保證一段時間內只有一個線程在執行一段代碼。
使用int pthread_mutex_lock鎖住互斥鎖，使用int pthread_mutex_unlock解瑣。
如果我們試圖為一個已被其他線程鎖住的互斥鎖加鎖，程序便會阻塞直到該互斥對象解鎖。
如果在共享內存中分配一個互斥鎖，我們必須在運行時調用ptgread_mutex_init函數盡心初始化。
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);
}
}
函數 pthread_mutex_init用來生成一個互斥鎖。NULL參數表明使用默認屬性。如果需要聲明特定屬性的互斥鎖，須調用函數 pthread_mutexattr_init。函數pthread_mutexattr_setpshared和函數 pthread_mutexattr_settype用來設置互斥鎖屬性。前一個函數設置屬性pshared，它有兩個取值， PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用來不同進程中的線程同步，后者用于同步本進程的不同線程。在上面的例子中，我們使用的是默認屬性PTHREAD_PROCESS_ PRIVATE。后者用來設置互斥鎖類型，可選的類型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、 PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它們分別定義了不同的上所、解鎖機制，一般情況下，選用最后一個默認屬性。
需要注意的是在使用互斥鎖的過程中很有可能會出現死鎖：兩個線程試圖同時占用兩個資源，并按不同的次序鎖定相應的互斥鎖，例如兩個線程都需要鎖定互斥鎖1和互斥鎖2，a線程先鎖定互斥鎖1，b 線程先鎖定互斥鎖2，這時就出現了死鎖。此時我們可以使用函數 pthread_mutex_trylock，它是函數pthread_mutex_lock的非阻塞版本，當它發現死鎖不可避免時，它會返回相應的信息，程序員可以針對死鎖做出相應的處理。另外不同的互斥鎖類型對死鎖的處理不一樣，但最主要的還是要程序員自己在程序設計注意這一點。
3．條件變量
互斥鎖一個明顯的缺點是它只有兩種狀態：鎖定和非鎖定。而條件變量通過允許線程阻塞和等待另一個線程發送信號的方法彌補了互斥鎖的不足，它常和互斥鎖一起使用。使用時，條件變量被用來阻塞一個線程，當條件不滿足時，線程往往解開相應的互斥鎖并等待條件發生變化。一旦其它的某個線程改變了條件變量，它將通知相應的條件變量喚醒一個或多個正被此條件變量阻塞的線程。這些線程將重新鎖定互斥鎖并重新測試條件是否滿足。一般說來，條件變量被用來進行線承間的同步。
條件變量的結構為pthread_cond_t，函數pthread_cond_init（）被用來初始化一個條件變量。它的原型為：
int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
其中cond是一個指向結構pthread_cond_t的指針，cond_attr是一個指向結構pthread_condattr_t的指針。結構 pthread_condattr_t是條件變量的屬性結構，和互斥鎖一樣我們可以用它來設置條件變量是進程內可用還是進程間可用，默認值是 PTHREAD_ PROCESS_PRIVATE，即此條件變量被同一進程內的各個線程使用。注意初始化條件變量只有未被使用時才能重新初始化或被釋放。
在pthread中，條件變量是一個pthread_cond_t類型的變量，條件變量使用下面兩個函數：
pthread_cond_wait 函數用于阻塞，線程可以被函數pthread_cond_signal和函數 pthread_cond_broadcast喚醒，但是要注意的是，條件變量只是起阻塞和喚醒線程的作用，具體的判斷條件還需用戶給出，例如一個變量是否為0等等，這一點我們從后面的例子中可以看到。線程被喚醒后，它將重新檢查判斷條件是否滿足，如果還不滿足，一般說來線程應該仍阻塞在這里，被等待被下一次喚醒。這個過程一般用while語句實現。
另一個用來阻塞線程的函數是pthread_cond_timedwait（）它比函數pthread_cond_wait（）多了一個時間參數，經歷abstime段時間后，即使條件變量不滿足，阻塞也被解除。
函數pthread_cond_signal（）用來釋放被阻塞在條件變量cond上的一個線程。
函數pthread_cond_broadcast（pthread_cond_t *cond）用來喚醒所有被阻塞在條件變量cond上的線程。這些線程被喚醒后將再次競爭相應的互斥鎖，所以必須小心使用這個函數。
下面是使用函數pthread_cond_wait（）和函數pthread_cond_signal（）的一個簡單的例子:
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（）停止阻塞。
=================================================================================
pthread_mutex_lock
函數名
pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock - lock and unlock a mutex
SYNOPSIS
概要
#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
);
描述
pthread_mutex_lock() 函數鎖住由 mutex 指定的 mutex 對象。如果 mutex 已經被鎖住，調用這個函數的線程阻塞直到 mutex 可用為止。這跟函數返回的時候參數 mutex 指定的 mutex 對象變成鎖住狀態，同時該函數的調用線程成為該 mutex 對象的擁有者。
如果 mutex 對象的 type 是 PTHREAD_MUTEX_NORMAL ，不進行 deadlock detection( 死鎖檢測 ) 。企圖進行 relock 這個 mutex 會導致 deadlock. 如果一個線程對未加鎖的或已經 unlock 的 mutex 對象進行 unlock 操作，結果是不未知的。
如果 mutex 類型是 PTHREAD_MUTEX_ERRORCHECK ，那么將進行錯誤檢查。如果一個線程企圖對一個已經鎖住的 mutex 進行 relock ，將返回一個錯誤。如果一個線程對未加鎖的或已經 unlock 的 mutex 對象進行 unlock 操作，將返回一個錯誤。
如果 mutex 類型是 PTHREAD_MUTEX_RECURSIVE ， mutex 會有一個鎖住次數（ lock count ）的概念。當一個線程成功地第一次鎖住一個 mutex 的時候，鎖住次數（ lock count ）被設置為 1 ，每一次一個線程 unlock 這個 mutex 的時候，鎖住次數（ lock count ）就減 1 。當鎖住次數（ lock count ）減少為 0 的時候，其他線程就能獲得該 mutex 鎖了。如果一個線程對未加鎖的或已經 unlock 的 mutex 對象進行 unlock 操作，將返回一個錯誤。
如果 mutex 類型是 PTHREAD_MUTEX_DEFAULT ，企圖遞歸的獲取這個 mutex 的鎖的結果是不確定的。 unlock 一個不是被調用線程鎖住的 mutex 的結果也是不確定的。企圖 unlock 一個未被鎖住的 mutex 導致不確定的結果。
pthread_mutex_trylock() 調用在參數 mutex 指定的 mutex 對象當前被鎖住的時候立即返回，除此之外， pthread_mutex_trylock() 跟 pthread_mutex_lock() 功能完全一樣。
The pthread_mutex_unlock() 函數釋放有參數 mutex 指定的 mutex 對象的鎖。如果被釋放取決于該 Mutex 對象的類型屬性。如果有多個線程為了獲得該 mutex 鎖阻塞，調用 pthread_mutex_unlock() 將是該 mutex 可用，一定的調度策略將被用來決定哪個線程可以獲得該 mutex 鎖。（在 mutex 類型為 PTHREAD_MUTEX_RECURSIVE 的情況下，只有當 lock count 減為 0 并且調用線程在該 mutex 上已經沒有鎖的時候）（翻譯到這里，才覺得我的這個鎖概念是多么模糊）
如果一個線程在等待一個 mutex 鎖得時候收到了一個 signal, 那么在從 signal handler 返回的時候，該線程繼續等待該 mutex 鎖，就像這個線程沒有被中斷一樣。
返回值
成功， pthread_mutex_lock() 和 pthread_mutex_unlock() 返回 0 ，否則返回一個錯誤的提示碼
pthread_mutex_trylock() 在成功獲得了一個 mutex 的鎖后返回 0 ，否則返回一個錯誤提示碼
錯誤
pthread_mutex_lock() 和 pthread_mutex_unlock() 失敗的時候
mutex 在生成的時候，它的 protocol 屬性的值是 PTHREAD_PRIO_PROTECT ，同時調用線程的優先級 (priority) 比該 mutex 的當前 prority 上限高
pthread_mutex_trylock() 函數在一下情況會失敗：
mutex 已經被鎖住的時候無法再獲取鎖
The pthread_mutex_lock() , pthread_mutex_trylock() and pthread_mutex_unlock() functions may fail if:
pthread_mutex_lock() 函數在一下情況下會失敗：
pthread_mutex_unlock() 函數在以下情況下會失敗：
=================================================================================
pthread_join函數及linux線程
pthread_join使一個線程等待另一個線程結束。
代碼中如果沒有pthread_join主線程會很快結束從而使整個進程結束，從而使創建的線程沒有機會開始執行就結束了。加入pthread_join后，主線程會一直等待直到等待的線程結束自己才結束，使創建的線程有機會執行。
所有線程都有一個線程號，也就是Thread ID。其類型為pthread_t。通過調用pthread_self()函數可以獲得自身的線程號。
下面說一下如何創建一個線程。
通過創建線程，線程將會執行一個線程函數，該線程格式必須按照下面來聲明：
void * Thread_Function(void *)
創建線程的函數如下：
int pthread_create(pthread_t *restrict thread,
const pthread_attr_t *restrict attr,
void *(*start_routine)(void*), void *restrict arg);
下面說明一下各個參數的含義：
thread：所創建的線程號。
attr：所創建的線程屬性，這個將在后面詳細說明。
start_routine：即將運行的線程函數。
art：傳遞給線程函數的參數。
下面是一個簡單的創建線程例子：
|
#include <pthread.h> #include <stdio.h> /* Prints x’s to stderr. The parameter is unused. Does not return. */ void* print_xs (void* unused) { while (1) fputc (‘x’, stderr); return NULL; } /* The main program. */ int main () { pthread_t thread_id; /* Create a new thread. The new thread will run the print_xs function. */ pthread_create (&thread_id, NULL, &print_xs, NULL); /* Print o’s continuously to stderr. */ while (1) fputc (‘o’, stderr); return 0; } |
在編譯的時候需要注意，由于線程創建函數在libpthread.so庫中，所以在編譯命令中需要將該庫導入。命令如下：
gcc –o createthread –lpthread createthread.c
如果想傳遞參數給線程函數，可以通過其參數arg，其類型是void *。如果你需要傳遞多個參數的話，可以考慮將這些參數組成一個結構體來傳遞。另外，由于類型是void *，所以你的參數不可以被提前釋放掉。
下面一個問題和前面創建進程類似，不過帶來的問題回避進程要嚴重得多。如果你的主線程，也就是main函數執行的那個線程，在你其他縣城推出之前就已經退出，那么帶來的bug則不可估量。通過pthread_join函數會讓主線程阻塞，直到所有線程都已經退出。
int pthread_join(pthread_t thread, void **value_ptr);
thread：等待退出線程的線程號。
value_ptr：退出線程的返回值。
下面一個例子結合上面的內容：
|
int main () { pthread_t thread1_id; pthread_t thread2_id; struct char_print_parms thread1_args; struct char_print_parms thread2_args; /* Create a new thread to print 30,000 x’s. */ thread1_args.character = ’x’; thread1_args.count = 30000; pthread_create (&thread1_id, NULL, &char_print, &thread1_args); /* Create a new thread to print 20,000 o’s. */ thread2_args.character = ’o’; thread2_args.count = 20000; pthread_create (&thread2_id, NULL, &char_print, &thread2_args); /* Make sure the first thread has finished. */ pthread_join (thread1_id, NULL); /* Make sure the second thread has finished. */ pthread_join (thread2_id, NULL); /* Now we can safely return. */ return 0; } |
下面說一下前面提到的線程屬性。
在我們前面提到，可以通過pthread_join()函數來使主線程阻塞等待其他線程退出，這樣主線程可以清理其他線程的環境。但是還有一些線程，更喜歡自己來清理退出的狀態，他們也不愿意主線程調用pthread_join來等待他們。我們將這一類線程的屬性稱為detached。如果我們在調用pthread_create()函數的時候將屬性設置為NULL，則表明我們希望所創建的線程采用默認的屬性，也就是jionable。如果需要將屬性設置為detached，則參考下面的例子：
|
#include <stdio.h> #include <pthread.h> void * start_run(void * arg) { //do some work } int main() { pthread_t thread_id; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED); pthread_create(&thread_id,&attr,start_run,NULL); pthread_attr_destroy(&attr); sleep(5); exit(0); } |
在線程設置為joinable后，可以調用pthread_detach()使之成為detached。但是相反的操作則不可以。還有，如果線程已經調用pthread_join()后，則再調用pthread_detach()則不會有任何效果。
線程可以通過自身執行結束來結束，也可以通過調用pthread_exit()來結束線程的執行。另外，線程甲可以被線程乙被動結束。這個通過調用pthread_cancel()來達到目的。
int pthread_cancel(pthread_t thread);
函數調用成功返回0。
當然，線程也不是被動的被別人結束。它可以通過設置自身的屬性來決定如何結束。
線程的被動結束分為兩種，一種是異步終結，另外一種是同步終結。異步終結就是當其他線程調用 pthread_cancel的時候，線程就立刻被結束。而同步終結則不會立刻終結，它會繼續運行，直到到達下一個結束點（cancellation point）。當一個線程被按照默認的創建方式創建，那么它的屬性是同步終結。
通過調用pthread_setcanceltype()來設置終結狀態。
int pthread_setcanceltype(int type, int *oldtype);
state：要設置的狀態，可以為PTHREAD_CANCEL_DEFERRED或者為PTHREAD_CANCEL_ASYNCHRONOUS。
那么前面提到的結束點又是如何設置了？最常用的創建終結點就是調用pthread_testcancel()的地方。該函數除了檢查同步終結時的狀態，其他什么也不做。
上面一個函數是用來設置終結狀態的。還可以通過下面的函數來設置終結類型，即該線程可不可以被終結：
int pthread_setcancelstate(int state, int *oldstate);
state：終結狀態，可以為PTHREAD_CANCEL_DISABLE或者PTHREAD_CANCEL_ENABLE。具體什么含義大家可以通過單詞意思即可明白。
最后說一下線程的本質。其實在Linux中，新建的線程并不是在原先的進程中，而是系統通過一個系統調用clone()。該系統copy了一個和原先進程完全一樣的進程，并在這個進程中執行線程函數。不過這個copy過程和fork不一樣。 copy后的進程和原先的進程共享了所有的變量，運行環境。這樣，原先進程中的變量變動在copy后的進程中便能體現出來。
轉載聲明： 本文轉自 http://blog.163.com/ccbobo_cat/blog/static/320994622009021070933/
=================================================================================
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
