線程概念：

• 典型的UNIX/Linux進程可以看成只有一個控制線程：一個進程在同一時刻只做一件事情。有了多個控制線程后，在程序設(shè)計時可以把進程設(shè)計成在同一時刻做不止一件事，每個線程各自處理獨立的任務(wù)。

• 進程是程序執(zhí)行時的一個實例，是擔(dān)當(dāng)分配系統(tǒng)資源（CPU時間、內(nèi)存等）的基本單位。在面向線程設(shè)計的系統(tǒng)中，進程本身不是基本運行單位，而是線程的容器。程序本身只是指令、數(shù)據(jù)及其組織形式的描述，進程才是程序（那些指令和數(shù)據(jù)）的真正運行實例。

• 首先Linux并不存在真正的線程，Linux的線程是使用進程模擬的。當(dāng)我們需要在一個進程中同時運行多個執(zhí)行流時，我們并不可以開辟多個進程執(zhí)行我們的操作（32位機器里每個進程認(rèn)為它獨享4G的內(nèi)存資源），此時便引入了線程，例如當(dāng)我們既需要下載內(nèi)容，又需要瀏覽網(wǎng)頁時，此時多線程便起了作用。線程是承擔(dān)調(diào)度的基本單位，一個進程可擁有多個線程，它的執(zhí)行力度比進程更加細(xì)致，線程資源共享。

• “進程——資源分配的最小單位，線程——程序執(zhí)行的最小單位”

• 一個進程至少包含一個線程，進程是運行的程序，程序是靜態(tài)的概念，進程是動態(tài)的概念。

• 進程有獨立的地址空間，一個進程崩潰后，在保護模式下不會對其它進程產(chǎn)生影響，而線程只是一個進程中的不同執(zhí)行路徑。線程有自己的堆棧和局部變量，但線程沒有單獨的地址空間，一個線程死掉就等于整個進程死掉，所以多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對于一些要求同時進行并且又要共享某些變量的并發(fā)操作，可以用線程，也可以用進程間的通信。

使用線程的理由：

• 總的來說就是：進程有獨立的地址空間，線程沒有單獨的地址空間（同一進程內(nèi)的線程共享進程的地址空間）。
• 使用多線程的理由之一是和進程相比，它是一種非常"節(jié)儉"的多任務(wù)操作方式。我們知道，在Linux系統(tǒng)下，啟動一個新的進程必須分配給它獨立的地址空間，建立眾多的數(shù)據(jù)表來維護它的代碼段、堆棧段和數(shù)據(jù)段，這是一種"昂貴"的多任務(wù)工作方式。而運行于一個進程中的多個線程，它們彼此之間使用相同的地址空間，共享大部分?jǐn)?shù)據(jù)，啟動一個線程所花費的空間遠(yuǎn)遠(yuǎn)小于啟動一個進程所花費的空間，而且，線程間彼此切換所需的時間也遠(yuǎn)遠(yuǎn)小于進程間切換所需要的時間。據(jù)統(tǒng)計，總的說來，一個進程的開銷大約是一個線程開銷的30倍左右，當(dāng)然，在具體的系統(tǒng)上，這個數(shù)據(jù)可能會有較大的區(qū)別。
• 使用多線程的理由之二是線程間方便的通信機制。對不同進程來說，它們具有獨立的數(shù)據(jù)空間，要進行數(shù)據(jù)的傳遞只能通過通信的方式進行，這種方式不僅費時，而且很不方便。線程則不然，由于同一進程下的線程之間共享數(shù)據(jù)空間，所以一個線程的數(shù)據(jù)可以直接為其它線程所用，這不僅快捷，而且方便。當(dāng)然，數(shù)據(jù)的共享也帶來其他一些問題，有的變量不能同時被兩個線程所修改，有的子程序中聲明為static的數(shù)據(jù)更有可能給多線程程序帶來災(zāi)難性的打擊，這些正是編寫多線程程序時最需要注意的地方。

除了以上所說的優(yōu)點外，不和進程比較，多線程程序作為一種多任務(wù)、并發(fā)的工作方式，當(dāng)然有以下的優(yōu)點：

