Linux系統下的多線程程式設計入門

引言

　　線程（thread）技術早在60年代就被提出，但真正應用多線程到作業系統中去，是在80年代中期，solaris是這方面的佼佼者。傳統的Unix也支援線程的概念，但是在一個程序（process）中隻允許有一個線程，這樣多線程就意味着多程序。現在，多線程技術已經被許多作業系統所支援，包括Windows/NT，當然，也包括Linux。

　　為什麼有了程序的概念後，還要再引入線程呢？使用多線程到底有哪些好處？什麼的系統應該選用多線程？我們首先必須回答這些問題。

　　使用多線程的理由之一是和程序相比，它是一種非常"節儉"的多任務操作方式。我們知道，在Linux系統下，啟動一個新的程序必須配置設定給它獨立的位址空間，建立衆多的資料表來維護它的代碼段、堆棧段和資料段，這是一種"昂貴"的多任務工作方式。而運作于一個程序中的多個線程，它們彼此之間使用相同的位址空間，共享大部分資料，啟動一個線程所花費的空間遠遠小于啟動一個程序所花費的空間，而且，線程間彼此切換所需的時間也遠遠小于程序間切換所需要的時間。據統計，總的說來桓鼋痰目笤際且桓鱿叱炭?0倍左右，當然，在具體的系統上，這個資料可能會有較大的差別。

　　使用多線程的理由之二是線程間友善的通信機制。對不同程序來說，它們具有獨立的資料空間，要進行資料的傳遞隻能通過通信的方式進行，這種方式不僅費時，而且很不友善。線程則不然，由于同一程序下的線程之間共享資料空間，是以一個線程的資料可以直接為其它線程所用，這不僅快捷，而且友善。當然，資料的共享也帶來其他一些問題，有的變量不能同時被兩個線程所修改，有的子程式中聲明為static的資料更有可能給多線程程式帶來災難性的打擊，這些正是編寫多線程程式時最需要注意的地方。

　　除了以上所說的優點外，不和程序比較，多線程程式作為一種多任務、并發的工作方式，當然有以下的優點：

　　1) 提高應用程式響應。這對圖形界面的程式尤其有意義，當一個操作耗時很長時，整個系統都會等待這個操作，此時程式不會響應鍵盤、滑鼠、菜單的操作，而使用多線程技術，将耗時長的操作（time consuming）置于一個新的線程，可以避免這種尴尬的情況。

　　2) 使多CPU系統更加有效。作業系統會保證當線程數不大于CPU數目時，不同的線程運作于不同的CPU上。

　　3) 改善程式結構。一個既長又複雜的程序可以考慮分為多個線程，成為幾個獨立或半獨立的運作部分，這樣的程式會利于了解和修改。

　　下面我們先來嘗試編寫一個簡單的多線程程式。

　　 簡單的多線程程式設計

　　Linux系統下的多線程遵循POSIX線程接口，稱為pthread。編寫Linux下的多線程程式，需要使用頭檔案pthread.h，連接配接時需要使用庫libpthread.a。順便說一下，Linux下pthread的實作是通過系統調用clone（）來實作的。clone（）是Linux所特有的系統調用，它的使用方式類似fork，關于clone（）的詳細情況，有興趣的讀者可以去檢視有關文檔說明。下面我們展示一個最簡單的多線程程式example1.c。

#include <stdio.h> #include <pthread.h> void thread(void) { 　int i; 　for(i=0;i<3;i++) 　　printf("This is a pthread.n"); } int main(void) { 　pthread_t id; 　int i,ret; 　ret=pthread_create(&id,NULL,(void *) thread,NULL); 　if(ret!=0){ 　　printf ("Create pthread error!n"); 　　exit (1); 　} 　for(i=0;i<3;i++) 　　printf("This is the main process.n"); 　pthread_join(id,NULL); 　return (0); }

　　我們編譯此程式：

gcc example1.c -lpthread -o example1

　　運作example1，我們得到如下結果：

This is the main process. This is a pthread. This is the main process. This is the main process. This is a pthread. This is a pthread.

　　再次運作，我們可能得到如下結果：

