是不是感覺多執行緒如此的簡單，短短几行程式碼就搞定了，我想你已經可以寫出一個簡單的多執行緒程式了吧，呵呵，其實問題沒有這麼簡單，多執行緒我們還要面對執行緒同步的問題，我會在下一個專題裡給大家講到。

二、

微軟在Windows API中提供了建立新的執行緒的函式CreateThread，
　　概述：
　　當使用CreateProcess呼叫時，系統將建立一個程序和一個主執行緒。CreateThread將在主執行緒的基礎上建立一個新執行緒，大致做如下步驟：
　　1在核心物件中分配一個執行緒標識/控制代碼，可供管理，由CreateThread返回
　　2把執行緒退出碼置為STILL_ACTIVE，把執行緒掛起計數置1
　　3分配context結構
　　4分配兩頁的物理儲存以準備棧，保護頁設定為PAGE_READWRITE，第2頁設為PAGE_GUARD
　　5lpStartAddr和lpvThread值被放在棧頂，使它們成為傳送給StartOfThread的引數
　　6把context結構的棧指標指向棧頂（第5步）指令指標指向startOfThread函式
　　MSDN中CreateThread原型：
　　HANDLE CreateThread(
　　LPSECURITY_ATTRIBUTES lpThreadAttributes,
　　DWORD dwStackSize,
　　LPTHREAD_START_ROUTINE lpStartAddress,
　　LPVOID lpParameter,
　　DWORD dwCreationFlags,
　　LPDWORD lpThreadId);
　　引數說明：
　　lpThreadAttributes：指向SECURITY_ATTRIBUTES型態的結構的指標。在Windows 98中忽略該引數。在Windows NT中，它被設為NULL，表示使用預設值。
　　dwStackSize，執行緒堆疊大小，一般=0，在任何情況下，Windows根據需要動態延長堆疊的大小。
　　lpStartAddress，指向執行緒函式的指標，形式：@函式名，函式名稱沒有限制，但是必須以下列形式宣告：
　　DWORD WINAPI ThreadProc (PVOID pParam) ，格式不正確將無法呼叫成功。
　　lpParameter：向執行緒函式傳遞的引數，是一個指向結構的指標，不需傳遞引數時，為Nil。
　　dwCreationFlags ：執行緒標誌,可取值如下
　　CREATE_SUSPENDED： 建立一個掛起的執行緒
　　0 ：建立後立即啟用。
　　lpThreadId:儲存新執行緒的id。
　　返回值：
　　函式成功，返回執行緒控制代碼；函式失敗返回false。
　　函式說明：
　　建立一個執行緒。
　　語法：
　　hThread = CreateThread (&security_attributes, dwStackSize, ThreadProc,pParam, dwFlags, &idThread) ;
　　一般並不推薦使用 CreateTheard函式，而推薦使用RTL 庫裡的System單元中定義的 BeginTheard函式，因為這除了能建立一個執行緒和一個入口函式以外，還增加了幾項保護措施。

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1. 引言

　　執行緒（thread）技術早在60年代就被提出，但真正應用多執行緒到作業系統中去，是在80年代中期，solaris是這方面的佼佼者。傳統的Unix也支援執行緒的概念，但是在一個程序（process）中只允許有一個執行緒，這樣多執行緒就意味著多程序。現在，多執行緒技術已經被許多作業系統所支援，包括Windows/NT，當然，也包括Linux。
　　為什麼有了程序的概念後，還要再引入執行緒呢？使用多執行緒到底有哪些好處？什麼的系統應該選用多執行緒？我們首先必須回答這些問題。
　　使用多執行緒的理由之一是和程序相比，它是一種非常"節儉"的多工操作方式。我們知道，在Linux系統下，啟動一個新的程序必須分配給它獨立的地址空間，建立眾多的資料表來維護它的程式碼段、堆疊段和資料段，這是一種"昂貴"的多工工作方式。而運行於一個程序中的多個執行緒，它們彼此之間使用相同的地址空間，共享大部分資料，啟動一個執行緒所花費的空間遠遠小於啟動一個程序所花費的空間，而且，執行緒間彼此切換所需的時間也遠遠小於程序間切換所需要的時間。據統計，總的說來，一個程序的開銷大約是一個執行緒開銷的30倍左右，當然，在具體的系統上，這個資料可能會有較大的區別。
　　使用多執行緒的理由之二是執行緒間方便的通訊機制。對不同程序來說，它們具有獨立的資料空間，要進行資料的傳遞只能通過通訊的方式進行，這種方式不僅費時，而且很不方便。執行緒則不然，由於同一程序下的執行緒之間共享資料空間，所以一個執行緒的資料可以直接為其它執行緒所用，這不僅快捷，而且方便。當然，資料的共享也帶來其他一些問題，有的變數不能同時被兩個執行緒所修改，有的子程式中宣告為static的資料更有可能給多執行緒程式帶來災難性的打擊，這些正是編寫多執行緒程式時最需要注意的地方。
　　除了以上所說的優點外，不和程序比較，多執行緒程式作為一種多工、併發的工作方式，當然有以下的優點：
　　1) 提高應用程式響應。這對圖形介面的程式尤其有意義，當一個操作耗時很長時，整個系統都會等待這個操作，此時程式不會響應鍵盤、滑鼠、選單的操作，而使用多執行緒技術，將耗時長的操作（time consuming）置於一個新的執行緒，可以避免這種尷尬的情況。
　　2) 使多CPU系統更加有效。作業系統會保證當執行緒數不大於CPU數目時，不同的執行緒運行於不同的CPU上。
　　3) 改善程式結構。一個既長又複雜的程序可以考慮分為多個執行緒，成為幾個獨立或半獨立的執行部分，這樣的程式會利於理解和修改。
　　下面我們先來嘗試編寫一個簡單的多執行緒程式。

