C++ 線程學習

標籤：thread

線程的概念

C++中的線程的Text Segment和Data Segment都是共用的，如果定義一個函數，在各線程中都可以調用，如果定義一個全域變數，在各線程中都可以訪問到。除此之外，各線程還共用以下進程資源和環境：

• 檔案描述符
• 每種訊號的處理方式
• 當前工作目錄
• 使用者id和組id

但是，有些資源是每個線程各有一份的：

• 線程id
• 上下文，包括各種寄存器的值、程式計數器和棧指標
• 棧空間
• errno變數
• 訊號屏蔽字
• 調度優先順序

我們將要學習的線程庫函數是由POSIX標準定義的，稱為POSIX thread或pthread。

線程式控制制 建立線程

建立線程的函數原型如下：

#include <pthread.h>int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

傳回值：成功返回0,失敗返回錯誤號碼。

在一個線程中調用pthread_create()建立新的線程後，當前線程從pthread_create()返回繼續往下執行，而新的線程所執行的代碼由我們傳給pthread_create的函數指標start_routine決定。start_routine函數接收一個參數，是通過pthread_create的arg參數傳遞給它的，該參數類型為void*，這個指標按什麼類型解釋由調用者自己定義。start_routine的傳回值類型也是void *,這個指標的含義同樣由調用者自己定義。start_routine返回時，這個線程就退出了，其它線程可以調用pthread_join得到start_routine的傳回值。

pthread_create成功返回後，新建立的線程的id被填寫到thread參數所指向的記憶體單元。我們知道進程id的類型是pid_t，每個進程的id在整個系統中是唯一的，調用getpid可以得到當前進程的id，是一個正整數值。線程id的類型是thread_t，它只在當前進程中保證是唯一的，在不同的系統中thread_t這個類型有不同的實現，它可能是一個整數值，也可能是一個結構體，也可能是一個地址，所以不能簡單的當成整數用printf列印，調用pthread_self可以擷取當前線程的id。

我們先來寫一個簡單的例子:

#include <stdio.h>#include <string.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>pthread_t ntid;void printids(const void *t){        char *s = (char *)t;    pid_t      pid;    pthread_t  tid;    pid = getpid();    tid = pthread_self();    printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,           (unsigned int)tid, (unsigned int)tid);}void *thr_fn(void *arg){    printids(arg);    return NULL;}int main(void){    int err;    err = pthread_create(&ntid, NULL, thr_fn, (void *)"Child Process:");    if (err != 0) {        fprintf(stderr, "can‘t create thread: %s\n", strerror(err));        exit(1);    }    printids("main thread:");    sleep(1);    return 0;}

編譯執行結果如下：

g++ thread.cpp -o thread -lpthread./threadmain thread: pid 21046 tid 3612727104 (0xd755d740)Child Process: pid 21046 tid 3604444928 (0xd6d77700)

從結果可以知道，thread_t類型是一個地址值，屬於同一進程的多個線程調用getpid可以得到相同的進程號，而調用pthread_self得到的線程號各不相同。

如果任意一個線程調用了exit或_exit，則整個進程的所有線程都終止，由於從main函數return也相當於調用exit，為了防止新建立的線程還沒有得到執行就終止，我們在main函數return之前延時1秒，這隻是一種權宜之計，即使主線程等待1秒，核心也不一定會調度新建立的線程執行，接下來，我們學習一下比較好的解決方案。

終止線程

如果需要只終止某個線程而不是終止整個進程，可以有三種方法：

• 從線程函數return。這種方法對主線程不適應，從main函數return相當於調用exit。
• 一個線程可以調用pthread_cancel終止同一個進程中的另一個線程。
• 線程可以調用pthread_exit終止自己。

這裡主要介紹pthread_exit和pthread_join的用法。

#include <pthread.h>void pthread_exit(void *value_ptr);

value_ptr是void*類型，和線程函數傳回值的用法一樣，其它線程可以調用pthread_join擷取這個指標。
需要注意，pthread_exit或者return返回的指標所指向的記憶體單元必須是全域的或者是用malloc分配的，不能線上程函數的棧上分配，因為當其它線程得到這個返回指標時線程函數已經退出了。