This is a pthread. This is the main process. This is a pthread. This is the main process. This is a pthread. This is the main process.

　　前後兩次結果不一樣，這是兩個線程争奪CPU資源的結果。上面的示例中，我們使用到了兩個函數，pthread_create和pthread_join，并聲明了一個pthread_t型的變量。

　　pthread_t在頭檔案/usr/include/bits/pthreadtypes.h中定義：

　　typedef unsigned long int pthread_t;

　　它是一個線程的辨別符。函數pthread_create用來建立一個線程，它的原型為：

extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,void *(*__start_routine) (void *), void *__arg));

　　第一個參數為指向線程辨別符的指針，第二個參數用來設定線程屬性，第三個參數是線程運作函數的起始位址，最後一個參數是運作函數的參數。這裡，我們的函數thread不需要參數，是以最後一個參數設為空指針。第二個參數我們也設為空指針，這樣将生成預設屬性的線程。對線程屬性的設定和修改我們将在下一節闡述。當建立線程成功時，函數傳回0，若不為0則說明建立線程失敗，常見的錯誤傳回代碼為EAGAIN和EINVAL。前者表示系統限制建立新的線程，例如線程數目過多了；後者表示第二個參數代表的線程屬性值非法。建立線程成功後，新建立的線程則運作參數三和參數四确定的函數，原來的線程則繼續運作下一行代碼。

　　函數pthread_join用來等待一個線程的結束。函數原型為：

　　extern int pthread_join __P ((pthread_t __th, void **__thread_return));

　　第一個參數為被等待的線程辨別符，第二個參數為一個使用者定義的指針，它可以用來存儲被等待線程的傳回值。這個函數是一個線程阻塞的函數，調用它的函數将一直等待到被等待的線程結束為止，當函數傳回時，被等待線程的資源被收回。一個線程的結束有兩種途徑，一種是象我們上面的例子一樣，函數結束了，調用它的線程也就結束了；另一種方式是通過函數pthread_exit來實作。它的函數原型為：

　　extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));

　　唯一的參數是函數的傳回代碼，隻要pthread_join中的第二個參數thread_return不是NULL，這個值将被傳遞給thread_return。最後要說明的是，一個線程不能被多個線程等待，否則第一個接收到信号的線程成功傳回，其餘調用pthread_join的線程則傳回錯誤代碼ESRCH。

　　在這一節裡，我們編寫了一個最簡單的線程，并掌握了最常用的三個函數pthread_create，pthread_join和pthread_exit。下面，我們來了解線程的一些常用屬性以及如何設定這些屬性。

　　 修改線程的屬性

　　在上一節的例子裡，我們用pthread_create函數建立了一個線程，在這個線程中，我們使用了預設參數，即将該函數的第二個參數設為NULL。的确，對大多數程式來說，使用預設屬性就夠了，但我們還是有必要來了解一下線程的有關屬性。

　　屬性結構為pthread_attr_t，它同樣在頭檔案/usr/include/pthread.h中定義，喜歡追根問底的人可以自己去檢視。屬性值不能直接設定，須使用相關函數進行操作，初始化的函數為pthread_attr_init，這個函數必須在pthread_create函數之前調用。屬性對象主要包括是否綁定、是否分離、堆棧位址、堆棧大小、優先級。預設的屬性為非綁定、非分離、預設1M的堆棧、與父程序同樣級别的優先級。

　　關于線程的綁定，牽涉到另外一個概念：輕程序（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);

　　線程的分離狀态決定一個線程以什麼樣的方式來終止自己。在上面的例子中，我們采用了線程的預設屬性，即為非分離狀态，這種情況下，原有的線程等待建立的線程結束。隻有當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傳回。設定一段等待時間，是在多線程程式設計裡常用的方法。但是注意不要使用諸如wait（）之類的函數，它們是使整個程序睡眠，并不能解決線程同步的問題。

　　另外一個可能常用的屬性是線程的優先級，它存放在結構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, &param); param.sched_priority=newprio; pthread_attr_setschedparam(&attr, &param); pthread_create(&tid, &attr, (void *)myfunction, myarg);

線程的資料處理