• 提高應(yīng)用程序響應(yīng)。這對圖形界面的程序尤其有意義，當(dāng)一個操作耗時很長時，整個系統(tǒng)都會等待這個操作，此時程序不會響應(yīng)鍵盤、鼠標(biāo)、菜單的操作，而使用多線程技術(shù)，將耗時長的操作（time consuming）置于一個新的線程，可以避免這種尷尬的情況。
• 使多CPU系統(tǒng)更加有效。操作系統(tǒng)會保證當(dāng)線程數(shù)不大于CPU數(shù)目時，不同的線程運行于不同的CPU上。
• 改善程序結(jié)構(gòu)。一個既長又復(fù)雜的進程可以考慮分為多個線程，成為幾個獨立或半獨立的運行部分，這樣的程序會利于理解和修改。

POSIX線程庫：與線程有關(guān)的函數(shù)構(gòu)成了一個完整的系列，絕大多數(shù)函數(shù)的名字都是以“pthread_”打頭的要使用這些函數(shù)庫，要通過引入頭文件#include<pthread.h>鏈接這些線程函數(shù)庫時要使用編譯器命令的“-lpthread”選項，多線程開發(fā)在 Linux 平臺上已經(jīng)有成熟的 pthread 庫支持。

其涉及的多線程開發(fā)的最基本概念主要包含三點：線程，互斥鎖，條件。其中，線程操作又分線程的創(chuàng)建，退出，等待 3 種。互斥鎖則包括 4 種操作，分別是創(chuàng)建，銷毀，加鎖和解鎖。條件操作有 5 種操作：創(chuàng)建，銷毀，觸發(fā)，廣播和等待。

線程開發(fā)API：

線程的創(chuàng)建：pthread_create()函數(shù)

#include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg); 功能：創(chuàng)建一個新的線程 參數(shù)：thread:指向的內(nèi)存單元被設(shè)置為新創(chuàng)建線程的線程IDattr:設(shè)置線程的屬性，attr為NULL表?示使?用默認(rèn)屬性start_routine:新創(chuàng)建的線程從start_rtn函數(shù)的地址開始運行該函數(shù)只有一個萬能 指針參數(shù)arg，如果需要向start_rtn函數(shù)傳遞的參數(shù)不止一個那么需要把這些參數(shù)放到一個結(jié)構(gòu)中，然后把這個結(jié)構(gòu)的地址作為arg的參數(shù)傳入。 arg:傳給線程啟動函數(shù)的參數(shù)返回值：成功返回0；失敗返回錯誤碼 注意：void*表示指針類型不限制，只要是指針就行 因為pthread并非Linux系統(tǒng)的默認(rèn)庫，而是POSIX線程庫。 在Linux中將其作為一個庫來使用，因此加上 -lpthread（或-pthread）以顯式鏈接該庫。 函數(shù)在執(zhí)行錯誤時的錯誤信息將作為返回值返回，并不修改系統(tǒng)全局變量errno，當(dāng)然也無法使用perror()打印錯誤信息。

線程退出：pthread_exit()函數(shù)

#include <pthread.h> void pthread_exit(void *retval); 功能:使用函數(shù)pthread_exit退出線程，這是線程的主動行為；由于一個進程中的多個線程是共享數(shù)據(jù)段的因此通常在線程退出之后，退出線程所占用的資源并不會隨著線程的終止而得到釋放，但是可以用pthread_join()函數(shù)來同步并釋放資源。 參數(shù)：retval: pthread_exit()調(diào)用線程的返回值，可由其他函數(shù)如pthread_join來檢索獲取。單個線程可以通過以下三種方式退出，在不終止整個進程的情況下停止它的控制流：1）線程只是從啟動例程中返回，返回值是線程的退出碼。2）線程可以被同一進程中的其他線程取消一個線程可以調(diào)用pthread_cancel終止同一進程中的另一個線程。3）線程調(diào)用pthread_exit： 注意：調(diào)用exit()的話，主進程會終止從線程函數(shù)return,這種方法法對主線程不適用從main函數(shù)return相當(dāng)于調(diào)用exit。

線程等待：pthread_join()函數(shù)

