多執行緒是多工處理的一種特殊形式，多工處理允許讓電腦同時執行兩個或兩個以上的程式。一般情況下，兩種型別的多工處理：基於程序和基於執行緒。

• 基於程序的多工處理是程式的併發執行。

• 執行緒的多工處理是同一程式的片段的併發執行。

多執行緒程式包含可以同時執行的兩個或多個部分。這樣的程式中的每個部分稱為一個執行緒，每個執行緒定義了一個單獨的執行路徑。

C++ 不包含多執行緒應用程式的任何內建支援。相反，它完全依賴於作業系統來提供此功能。

本教程假設您使用的是 Linux 作業系統，我們要使用 POSIX 編寫多執行緒 C++ 程式。POSIX Threads 或 Pthreads 提供的 API 可在多種類 Unix POSIX 系統上可用，比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

建立執行緒

下面的程式，我們可以用它來建立一個 POSIX 執行緒：

#include <pthread.h>pthread_create (thread, attr, start_routine, arg) 

在這裡，pthread_create 建立一個新的執行緒，並讓它可執行。下面是關於引數的說明：

引數說明

建立執行緒成功時，函式返回 0，若返回值不為 0 則說明建立執行緒失敗。

終止執行緒

使用下面的程式，我們可以用它來終止一個 POSIX 執行緒：

#include <pthread.h>pthread_exit (status) 

在這裡，pthread_exit 用於顯式地退出一個執行緒。通常情況下，pthread_exit() 函式是線上程完成工作後無需繼續存在時被呼叫。

如果 main() 是在它所建立的執行緒之前結束，並通過 pthread_exit() 退出，那麼其他執行緒將繼續執行。否則，它們將在 main() 結束時自動被終止。

例項：
以下簡單的例項程式碼使用 pthread_create() 函式建立了 5 個執行緒，每個執行緒輸出"Hello Runoob！":

#include <iostream>// 必須的標頭檔案是#include <pthread.h>using namespace std;#define NUM_THREADS 5// 執行緒的執行函式,函式返回的是函式指標，便於後面作為引數  void* say_hello(void* args){    cout << "Hello Runoob！" << endl;}int main(){    // 定義執行緒的 id 變數，多個變數使用陣列    pthread_t tids[NUM_THREADS];    for(int i = 0; i < NUM_THREADS; ++i)    {        //引數依次是：建立的執行緒id，執行緒引數，呼叫的函式，傳入的函式引數        int ret = pthread_create(&tids[i], NULL, say_hello, NULL);        if (ret != 0)        {           cout << "pthread_create error: error_code=" << ret << endl;        }    }    //等各個執行緒退出後，程序才結束，否則程序強制結束了，執行緒可能還沒反應過來；    pthread_exit(NULL);}

使用 -lpthread 庫編譯下面的程式：

$ g++ test.cpp -lpthread -o test.o

現在，執行程式，將產生下列結果：

$ ./test.oHello Runoob！Hello Runoob！Hello Runoob！Hello Runoob！Hello Runoob！

以下簡單的例項程式碼使用 pthread_create() 函式建立了 5 個執行緒，並接收傳入的引數。每個執行緒列印一個 "Hello Runoob!" 訊息，並輸出接收的引數，然後呼叫 pthread_exit() 終止執行緒。

//檔名：test.cpp#include <iostream>#include <cstdlib>#include <pthread.h>using namespace std;#define NUM_THREADS     5void *PrintHello(void *threadid){     // 對傳入的引數進行強制型別轉換，由無型別指標變為整形數指標，然後再讀取   int tid = *((int*)threadid);   cout << "Hello Runoob! 執行緒 ID, " << tid << endl;   pthread_exit(NULL);}int main (){   pthread_t threads[NUM_THREADS];   int indexes[NUM_THREADS];// 用陣列來儲存i的值   int rc;   int i;   for( i=0; i < NUM_THREADS; i++ ){            cout << "main() : 建立執行緒, " << i << endl;      indexes[i] = i; //先儲存i的值      // 傳入的時候必須強制轉換為void* 型別，即無型別指標              rc = pthread_create(&threads[i], NULL,                           PrintHello, (void *)&(indexes[i]));      if (rc){         cout << "Error:無法建立執行緒," << rc << endl;         exit(-1);      }   }   pthread_exit(NULL);}