2. 簡單的多執行緒程式設計

　　Linux系統下的多執行緒遵循POSIX執行緒介面，稱為pthread。編寫Linux下的多執行緒程式，需要使用標頭檔案pthread.h，連線時需要使用庫libpthread.a。順便說一下，Linux下pthread的實現是通過系統呼叫clone()來實現的。clone()是Linux所特有的系統呼叫，它的使用方式類似fork，關於clone()的詳細情況，有興趣的讀者可以去檢視有關文件說明。下面我們展示一個最簡單的多執行緒程式threads.cpp。 

//Threads.cpp
#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

void *thread(void *ptr)
{
    for(int i = 0;i < 3;i++) {
        sleep(1);
        cout << "This is a pthread." << endl;
    }
    return 0;
}

int main() {
    pthread_t id;
    int ret = pthread_create(&id, NULL, thread, NULL);
    if(ret) {
        cout << "Create pthread error!" << endl;
        return 1;
    }
    for(int i = 0;i < 3;i++) {
        cout <<  "This is the main process." << endl;
        sleep(1);
    }
    pthread_join(id, NULL);
    return 0;
}

　　我們編譯並執行此程式，可以得到如下結果：
　　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。下面，我們來了解執行緒的一些常用屬性以及如何設定這些屬性。

3. 修改執行緒的屬性

　　在上一節的例子裡，我們用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(&amp;attr);
pthread_attr_getschedparam(&attr, &param);
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr, &param);
pthread_create(&tid, &attr, (void *)myfunction, myarg);

4. 執行緒的資料處理
　　和程序相比，執行緒的最大優點之一是資料的共享性，各個程序共享父程序處沿襲的資料段，可以方便的獲得、修改資料。但這也給多執行緒程式設計帶來了許多問題。我們必須當心有多個不同的程序訪問相同的變數。許多函式是不可重入的，即同時不能執行一個函式的多個拷貝（除非使用不同的資料段）。在函式中宣告的靜態變數常常帶來問題，函式的返回值也會有問題。因為如果返回的是函式內部靜態宣告的空間的地址，則在一個執行緒呼叫該函式得到地址後使用該地址指向的資料時，別的執行緒可能呼叫此函式並修改了這一段資料。在程序中共享的變數必須用關鍵字volatile來定義，這是為了防止編譯器在優化時（如gcc中使用-OX引數）改變它們的使用方式。為了保護變數，我們必須使用訊號量、互斥等方法來保證我們對變數的正確使用。下面，我們就逐步介紹處理執行緒資料時的有關知識。
   
4.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;
/* 函式 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來將執行緒資料和一個鍵繫結在一起。這兩個函式的原型如下：

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函式。執行緒資料的釋放必須在釋放鍵之前完成。

　　4.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的非阻塞版本，當它發現死鎖不可避免時，它會返回相應的資訊，程式設計師可以針對死鎖做出相應的處理。另外不同的互斥鎖型別對死鎖的處理不一樣，但最主要的還是要程式設計師自己在程式設計注意這一點。

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