#include <pthread.h> int pthread_join(pthread_t thread, void **retval);功能：調(diào)pthread_join()函數(shù)，以阻塞的方式等待thread指定的線程結(jié)束。當(dāng)函數(shù)返回時，被等待線程的資源被收回。如果線程已經(jīng)結(jié)束，那么該函數(shù)會立即返回。并且thread指定的線程必須是joinable的。 參數(shù)：thread: 線程標(biāo)識符，即線程ID，標(biāo)識唯一線程。retval: 用戶定義的指針，用來存儲被等待線程的返回值。退出函數(shù)返回的是一個空指針類型，接受函數(shù)也必須用一個指針來接收。但是函數(shù)給出的參數(shù)是接收指針的地址，即，接收到的指針值寫入給出的地址處的指針變量。返回值：若成功返回0，否則返回錯誤編號為什么要用這個函數(shù)？1、代碼中如果沒有pthread_join，主線程會很快結(jié)束從而使整個進程結(jié)束，從而使創(chuàng)建的線程沒有機會開始執(zhí)行就結(jié)束了。2、在很多情況下，主線程生成并起動了子線程，如果子線程里要進行大量的耗時的運算主線程往往將于子線程之前結(jié)束，但是如果主線程處理完其他的事務(wù)后，需要用到子線程的處理結(jié)果也就是主線程需要等待子線程執(zhí)行完成之后再結(jié)束，這個時候就要用到pthread_join()方法了。即pthread_join()的作用可以這樣理解：主線程等待子線程的終止。也就是在子線程調(diào)用了pthread_join()方法后面的代碼只有等到子線程結(jié)束了才能執(zhí)行。

信號發(fā)送函數(shù)：pthread_cancel()

#include <pthread.h> int pthread_cancel(pthread_t thread) 功能：發(fā)送終止信號給thread線程 參數(shù)：thread：要發(fā)送的目標(biāo)線程id返回值：如果成功則返回0，否則為非0值。函數(shù)說明：pyhread_cancel函數(shù)只是給線程發(fā)送了一個請求該請求是希望可以將該線程終止。所以對于該請求的話，只是對于線程的一個建議線程也可能就不會立即終止，會繼續(xù)運行，直到運行到取消點的時候該線程才會退出

取消點的理解：

• 取消點是線程檢查是否被取消并按照請求進行動作的一個位置.
• 取消點是如何出現(xiàn)的呢？
• 對于取消點對于使用某些函數(shù)就會出現(xiàn)取消點
• 例如：sleep，wait，waitpid，waitid，send等函數(shù)

設(shè)置取消的狀態(tài)函數(shù):pthread_setcancelstate()

#include <pthread.h> pthread_setcancelstate(int state, int* oldstate); 功能：這個函數(shù)可以設(shè)置取消的狀態(tài)，有兩種狀態(tài)PTHREAD_CANCEL_ENABLE（可取消狀態(tài)）PTHREAD_CANCEL_DISABLE（不可取消狀態(tài)）。 參數(shù)：state：將當(dāng)前狀態(tài)改為stateoldstate：將該線程原先的狀態(tài)放到oldtype所指向的空間里面 返回值：成功返回0，失敗返回錯誤碼這兩步是一個原子操作。對于pthread_cancel函數(shù)默認(rèn)的是PTHREAD_CANCEL_ENABLE可取消狀態(tài)。當(dāng)狀態(tài)設(shè)為PTHREAD_CANCEL_DISABLE時，對于pthread_cancel的調(diào)用并不會殺死線程。相反，該取消請求對于這個線程還處于掛起狀態(tài)（也就是未決），直到線程的取消狀態(tài)變?yōu)镻THREAD_CANCEL_ENABLE時線程將在下一個取消點上對所有的掛起請求進行處理。

設(shè)置取消類型函數(shù):pthread_setcanceltype()

#include <thread.h> int pthread_testcanceltype(int type, int* oldtype);參數(shù)：type：將取消的類型設(shè)置為typeoldtype：將該線程的取消類型放到oldtype所指向的空間里面返回值：成功返回0，失敗返回錯誤碼1、我們默認(rèn)的取消類型是推遲取消。也就是會運行到取消點再取消對于可以設(shè)置的取消類型有PTHREAD_CANCEL_DEFERRED（推遲取消），也就是默認(rèn)的取消類型。 2、PTHRAED_CANCEL_ASYNCHRONOUS（異步取消），采用異步取消之后，線程可以在任意時間取消，不是非得到取消點才可以取消。

加取消點函數(shù):pthread_testcancel()

• 對于一個線程沒有調(diào)用上面說的可以產(chǎn)生取消點函數(shù)，那么該線程就沒有取消點，也就無法被取消，取消請求也就會一直掛起，不會被線程處理。
• 所以如果要對線程進行取消請求的話，可以自己給線程加上取消點
• pthread_testcancel函數(shù)就可以在程序自己加上取消點。