#include <pthread.h>int pthread_join(pthread_t thread, void **value_ptr);

傳回值：成功返回0，失敗返回錯誤號碼。

調用該函數的線程將掛起等待，直到id為thread的線程終止。thread線程以不同的方法終止，通過pthread_join得到的終止狀態是不同的，總結如下：

• 如果thread線程通過return返回，value_ptr所指向的單元裡存放的是thread線程函數的傳回值。
• 如果thread線程被別的線程調用pthread_cancel異常終止掉，value_ptr所指向的單元存放的是常數PTHREAD_CANCELED。
• 如果thread線程是自己調用pthread_exit終止的，value_ptr所指向的單元存放的是傳給pthread_exit的參數。

如果對thread線程的終止狀態不感興趣，可以傳NULL給value_ptr參數。參考代碼如下：

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>void* thread_function_1(void *arg){    printf("thread 1 running\n");    return (void *)1;}void* thread_function_2(void *arg){    printf("thread 2 exiting\n");    pthread_exit((void *) 2);}void* thread_function_3(void* arg){    while (1) {        printf("thread 3 writeing\n");        sleep(1);    }}int main(void){    pthread_t tid;    void *tret;    pthread_create(&tid, NULL, thread_function_1, NULL);    pthread_join(tid, &tret);    printf("thread 1 exit code %d\n", *((int*) (&tret)));    pthread_create(&tid, NULL, thread_function_2, NULL);    pthread_join(tid, &tret);    printf("thread 2 exit code %d\n", *((int*) (&tret)));    pthread_create(&tid, NULL, thread_function_3, NULL);    sleep(3);    pthread_cancel(tid);    pthread_join(tid, &tret);    printf("thread 3 exit code %d\n", *((int*) (&tret)));    return 0;}

運行結果是：

thread 1 runningthread 1 exit code 1thread 2 exitingthread 2 exit code 2thread 3 writeingthread 3 writeingthread 3 writeingthread 3 exit code -1

可見，Linux的pthread庫中常數PTHREAD_CANCELED的值是-1.可以在標頭檔pthread.h中找到它的定義：

#define PTHREAD_CANCELED ((void *) -1)

線程間同步

多個線程同時訪問共用資料時可能會衝突，例如兩個線程都要把某個全域變數增加1，這個操作在某平台上需要三條指令才能完成：

1. 從記憶體讀變數值到寄存器。
2. 寄存器值加1.
3. 將寄存器的值寫回到記憶體。

這個時候很容易出現兩個進程同時操作寄存器變數值的情況，導致最終結果不正確。

解決的辦法是引入互斥鎖(Mutex, Mutual Exclusive Lock)，獲得鎖的線程可以完成“讀-修改-寫”的操作，然後釋放鎖給其它線程，沒有獲得鎖的線程只能等待而不能訪問共用資料，這樣，“讀-修改-寫”的三步操作組成一個原子操作，要不都執行，要不都不執行，不會執行到中間被打斷，也不會在其它處理器上並行做這個操作。

Mutex用pthread_mutex_t類型的變數表示，可以這樣初始化和銷毀：

#include <pthread.h>int pthread_mutex_destory(pthread_mutex_t *mutex);int pthread_mutex_int(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);pthread_mutex_t mutex = PTHEAD_MUTEX_INITIALIZER;

傳回值：成功返回0，失敗返回錯誤號碼。

用pthread_mutex_init函數初始化的Mutex可以用pthread_mutex_destroy銷毀。如果Mutex變數是靜態分配的（全域變數或static變數），也可以用宏定義PTHREAD_MUTEX_INITIALIZER來初始化，相當於用pthread_mutex_init初始化並且attr參數為NULL。Mutex的加鎖和解鎖操作可以用下列函數：

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

傳回值：成功返回0，失敗返回錯誤號碼。

一個線程可以調用pthread_mutex_lock獲得Mutex，如果這時另一個線程已經調用pthread_mutex_lock獲得了該Mutex，則當前線程需要掛起等待，直到另一個線程調用pthread_mutex_unlock釋放Mutex，當前線程被喚醒，才能獲得該Mutex並繼續執行。

我們用Mutex解決上面說的兩個線程同時對全域變數+1可能導致紊亂的問題：