　　和程序相比，線程的最大優點之一是資料的共享性，各個程序共享父程序處沿襲的資料段，可以友善的獲得、修改資料。但這也給多線程程式設計帶來了許多問題。我們必須當心有多個不同的程序通路相同的變量。許多函數是不可重入的，即同時不能運作一個函數的多個拷貝（除非使用不同的資料段）。在函數中聲明的靜态變量常常帶來問題，函數的傳回值也會有問題。因為如果傳回的是函數内部靜态聲明的空間的位址，則在一個線程調用該函數得到位址後使用該位址指向的資料時，别的線程可能調用此函數并修改了這一段資料。在程序中共享的變量必須用關鍵字volatile來定義，這是為了防止編譯器在優化時（如gcc中使用-OX參數）改變它們的使用方式。為了保護變量，我們必須使用信号量、互斥等方法來保證我們對變量的正确使用。下面，我們就逐漸介紹處理線程資料時的有關知識。

　　1、線程資料

　　在單線程的程式裡，有兩種基本的資料：全局變量和局部變量。但在多線程程式裡，還有第三種資料類型：線程資料（TSD: Thread-Specific Data）。它和全局變量很象，線上程内部，各個函數可以象使用全局變量一樣調用它，但它對線程外部的其它線程是不可見的。這種資料的必要性是顯而易見的。例如我們常見的變量errno，它傳回标準的出錯資訊。它顯然不能是一個局部變量，幾乎每個函數都應該可以調用它；但它又不能是一個全局變量，否則在A線程裡輸出的很可能是B線程的出錯資訊。要實作諸如此類的變量，我們就必須使用線程資料。我們為每個線程資料建立一個鍵，它和這個鍵相關聯，在各個線程裡，都使用這個鍵來指代線程資料，但在不同的線程裡，這個鍵代表的資料是不同的，在同一個線程裡，它代表同樣的資料内容。

　　和線程資料相關的函數主要有4個：建立一個鍵；為一個鍵指定線程資料；從一個鍵讀取線程資料；删除鍵。

　　建立鍵的函數原型為：

extern 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時它執行這個函數，以後的調用将被它忽略。

　　在下面的例子中，我們建立一個鍵，并将它和某個資料相關聯。我們要定義一個函數createWindow，這個函數定義一個圖形視窗（資料類型為Fl_Window *，這是圖形界面開發工具FLTK中的資料類型）。由于各個線程都會調用這個函數，是以我們使用線程資料。

pthread_key_t myWinKey; void createWindow ( void ) { 　Fl_Window * win; 　static pthread_once_t once= PTHREAD_ONCE_INIT; 　 　pthread_once ( & once, createMyKey) ; 　 　win=new Fl_Window( 0, 0, 100, 100, "MyWindow"); 　 　setWindow(win); 　 　pthread_setpecific ( myWinKey, win); } void createMyKey ( void ) { 　pthread_keycreate(&myWinKey, freeWinKey); } void freeWinKey ( Fl_Window * win){ 　delete win; }

　　這樣，在不同的線程中調用函數createMyWin，都可以得到線上程内部均可見的視窗變量，這個變量通過函數pthread_getspecific得到。在上面的例子中，我們已經使用了函數pthread_setspecific來将線程資料和一個鍵綁定在一起。這兩個函數的原型如下：

extern int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer)); 　　extern void *pthread_getspecific __P ((pthread_key_t __key));

　　這兩個函數的參數意義和使用方法是顯而易見的。要注意的是，用pthread_setspecific為一個鍵指定新的線程資料時，必須自己釋放原有的線程資料以回收空間。這個過程函數pthread_key_delete用來删除一個鍵，這個鍵占用的記憶體将被釋放，但同樣要注意的是，它隻釋放鍵占用的記憶體，并不釋放該鍵關聯的線程資料所占用的記憶體資源，而且它也不會觸發函數pthread_key_create中定義的destructor函數。線程資料的釋放必須在釋放鍵之前完成。

　　2、互斥鎖

　　互斥鎖用來保證一段時間内隻有一個線程在執行一段代碼。必要性顯而易見：假設各個線程向同一個檔案順序寫入資料，最後得到的結果一定是災難性的。