#include <thread.h> void pthread_testcancel(void);調(diào)用pthread_testcancel函數(shù)，如果有某個取消請求正處于掛起狀態(tài)的話 而且取消并沒有被設(shè)置為無效，那么該線程就會立即被取消。 但是，如果取消被設(shè)置為無效的話，那么pthread_testcancel函數(shù)調(diào)用就沒與效果了。

線程脫離：pthread_detach()函數(shù)
一個線程或者是可匯合（joinable，默認(rèn)值），或者是脫離的（detached）。當(dāng)一個可匯合的線程終止時，它的線程ID和退出狀態(tài)將留存到另一個線程對它調(diào)用pthread_join。脫離的線程卻像守護進程，當(dāng)它們終止時，所有相關(guān)的資源都被釋放，我們不能等待它們終止。

#include <pthread.h> int pthread_detach(pthread_t thread); 作用：從狀態(tài)上實現(xiàn)線程分離，注意不是指該線程獨自占用地址空間。本函數(shù)通常由想讓自己脫離的線程使用參數(shù)：thread：線程標(biāo)識符返回值：若成功返回0，否則返回錯誤編號

線程分離狀態(tài)： 指定該狀態(tài)，線程主動與主控線程斷開關(guān)系。線程結(jié)束后（不會產(chǎn)生僵尸線程），其退出狀態(tài)不由其他線程獲取，而直接自己自動釋放（自己清理掉PCB的殘留資源）。網(wǎng)絡(luò)、多線程服務(wù)器常用。

• 進程若有該機制，將不會產(chǎn)生僵尸進程。僵尸進程的產(chǎn)生主要由于進程死后，大部分資源被釋放，一點殘留資源仍存于系統(tǒng)中，導(dǎo)致內(nèi)核認(rèn)為該進程仍存在。（注意進程沒有這一機制）
• 也可使用 pthread_create函數(shù)參2(線程屬性)來設(shè)置線程分離。
• 一般情況下，線程終止后，其終止?fàn)顟B(tài)一直保留到其它線程調(diào)用pthread_join獲取它的狀態(tài)為止（或者進程終止被回收了）。但是線程也可以被置為detach狀態(tài)，這樣的線程一旦終止就立刻回收它占用的所有資源，而不保留終止?fàn)顟B(tài)。不能對一個已經(jīng)處于detach狀態(tài)的線程調(diào)用pthread_join，這樣的調(diào)用將返回EINVAL錯誤（22號錯誤）。也就是說，如果已經(jīng)對一個線程調(diào)用了pthread_detach就不能再調(diào)用pthread_join了。

線程ID獲取：pthread_self()函數(shù)

#include <pthread.h> pthread_t pthread_self(void);返回：調(diào)用線程的ID，可以和pthread_detach函數(shù)配合使用

線程ID比較：pthread_equal()函數(shù)

#include <pthread.h> int pthread_equal(pthread_t tid1, pthread_t tid2);返回：若相等則返回非0值，否則返回0

pthread_create()函數(shù)、pthread_exit()函數(shù)和pthread_join()函數(shù)搭配實例：

#include<stdio.h> #include <pthread.h> #include<stdlib.h> struct num {int a,b; }; void *add(void* arg)//函數(shù)多個參數(shù)時用結(jié)構(gòu)體 {struct num *p;p=(struct num*)malloc(128);p->a=12;p->b=18;//這種方式是在堆上面開辟了空間，如果不是手動釋放將一直存在//但是在得到數(shù)據(jù)后最好將內(nèi)存釋放否則可能造成內(nèi)存泄露/*struct num p;p.a=1;p.b=2;這種方式傳參會在函數(shù)調(diào)用時將內(nèi)存空間釋放，得不到準(zhǔn)確的值*/printf("a=%d\n",((struct num*)arg)->a);printf("b=%d\n",((struct num*)arg)->b);printf("a+b=%d\n",((struct num*)arg)->a+((struct num*)arg)->b);printf("son id=%ld\n",(unsigned long)pthread_self());pthread_exit((void*)&p); } int main() {pthread_t td;int retnu;struct num son;struct num* sonret;son.a=10;son.b=-3;retnu=pthread_create(&td,NULL,add,(void*)&son);if(retnu!=0){printf("pthread create fail\n");}pthread_join(td,(void**)&sonret);//退出函數(shù)返回的是一個空指針類型，接受函數(shù)也必須用一個指針來接收。//但是函數(shù)給出的參數(shù)是接收指針的地址，即，接收到的指針值寫入給出的地址處的指針變量。printf("進程結(jié)束\n");printf("son return:a=%d,b=%d\n",((struct num*)sonret)->a,((struct num*)sonret)->b);printf("main id=%ld,td=%ld\n",(unsigned long)pthread_self(),(unsigned long)td);return 0; }