#include <pthread.h>#include <stdio.h>#include <stdlib.h>#define NLOOP 5000int counter;pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;void *do_add_process(void *vptr){    int i, val;    for (i = 0; i < NLOOP; i ++) {        pthread_mutex_lock(&counter_mutex);        val = counter;        printf("%x:%d\n", (unsigned int)pthread_self(), val + 1);        counter = val + 1;        pthread_mutex_unlock(&counter_mutex);    }    return NULL;}int main(){    pthread_t tida, tidb;    pthread_create(&tida, NULL, do_add_process, NULL);    pthread_create(&tidb, NULL, do_add_process, NULL);    pthread_join(tida, NULL);    pthread_join(tidb, NULL);    return 0;}

這樣，每次運行都能顯示到10000。如果去掉鎖機制，可能就會有問題。這個機制類似於Java的synchronized塊機制。

Condition Variable

線程間的同步還有這樣一種情況：線程A需要等某個條件成立才能繼續往下執行，現在這個條件不成立，線程A就阻塞等待，而線程B在執行過程中使這個條件成立了，就喚醒線程A繼續執行。在pthread庫中通過條件變數(Conditiion Variable)來阻塞等待一個條件，或者喚醒等待這個條件的線程。Condition Variable用pthread_cond_t類型的變數表示，可以這樣初始化和銷毀：

#include <pthread.h>int pthread_cond_destory(pthread_cond_t *cond);int pthread_cond_init(pthead_cond_t *cond, const pthread_condattr_t *attr);pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

傳回值：成功返回0，失敗返回錯誤號碼。

和Mutex的初始化和銷毀類似，pthread_cond_init函數初始化一個Condition Variable，attr參數為NULL則表示預設屬性，pthread_cond_destroy函數銷毀一個Condition Variable。如果Condition Variable是靜態分配的，也可以用宏定義PTHEAD_COND_INITIALIZER初始化，相當於用pthread_cond_init函數初始化並且attr參數為NULL。Condition Variable的操作可以用下列函數：

#include <pthread.h>int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);int pthread_cond_broadcast(pthread_cond_t *cond);int pthread_cond_signal(pthread_cond_t *cond);

可見，一個Condition Variable總是和一個Mutex搭配使用的。一個線程可以調用pthread_cond_wait在一個Condition Variable上阻塞等待，這個函數做以下三步操作：

1. 釋放Mutex。
2. 阻塞等待。
3. 當被喚醒時，重新獲得Mutex並返回。

pthread_cond_timedwait函數還有一個額外的參數可以設定等待逾時，如果到達了abstime所指定的時刻仍然沒有別的線程來喚醒當前線程，就返回ETIMEDOUT。一個線程可以調用pthread_cond_signal喚醒在某個Condition Variable上等待的另一個線程，也可以調用pthread_cond_broadcast喚醒在這個Condition Variable上等待的所有線程。

下面的程式示範了一個生產者-消費者的例子，生產者生產一個結構體串在鏈表的表頭上，消費者從表頭取走結構體。

#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <unistd.h>struct msg {    struct msg *next;    int num;};struct msg *head;pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;void* consumer(void *p){    struct msg *mp;    for(;;) {        pthread_mutex_lock(&lock);        while (head == NULL) {            pthread_cond_wait(&has_product, &lock);        }        mp = head;        head = mp->next;        pthread_mutex_unlock(&lock);        printf("Consume %d\n", mp->num);        free(mp);        sleep(rand() % 5);    }}void* producer(void *p){    struct msg *mp;    for(;;) {        mp = (struct msg *)malloc(sizeof(*mp));        pthread_mutex_lock(&lock);        mp->next = head;        mp->num = rand() % 1000;        head = mp;        printf("Product %d\n", mp->num);        pthread_mutex_unlock(&lock);        pthread_cond_signal(&has_product);        sleep(rand() % 5);    }}int main(){    pthread_t pid, cid;    srand(time(NULL));    pthread_create(&pid, NULL, producer, NULL);    pthread_create(&cid, NULL, consumer, NULL);    pthread_join(pid, NULL);    pthread_join(cid, NULL);    return 0;}

C++ 線程學習