現在編譯並執行程式，將產生下列結果：

$ g++ test.cpp -lpthread -o test.o$ ./test.omain() : 建立執行緒, 0main() : 建立執行緒, 1main() : 建立執行緒, 2main() : 建立執行緒, 3main() : 建立執行緒, 4Hello Runoob! 執行緒 ID, 4Hello Runoob! 執行緒 ID, 3Hello Runoob! 執行緒 ID, 2Hello Runoob! 執行緒 ID, 1Hello Runoob! 執行緒 ID, 0

向執行緒傳遞引數

這個例項演示瞭如何通過結構傳遞多個引數。您可以線上程回撥中傳遞任意的資料型別，因為它指向 void，如下面的例項所示：

#include <iostream>#include <cstdlib>#include <pthread.h>using namespace std;#define NUM_THREADS     5struct thread_data{   int  thread_id;   char *message;};void *PrintHello(void *threadarg){   struct thread_data *my_data;   my_data = (struct thread_data *) threadarg;   cout << "Thread ID : " << my_data->thread_id ;   cout << " Message : " << my_data->message << endl;   pthread_exit(NULL);}int main (){   pthread_t threads[NUM_THREADS];   struct thread_data td[NUM_THREADS];   int rc;   int i;   for( i=0; i < NUM_THREADS; i++ ){      cout <<"main() : creating thread, " << i << endl;      td[i].thread_id = i;      td[i].message = "This is message";      rc = pthread_create(&threads[i], NULL,                          PrintHello, (void *)&td[i]); //傳入到引數必須強轉為void*型別，即無型別指標      if (rc){         cout << "Error:unable to create thread," << rc << endl;         exit(-1);      }   }   pthread_exit(NULL);}

當上面的程式碼被編譯和執行時，它會產生下列結果：

$ g++ -Wno-write-strings test.cpp -lpthread -o test.o$ ./test.omain() : creating thread, 0main() : creating thread, 1main() : creating thread, 2main() : creating thread, 3main() : creating thread, 4Thread ID : 3 Message : This is messageThread ID : 2 Message : This is messageThread ID : 0 Message : This is messageThread ID : 1 Message : This is messageThread ID : 4 Message : This is message

連線和分離執行緒

我們可以使用以下兩個函式來連線或分離執行緒：

pthread_join (threadid, status) pthread_detach (threadid) 

pthread_join() 子程式阻礙呼叫程式，直到指定的threadid 執行緒終止為止。當建立一個執行緒時，它的某個屬性會定義它是否是可連線的（joinable）或可分離的（detached）。只有建立時定義為可連線的執行緒才可以被連線。如果執行緒建立時被定義為可分離的，則它永遠也不能被連線。

這個例項演示瞭如何使用 pthread_join() 函式來等待執行緒的完成。

#include <iostream>#include <cstdlib>#include <pthread.h>#include <unistd.h>using namespace std;#define NUM_THREADS     5void *wait(void *t){   int i;   long tid;   tid = (long)t;   sleep(1);   cout << "Sleeping in thread " << endl;   cout << "Thread with id : " << tid << "  ...exiting " << endl;   pthread_exit(NULL);}int main (){   int rc;   int i;   pthread_t threads[NUM_THREADS];   pthread_attr_t attr;   void *status;   // 初始化並設定執行緒為可連線的（joinable）   pthread_attr_init(&attr);   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);   for( i=0; i < NUM_THREADS; i++ ){      cout << "main() : creating thread, " << i << endl;      rc = pthread_create(&threads[i], NULL, wait, (void *)i );      if (rc){         cout << "Error:unable to create thread," << rc << endl;         exit(-1);      }   }   // 刪除屬性，並等待其他執行緒   pthread_attr_destroy(&attr);   for( i=0; i < NUM_THREADS; i++ ){      rc = pthread_join(threads[i], &status);      if (rc){         cout << "Error:unable to join," << rc << endl;         exit(-1);      }      cout << "Main: completed thread id :" << i ;      cout << "  exiting with status :" << status << endl;   }   cout << "Main: program exiting." << endl;   pthread_exit(NULL);}

當上面的程式碼被編譯和執行時，它會產生下列結果：