實例驗證子線程和主線程共享資源：

#include<stdio.h> #include <pthread.h> int i=1; void * func1(void*arg) {i=i+1;printf("thread1 i=%d\n",i);pthread_exit((void*)&i); } void * func2(void*arg) {i=i+1;printf("thread2 i=%d\n",i);pthread_exit((void*)&i); } int main() {pthread_t t1;pthread_t t2;int t1return;int t2return;int* th1;int* th2;t1return=pthread_create(&t1,NULL,func1,(void*)&i);if(t1return!=0){printf("pthread create fail\n");}pthread_join(t1,(void**)&th1);printf("thread1 return:i=%d\n",*(int *)th1);t2return=pthread_create(&t2,NULL,func2,(void*)&i);if(t2return!=0){printf("pthread create fail\n");}pthread_join(t2,(void**)&th2);printf("thread2 return:i=%d\n",*(int *)th2);printf("main thread i=%d\n",i);return 0; }

對于多線程程序來說，我們往往需要對這些多線程進行同步。同步（synchronization）是指在一定的時間內(nèi)只允許某一個線程訪問某個資源。而在此時間內(nèi)，不允許其它的線程訪問該資源。我們可以通過互斥鎖（mutex），條件變量（condition variable）和讀寫鎖（reader-writer lock）來同步資源。

互斥鎖：

• 互斥量（mutex）從本質(zhì)上來說是一把鎖，在訪問共享資源前對互斥量進行加鎖，在訪問完成后釋放互斥量上的鎖。對互斥量進行加鎖后，任何其他試圖再次對互斥量加鎖的線程將會被阻塞直到當(dāng)前線程釋放該互斥鎖。如果釋放互斥鎖時有多個線程阻塞，所有在該互斥鎖上的阻塞線程都會變成可運行狀態(tài)，第一個變?yōu)榭蛇\行狀態(tài)的線程可以對互斥量加鎖，其他線程將會看到互斥鎖依然被鎖住，只能回去等待它重新變?yōu)榭捎谩Ｔ谶@種方式下，每次只有一個線程可以向前運行。
• 在設(shè)計時需要規(guī)定所有的線程必須遵守相同的數(shù)據(jù)訪問規(guī)則。只有這樣，互斥機制才能正常工作。操作系統(tǒng)并不會做數(shù)據(jù)訪問的串行化。如果允許其中的某個線程在沒有得到鎖的情況下也可以訪問共享資源，那么即使其它的線程在使用共享資源前都獲取了鎖，也還是會出現(xiàn)數(shù)據(jù)不一致的問題。
• 互斥變量用pthread_mutex_t數(shù)據(jù)類型表示。在使用互斥變量前必須對它進行初始化，可以把它置為常量PTHREAD_MUTEX_INITIALIZER（只對靜態(tài)分配的互斥量），也可以通過調(diào)用pthread_mutex_init函數(shù)進行初始化。如果動態(tài)地分配互斥量（例如通過調(diào)用malloc函數(shù)），那么在釋放內(nèi)存前需要調(diào)用pthread_mutex_destroy。
• 在使用互斥鎖前，需要定義互斥鎖(全局變量)，定義互斥鎖對象形式為：pthread_mutex_t lock;
• 還可以用宏 PTHREAD_MUTEX_INITIALIZER 來初始化靜態(tài)分配的互斥鎖，如下：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
• 使用互斥鎖能保證在一個線程內(nèi)的代碼跑完后再去跑別的線程的代碼。

創(chuàng)建互斥鎖：