　　我們先看下面一段代碼。這是一個讀/寫程式，它們公用一個緩沖區，并且我們假定一個緩沖區隻能儲存一條資訊。即緩沖區隻有兩個狀态：有資訊或沒有資訊。

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

　　這裡聲明了互斥鎖變量mutex，結構pthread_mutex_t為不公開的資料類型，其中包含一個系統配置設定的屬性對象。函數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。它們分别定義了不同的上所、解鎖機制，一般情況下，選用最後一個預設屬性。

　　pthread_mutex_lock聲明開始用互斥鎖上鎖，此後的代碼直至調用pthread_mutex_unlock為止，均被上鎖，即同一時間隻能被一個線程調用執行。當一個線程執行到pthread_mutex_lock處時，如果該鎖此時被另一個線程使用，那此線程被阻塞，即程式将等待到另一個線程釋放此互斥鎖。在上面的例子中，我們使用了pthread_delay_np函數，讓線程睡眠一段時間，就是為了防止一個線程始終占據此函數。

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

　　3、條件變量

　　前一節中我們講述了如何使用互斥鎖來實作線程間資料的共享和通信，互斥鎖一個明顯的缺點是它隻有兩種狀态：鎖定和非鎖定。而條件變量通過允許線程阻塞和等待另一個線程發送信号的方法彌補了互斥鎖的不足，它常和互斥鎖一起使用。使用時，條件變量被用來阻塞一個線程，當條件不滿足時，線程往往解開相應的互斥鎖并等待條件發生變化。一旦其它的某個線程改變了條件變量，它将通知相應的條件變量喚醒一個或多個正被此條件變量阻塞的線程。這些線程将重新鎖定互斥鎖并重新測試條件是否滿足。一般說來，條件變量被用來進行線承間的同步。

　　條件變量的結構為pthread_cond_t，函數pthread_cond_init（）被用來初始化一個條件變量。它的原型為：

　　extern 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_cond_ destroy（pthread_cond_t cond）。　

　　函數pthread_cond_wait（）使線程阻塞在一個條件變量上。它的函數原型為：

　　extern int pthread_cond_wait __P ((pthread_cond_t *__cond,pthread_mutex_t *__mutex));

　　線程解開mutex指向的鎖并被條件變量cond阻塞。線程可以被函數pthread_cond_signal和函數pthread_cond_broadcast喚醒，但是要注意的是，條件變量隻是起阻塞和喚醒線程的作用，具體的判斷條件還需使用者給出，例如一個變量是否為0等等，這一點我們從後面的例子中可以看到。線程被喚醒後，它将重新檢查判斷條件是否滿足，如果還不滿足，一般說來線程應該仍阻塞在這裡，被等待被下一次喚醒。這個過程一般用while語句實作。

　　另一個用來阻塞線程的函數是pthread_cond_timedwait（），它的原型為：

　　extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond,pthread_mutex_t *__mutex, __const struct timespec *__abstime));

　　它比函數pthread_cond_wait（）多了一個時間參數，經曆abstime段時間後，即使條件變量不滿足，阻塞也被解除。

　　函數pthread_cond_signal（）的原型為：

　　extern int pthread_cond_signal __P ((pthread_cond_t *__cond));

　　它用來釋放被阻塞在條件變量cond上的一個線程。多個線程阻塞在此條件變量上時，哪一個線程被喚醒是由線程的排程政策所決定的。要注意的是，必須用保護條件變量的互斥鎖來保護這個函數，否則條件滿足信号又可能在測試條件和調用pthread_cond_wait函數之間被發出，進而造成無限制的等待。下面是使用函數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_cond_broadcast（pthread_cond_t *cond）用來喚醒所有被阻塞在條件變量cond上的線程。這些線程被喚醒後将再次競争相應的互斥鎖，是以必須小心使用這個函數。

　　4、信号量