main() : creating thread, 0main() : creating thread, 1main() : creating thread, 2main() : creating thread, 3main() : creating thread, 4Sleeping in thread Thread with id : 4  ...exiting Sleeping in thread Thread with id : 3  ...exiting Sleeping in thread Thread with id : 2  ...exiting Sleeping in thread Thread with id : 1  ...exiting Sleeping in thread Thread with id : 0  ...exiting Main: completed thread id :0  exiting with status :0Main: completed thread id :1  exiting with status :0Main: completed thread id :2  exiting with status :0Main: completed thread id :3  exiting with status :0Main: completed thread id :4  exiting with status :0Main: program exiting.

互斥鎖的實現

互斥鎖是實現執行緒同步的一種機制，只要在臨界區前後對資源加鎖就能阻塞其他程序的訪問。

#include <iostream>#include <pthread.h>using namespace std;#define NUM_THREADS 5int sum = 0; //定義全域性變數，讓所有執行緒同時寫，這樣就需要鎖機制pthread_mutex_t sum_mutex; //互斥鎖void* say_hello( void* args ){    cout << "hello in thread " << *(( int * )args) << endl;    pthread_mutex_lock( &sum_mutex ); //先加鎖，再修改sum的值，鎖被佔用就阻塞，直到拿到鎖再修改sum;    cout << "before sum is " << sum << " in thread " << *( ( int* )args ) << endl;    sum += *( ( int* )args );    cout << "after sum is " << sum << " in thread " << *( ( int* )args ) << endl;    pthread_mutex_unlock( &sum_mutex ); //釋放鎖，供其他執行緒使用    pthread_exit( 0 );}int main(){    pthread_t tids[NUM_THREADS];    int indexes[NUM_THREADS];    pthread_attr_t attr; //執行緒屬性結構體，建立執行緒時加入的引數    pthread_attr_init( &attr ); //初始化    pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是設定你想要指定執行緒屬性引數，這個引數表明這個執行緒是可以join連線的，join功能表示主程式可以等執行緒結束後再去做某事，實現了主程式和執行緒同步功能    pthread_mutex_init( &sum_mutex, NULL ); //對鎖進行初始化    for( int i = 0; i < NUM_THREADS; ++i )    {        indexes[i] = i;        int ret = pthread_create( &tids[i], &attr, say_hello, ( void* )&( indexes[i] ) ); //5個程序同時去修改sum        if( ret != 0 )        {            cout << "pthread_create error:error_code=" << ret << endl;        }    }    pthread_attr_destroy( &attr ); //釋放記憶體    void *status;    for( int i = 0; i < NUM_THREADS; ++i )    {        int ret = pthread_join( tids[i], &status ); //主程式join每個執行緒後取得每個執行緒的退出資訊status        if( ret != 0 )        {            cout << "pthread_join error:error_code=" << ret << endl;        }    }    cout << "finally sum is " << sum << endl;    pthread_mutex_destroy( &sum_mutex ); //登出鎖}

測試結果：

hello in thread hello in thread 1hello in thread 30hello in thread 2before sum is 0 in thread 1hello in thread 4after sum is 1 in thread 1before sum is 1 in thread 3after sum is 4 in thread 3before sum is 4 in thread 4after sum is 8 in thread 4before sum is 8 in thread 0after sum is 8 in thread 0before sum is 8 in thread 2after sum is 10 in thread 2finally sum is 10

可知，sum的訪問和修改順序是正常的，這就達到了多執行緒的目的了，但是執行緒的執行順序是混亂的，混亂就是正常？

訊號量的實現

訊號量是執行緒同步的另一種實現機制，訊號量的操作有signal和wait，本例子採用條件訊號變數

pthread_cond_t tasks_cond;

訊號量的實現也要給予鎖機制。