#include <pthread.h> int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); 功能：該函數(shù)用于C函數(shù)的多線程編程中，互斥鎖的初始化。pthread_mutex_init()函數(shù)是以動態(tài)方式創(chuàng)建互斥鎖的。 參數(shù)：mutex 是指向要初始化的互斥鎖的指針。參數(shù)attr指定了新建互斥鎖的屬性。如果參數(shù)attr為NULL則使用默認(rèn)的互斥鎖屬性，默認(rèn)屬性為快速互斥鎖 。互斥鎖的屬性在創(chuàng)建鎖的時候指定，在LinuxThreads實現(xiàn)中僅有一個鎖類型屬性不同的鎖類型在試圖對一個已經(jīng)被鎖定的互斥鎖加鎖時表現(xiàn)不同。返回值：函數(shù)成功完成之后會返回零，其他任何返回值都表示出現(xiàn)了錯誤。函數(shù)成功執(zhí)行后，互斥鎖被初始化為鎖住態(tài)。

互斥鎖屬性：

互斥鎖的屬性在創(chuàng)建鎖的時候指定，在LinuxThreads實現(xiàn)中僅有一個鎖類型屬性，不同的鎖類型在試圖對一個已經(jīng)被鎖定的互斥鎖加鎖時表現(xiàn)不同。當(dāng)前（glibc2.2.3,linuxthreads0.9）有四個值可供選擇：

• PTHREAD_MUTEX_TIMED_NP，這是缺省值，也就是普通鎖。當(dāng)一個線程加鎖以后，其余請求鎖的線程將形成一個等待隊列，并在解鎖后按優(yōu)先級獲得鎖。這種鎖策略保證了資源分配的公平性。
• PTHREAD_MUTEX_RECURSIVE_NP，嵌套鎖，允許同一個線程對同一個鎖成功獲得多次，并通過多次unlock解鎖。如果是不同線程請求，則在加鎖線程解鎖時重新競爭。
• PTHREAD_MUTEX_ERRORCHECK_NP，檢錯鎖，如果同一個線程請求同一個鎖，則返回EDEADLK，否則與PTHREAD_MUTEX_TIMED_NP類型動作相同。這樣就保證當(dāng)不允許多次加鎖時不會出現(xiàn)最簡單情況下的死鎖。
• PTHREAD_MUTEX_ADAPTIVE_NP，適應(yīng)鎖，動作最簡單的鎖類型，僅等待解鎖后重新競爭。

互斥鎖銷毀:pthread_mutex_destroy()

#include <pthread.h> int pthread_mutex_destroy( pthread_mutex_t * mutex); 參數(shù)：指向要初始化的互斥鎖的指針 返回值：成功后都返回 0，否則返回錯誤編號以指名錯誤。

加鎖函數(shù)：pthread_mutex_lock（）

#include <pthread.h> int pthread_mutex_lock(pthread_mutex_t* mutex); int pthread_mutex_trylock(pthread_mutex_t* mutex); 功能：描述 pthread_mutex_lock()函數(shù)鎖住由mutex指定的mutex 對象。pthread_mutex_trylock()調(diào)用在參數(shù)mutex指定的mutex對象當(dāng)前被鎖住的時候立即返回除此之外，pthread_mutex_trylock()跟pthread_mutex_lock()功能完全一樣。參數(shù)：指向要操作的的mutex對象返回值：pthread_mutex_lock() 成功：返回0，否則返回一個錯誤的提示碼 pthread_mutex_trylock() 在成功獲得了一個mutex的鎖后返回0，否則返回一個錯誤提示碼錯誤

解鎖函數(shù)：pthread_mutex_unlock()

#include <pthread.h> int pthread_mutex_unlock(pthread_mutex_t* mutex); 參數(shù)：指向要操作的的mutex對象 返回值: 成功則返回0, 出錯則返回錯誤編號.

函數(shù)的綜合應(yīng)用：

#include<stdio.h> #include <pthread.h> #include <unistd.h> int i=1; pthread_mutex_t mutex; void * func1(void*arg) {pthread_mutex_lock(&mutex);while(1){i=i+1;printf("thread1 i=%d\n",i);sleep(2);if(i==7){pthread_mutex_unlock(&mutex);pthread_exit((void*)&i);}} } void * func2(void*arg) {pthread_mutex_lock(&mutex);while(1){i=i+1;printf("thread2 i=%d\n",i);sleep(2);if(i==13){pthread_mutex_unlock(&mutex);pthread_exit((void*)&i);}}} } int main() {pthread_t t1;pthread_t t2;int t1return;int t2return;int* th1;int* th2;pthread_mutex_init(&mutex,NULL);t1return=pthread_create(&t1,NULL,func1,(void*)&i);if(t1return!=0){printf("pthread create fail\n");}sleep(2);pthread_mutex_lock(&mutex);for(;;){i++;printf("main thread i=%d\n",i);sleep(2);if(i==10){pthread_mutex_unlock(&mutex);break;}}pthread_join(t1,(void**)&th1);printf("thread1 return:i=%d\n",*(int *)th1);t2return=pthread_create(&t2,NULL,func2,(void*)&i);if(t2return!=0){printf("pthread create fail\n");}pthread_join(t2,(void**)&th2);printf("thread2 return:i=%d\n",*(int *)th2);pthread_mutex_destroy(&mutex);printf("main over\n");return 0; } 以下是程序每次執(zhí)行的順序： thread1 i=2 thread1 i=3 thread1 i=4 thread1 i=5 thread1 i=6 thread1 i=7 main thread i=8 main thread i=9 main thread i=10 thread1 return:i=10 thread2 i=11 thread2 i=12 thread2 i=13 thread2 return:i=13 main over