　　信号量本質上是一個非負的整數計數器，它被用來控制對公共資源的通路。當公共資源增加時，調用函數sem_post（）增加信号量。隻有當信号量值大于０時，才能使用公共資源，使用後，函數sem_wait（）減少信号量。函數sem_trywait（）和函數pthread_ mutex_trylock（）起同樣的作用，它是函數sem_wait（）的非阻塞版本。下面我們逐個介紹和信号量有關的一些函數，它們都在頭檔案/usr/include/semaphore.h中定義。

　　信号量的資料類型為結構sem_t，它本質上是一個長整型的數。函數sem_init（）用來初始化一個信号量。它的原型為：

　　extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));

　　sem為指向信号量結構的一個指針；pshared不為０時此信号量在程序間共享，否則隻能為目前程序的所有線程共享；value給出了信号量的初始值。

　　函數sem_post( sem_t *sem )用來增加信号量的值。當有線程阻塞在這個信号量上時，調用這個函數會使其中的一個線程不在阻塞，選擇機制同樣是由線程的排程政策決定的。

　　函數sem_wait( sem_t *sem )被用來阻塞目前線程直到信号量sem的值大于0，解除阻塞後将sem的值減一，表明公共資源經使用後減少。函數sem_trywait ( sem_t *sem )是函數sem_wait（）的非阻塞版本，它直接将信号量sem的值減一。

　　函數sem_destroy(sem_t *sem)用來釋放信号量sem。

　　下面我們來看一個使用信号量的例子。在這個例子中，一共有4個線程，其中兩個線程負責從檔案讀取資料到公共的緩沖區，另兩個線程從緩沖區讀取資料作不同的處理（加和乘運算）。

#include <stdio.h> #include <pthread.h> #include <semaphore.h> #define MAXSTACK 100 int stack[MAXSTACK][2]; int size=0; sem_t sem; void ReadData1(void){ 　FILE *fp=fopen("1.dat","r"); 　while(!feof(fp)){ 　　fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]); 　　sem_post(&sem); 　　++size; 　} 　fclose(fp); } void ReadData2(void){ 　FILE *fp=fopen("2.dat","r"); 　while(!feof(fp)){ 　　fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]); 　　sem_post(&sem); 　　++size; 　} 　fclose(fp); } void HandleData1(void){ 　while(1){ 　　sem_wait(&sem); 　　printf("Plus:%d+%d=%dn",stack[size][0],stack[size][1], 　　stack[size][0]+stack[size][1]); 　　--size; 　} } void HandleData2(void){ 　while(1){ 　　sem_wait(&sem); 　　printf("Multiply:%d*%d=%dn",stack[size][0],stack[size][1], 　　stack[size][0]*stack[size][1]); 　　--size; 　} } int main(void){ 　pthread_t t1,t2,t3,t4; 　sem_init(&sem,0,0); 　pthread_create(&t1,NULL,(void *)HandleData1,NULL); 　pthread_create(&t2,NULL,(void *)HandleData2,NULL); 　pthread_create(&t3,NULL,(void *)ReadData1,NULL); 　pthread_create(&t4,NULL,(void *)ReadData2,NULL); 　 　pthread_join(t1,NULL); }

　　在Linux下，我們用指令gcc -lpthread sem.c -o sem生成可執行檔案sem。 我們事先編輯好資料檔案1.dat和2.dat，假設它們的内容分别為1 2 3 4 5 6 7 8 9 10和 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 ，我們運作sem，得到如下的結果：

Multiply:-1*-2=2

Plus:-1+-2=-3

Multiply:9*10=90

Plus:-9+-10=-19

Multiply:-7*-8=56

Plus:-5+-6=-11

Multiply:-3*-4=12

Plus:9+10=19

Plus:7+8=15

Plus:5+6=11

　　從中我們可以看出各個線程間的競争關系。而數值并未按我們原先的順序顯示出來這是由于size這個數值被各個線程任意修改的緣故。這也往往是多線程程式設計要注意的問題。

　　 小結

　　多線程程式設計是一個很有意思也很有用的技術，使用多線程技術的網絡螞蟻是目前最常用的下載下傳工具之一，使用多線程技術的grep比單線程的grep要快上幾倍，類似的例子還有很多。希望大家能用多線程技術寫出高效實用的好程式來。