#include <iostream>#include <pthread.h>#include <stdio.h>using namespace std;#define BOUNDARY 5int tasks = 10;pthread_mutex_t tasks_mutex; //互斥鎖pthread_cond_t tasks_cond; //條件訊號變數，處理兩個執行緒間的條件關係，當task>5，hello2處理，反之hello1處理，直到task減為0void* say_hello2( void* args ){    pthread_t pid = pthread_self(); //獲取當前執行緒id    cout << "[" << pid << "] hello in thread " <<  *( ( int* )args ) << endl;    bool is_signaled = false; //sign    while(1)    {        pthread_mutex_lock( &tasks_mutex ); //加鎖        if( tasks > BOUNDARY )        {            cout << "[" << pid << "] take task: " << tasks << " in thread " << *( (int*)args ) << endl;            --tasks; //modify        }        else if( !is_signaled )        {            cout << "[" << pid << "] pthread_cond_signal in thread " << *( ( int* )args ) << endl;            pthread_cond_signal( &tasks_cond ); //signal:向hello1傳送訊號，表明已經>5            is_signaled = true; //表明訊號已傳送，退出此執行緒        }        pthread_mutex_unlock( &tasks_mutex ); //解鎖        if( tasks == 0 )            break;    }}void* say_hello1( void* args ){    pthread_t pid = pthread_self(); //獲取當前執行緒id    cout << "[" << pid << "] hello in thread " <<  *( ( int* )args ) << endl;    while(1)    {        pthread_mutex_lock( &tasks_mutex ); //加鎖        if( tasks > BOUNDARY )        {            cout << "[" << pid << "] pthread_cond_signal in thread " << *( ( int* )args ) << endl;            pthread_cond_wait( &tasks_cond, &tasks_mutex ); //wait:等待訊號量生效，接收到訊號，向hello2發出訊號，跳出wait,執行後續        }        else        {            cout << "[" << pid << "] take task: " << tasks << " in thread " << *( (int*)args ) << endl;            --tasks;        }        pthread_mutex_unlock( &tasks_mutex ); //解鎖        if( tasks == 0 )            break;    }}int main(){    pthread_attr_t attr; //執行緒屬性結構體，建立執行緒時加入的引數    pthread_attr_init( &attr ); //初始化    pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是設定你想要指定執行緒屬性引數，這個引數表明這個執行緒是可以join連線的，join功能表示主程式可以等執行緒結束後再去做某事，實現了主程式和執行緒同步功能    pthread_cond_init( &tasks_cond, NULL ); //初始化條件訊號量    pthread_mutex_init( &tasks_mutex, NULL ); //初始化互斥量    pthread_t tid1, tid2; //儲存兩個執行緒id    int index1 = 1;    int ret = pthread_create( &tid1, &attr, say_hello1, ( void* )&index1 );    if( ret != 0 )    {        cout << "pthread_create error:error_code=" << ret << endl;    }    int index2 = 2;    ret = pthread_create( &tid2, &attr, say_hello2, ( void* )&index2 );    if( ret != 0 )    {        cout << "pthread_create error:error_code=" << ret << endl;    }    pthread_join( tid1, NULL ); //連線兩個執行緒    pthread_join( tid2, NULL );    pthread_attr_destroy( &attr ); //釋放記憶體    pthread_mutex_destroy( &tasks_mutex ); //登出鎖    pthread_cond_destroy( &tasks_cond ); //正常退出}

測試結果：
先線上程2中執行say_hello2，再跳轉到執行緒1中執行say_hello1，直到tasks減到0為止。

[2] hello in thread 1[2] pthread_cond_signal in thread 1[3] hello in thread 2[3] take task: 10 in thread 2[3] take task: 9 in thread 2[3] take task: 8 in thread 2[3] take task: 7 in thread 2[3] take task: 6 in thread 2[3] pthread_cond_signal in thread 2[2] take task: 5 in thread 1[2] take task: 4 in thread 1[2] take task: 3 in thread 1[2] take task: 2 in thread 1[2] take task: 1 in thread 1

C++ 11中的多執行緒技術

C++11 新標準中引入了四個標頭檔案來支援多執行緒程式設計，他們分別是 <atomic> ,<thread>,<mutex>,<condition_variable>和<future>。

• <atomic>：提供原子操作功能，該頭文主要聲明瞭兩個類, std::atomic 和 std::atomic_flag，另外還聲明瞭一套 C 風格的原子型別和與 C 相容的原子操作的函式。

• <thread>：執行緒模型封裝，該標頭檔案主要聲明瞭 std::thread 類，另外 std::this_thread 名稱空間也在該標頭檔案中。

• <mutex>：互斥量封裝，該標頭檔案主要聲明瞭與互斥量(mutex)相關的類，包括 std::mutex 系列類，std::lock_guard, std::unique_lock, 以及其他的型別和函式。

• <condition_variable>：條件變數，該標頭檔案主要聲明瞭與條件變數相關的類，包括 std::condition_variable 和 std::condition_variable_any。