通過chmod改變文件權(quán)限
可以寫一個腳本來驗證上述代碼，只需要將寫好的文件加上可執(zhí)行權(quán)限即可。

什么條件下可能造成死鎖：

• 在線程一里面想先獲取鎖一，然后獲取鎖二，在線程二里面想先獲取鎖二再獲取鎖一，如果在線程一獲取鎖一并且沒有解鎖時，同時未獲得鎖二，如果此時線程二獲得了鎖二那么將造成死鎖。

條件變量：

• 條件變量是線程另一可用的同步機制。條件變量給多個線程提供了一個會合的場所。條件變量與互斥量一起使用時，允許線程以無競爭的方式等待特定的條件發(fā)生。
• 條件本身是由互斥量保護的。線程在改變條件狀態(tài)前必須首先鎖住互斥量，其他線程在獲得互斥量之前不會察覺到這種改變，因為必須鎖定互斥量以后才能計算條件。
• 條件變量使用之前必須首先初始化，pthread_cond_t數(shù)據(jù)類型代表的條件變量可以用兩種方式進行初始化，可以把常量PTHREAD_COND_INITIALIZER賦給靜態(tài)分配的條件變量，但是如果條件變量是動態(tài)分配的，可以使用pthread_cond_destroy函數(shù)對條件變量進行去除初始化（deinitialize）。
• 注意： 不能用多個線程初始化同一個條件變量，當(dāng)一個線程要使用條件變量的時候確保它是未被使用的。

創(chuàng)建及銷毀條件變量：

#include <pthread.h> int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); int pthread_cond_destroy(pthread_cond_t*cond);注銷一個條件變量需要調(diào)用pthread_cond_destroy() 只有在沒有線程在該條件變量上等待的時候才能注銷這個條件變量，否則返回EBUSY。參數(shù)：cond：指向定義的cond變量參數(shù)attr為空指針時，函數(shù)創(chuàng)建的是一個缺省的條件變量。否則條件變量的屬性將由attr中的屬性值來決定返回值：若成功執(zhí)行，函數(shù)pthread_cond_init()將返回零，并把新建條件變量的id放在cond變量中否則，將返回一個代表錯誤的錯誤碼。

等待：

• 等待條件有兩種方式：無條件等待pthread_cond_wait()和計時等待pthread_cond_timedwait()
• 其中計時等待方式如果在給定時刻前條件沒有滿足，則返回ETIMEOUT，結(jié)束等待
• 無論哪種等待方式，都必須和一個互斥鎖配合，以防止多個線程同時請求pthread_cond_wait()（或pthread_cond_timedwait()，下同）的競爭條件（Race Condition）。mutex互斥鎖必須是普通鎖（PTHREAD_MUTEX_TIMED_NP）或者適應(yīng)鎖（PTHREAD_MUTEX_ADAPTIVE_NP），且在調(diào)用pthread_cond_wait()前必須由本線程加鎖（pthread_mutex_lock()），而在更新條件等待隊列以前，mutex保持鎖定狀態(tài)，并在線程掛起進入等待前解鎖。在條件滿足從而離開pthread_cond_wait()之前，mutex將被重新加鎖，以與進入pthread_cond_wait()前的加鎖動作對應(yīng)。
• 激發(fā)條件有兩種形式，pthread_cond_signal()激活一個等待該條件的線程，存在多個等待線程時按入隊順序激活其中一個；而pthread_cond_broadcast()則激活所有等待線程。