• <future>：實現了對指定資料提供者提供的資料進行非同步訪問的機制。該標頭檔案主要聲明瞭 std::promise, std::package_task 兩個 Provider 類，以及 std::future 和 std::shared_future 兩個 Future 類，另外還有一些與之相關的型別和函式，std::async() 函式就宣告在此標頭檔案中。

簡單示例：

#include <iostream>#include <thread>using namespace std;void thread_1(){    cout << "hello from thread_1" << endl;}int main(int argc, char **argv){    thread t1(thread_1);    /**    join()相當於呼叫了兩個函式：WaitForSingleObject、CloseHandle，事實上，在vc12中也是這麼實現的    */    t1.join();    return 0;}

注意事項

1. 若執行緒呼叫到的函式在一個類中，則必須將該函式宣告為靜態函式函式

因為靜態成員函式屬於靜態全域性區，執行緒可以共享這個區域，故可以各自呼叫。

    #include <iostream>      #include <pthread.h>            using namespace std;            #define NUM_THREADS 5            class Hello      {      public:          //多執行緒呼叫，宣告為static        static void* say_hello( void* args )          {              cout << "hello..." << endl;          }      };            int main()      {          pthread_t tids[NUM_THREADS];          for( int i = 0; i < NUM_THREADS; ++i )          {              int ret = pthread_create( &tids[i], NULL, Hello::say_hello, NULL );              if( ret != 0 )              {                  cout << "pthread_create error:error_code" << ret << endl;              }          }          pthread_exit( NULL );      }  

測試結果：

    hello...      hello...      hello...      hello...      hello... 

2. 程式碼中如果沒有pthread_join主執行緒會很快結束從而使整個程序結束，從而使建立的執行緒沒有機會開始執行就結束了。加入pthread_join後，主執行緒會一直等待直到等待的執行緒結束自己才結束，使建立的執行緒有機會執行。

3. 執行緒建立時屬性引數的設定pthread_attr_t及join功能的使用
   執行緒的屬性由結構體pthread_attr_t進行管理。

typedef struct{    int      detachstate;       //執行緒的分離狀態    int      schedpolicy;       //執行緒排程策略    struct sched_param   schedparam;   //執行緒的排程引數    int inheritsched;       //執行緒的繼承性     int scope;              //執行緒的作用域     size_t guardsize;   //執行緒棧末尾的警戒緩衝區大小     int stackaddr_set;     void * stackaddr;   //執行緒棧的位置     size_t stacksize;   // 執行緒棧的大小}pthread_attr_t;

示例：

    #include <iostream>      #include <pthread.h>            using namespace std;            #define NUM_THREADS 5            void* say_hello( void* args )      {          cout << "hello in thread " << *(( int * )args) << endl;          int status = 10 + *(( int * )args); //執行緒退出時新增退出的資訊，status供主程式提取該執行緒的結束資訊          pthread_exit( ( void* )status );       }            int main()      {          pthread_t tids[NUM_THREADS];          int indexes[NUM_THREADS];                    pthread_attr_t attr; //執行緒屬性結構體，建立執行緒時加入的引數          pthread_attr_init( &attr ); //初始化          pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是設定你想要指定執行緒屬性引數，這個引數表明這個執行緒是可以join連線的，join功能表示主程式可以等執行緒結束後再去做某事，實現了主程式和執行緒同步功能          for( int i = 0; i < NUM_THREADS; ++i )          {              indexes[i] = i;              int ret = pthread_create( &tids[i], &attr, say_hello, ( void* )&( indexes[i] ) );              if( ret != 0 )              {              cout << "pthread_create error:error_code=" << ret << endl;          }          }           pthread_attr_destroy( &attr ); //釋放記憶體           void *status;          for( int i = 0; i < NUM_THREADS; ++i )          {          int ret = pthread_join( tids[i], &status ); //主程式join每個執行緒後取得每個執行緒的退出資訊status          if( ret != 0 )          {              cout << "pthread_join error:error_code=" << ret << endl;          }          else          {              cout << "pthread_join get status:" << (long)status << endl;          }          }      }  

測試結果：

hello in thread hello in thread 1hello in thread 3hello in thread 40hello in thread 2pthread_join get status:10pthread_join get status:11pthread_join get status:12pthread_join get status:13pthread_join get status:14