#include <pthread.h> int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); int pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * mutex, cond struct timespec * timeout); 返回：若成功返回0，否則返回錯誤編號

觸發(fā):

#include <pthread.h> int pthread_cond_signal(pthread_cond_t* cond); int pthread_cond_broadcast(pthread_cond_t* cond);返回：若成功返回0，否則返回錯誤編號這兩個函數(shù)可以用于通知線程條件已經(jīng)滿足。pthread_cond_signal函數(shù)將喚醒等待該條件的某個線程 而pthread_cond_broadcast函數(shù)將喚醒等待該條件的所有進程。

互斥鎖和條件變量綜合使用：

#include<stdio.h> #include <pthread.h> #include <unistd.h> int i=0; pthread_cond_t cond; pthread_mutex_t mutex; void * func1(void*arg) {printf("線程一運行\(zhòng)n");while(1){pthread_mutex_lock(&mutex);pthread_cond_wait(&cond,&mutex);if(i==7){printf("新的循環(huán)\n");i=0;pthread_mutex_unlock(&mutex);}}pthread_exit((void*)&i); } void * func2(void*arg) {printf("線程二運行\(zhòng)n");while(1){pthread_mutex_lock(&mutex);i=i+1;printf("t2:i=%d\n",i);if(i==7){pthread_cond_signal(&cond);//break;}pthread_mutex_unlock(&mutex);sleep(1);}pthread_exit((void*)&i); } int main() {pthread_t t1;pthread_t t2;int t1return;int t2return;int* th1;int* th2;pthread_cond_init(&cond,NULL);pthread_mutex_init(&mutex,NULL);t1return=pthread_create(&t1,NULL,func1,(void*)&i);if(t1return!=0){printf("pthread create fail\n");}t2return=pthread_create(&t2,NULL,func2,(void*)&i);if(t2return!=0){printf("pthread create fail\n");}pthread_join(t1,(void**)&th1);pthread_join(t2,(void**)&th2);pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond);printf("main over\n");return 0; }

將程序輸出到文件：

fhn@ubuntu:~/thread$ ./test >> result.txt & [2] 18838 其中>>表示將運行的結(jié)果追加到test.ret.txt中 &表示在后臺運行 [2] 18838（這是test 進程的ID號）

大佬博客：條件變量和互斥鎖使用實例

學(xué)習(xí)過程補充：

• C中struct只是類型聲明，沒有內(nèi)存空間的分配，而static變量是需要分配內(nèi)存的。這種解釋可以說明為什么在結(jié)構(gòu)體內(nèi)包含static變量會出錯。
• void (*add)(void);這個只是用來聲明add是函數(shù)指針的，不能用來函數(shù)定義，這個add可以指向其他函數(shù)的指針，但是要求函數(shù)類型和add的函數(shù)類型相同。
• 程序中各種變量、常量的存儲位置
• 關(guān)鍵字restrict只用于限定指針，表明本指針是訪問一個數(shù)據(jù)對象的惟一且初始的方式。
• 生產(chǎn)者消費者問題
• 這是一個非常經(jīng)典的多線程題目，題目大意如下：有一個生產(chǎn)者在生產(chǎn)產(chǎn)品，這些產(chǎn)品將提供給若干個消費者去消費，為了使生產(chǎn)者和消費者能并發(fā)執(zhí)行，在兩者之間設(shè)置一個有多個緩沖區(qū)的緩沖池，生產(chǎn)者將它生產(chǎn)的產(chǎn)品放入一個緩沖區(qū)中，消費者可以從緩沖區(qū)中取走產(chǎn)品進行消費，所有生產(chǎn)者和消費者都是異步方式運行的，但它們必須保持同步，即不允許消費者到一個空的緩沖區(qū)中取產(chǎn)品，也不允許生產(chǎn)者向一個已經(jīng)裝滿產(chǎn)品且尚未被取走的緩沖區(qū)中投放產(chǎn)品。
• 消費者將g_count每次減去1，生產(chǎn)者將g_count每次加1；消費者會判斷g_count的大小，如果g_count==0那么消費者線程要阻塞；但是它還會一直占有鎖，所以這樣就阻止了其它線程對g_count的操作；此時我們要用到條件變量；調(diào)用pthread_cond_wait(&g_cond, &g_mutex);讓互斥鎖g_mutex在這個g_cond條件上等待；

總結(jié)

以上是生活随笔為你收集整理的linux线程（互斥锁、条件）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。