Linux Pthread 深入解析

Outline 

- 1.線程特點

- 2.pthread創建

- 3.pthread終止

        - 4.mutex互斥量使用框架

        - 5.cond條件變量

        - 6.綜合實例

================================================================================================

1. 線程特點

線程擁有自己獨立的棧、調度優先級和策略、信號屏蔽字（創建時繼承）、errno變量以及線程私有數據。進程的其他地址空間均被所有線程所共享，因此線程可以訪問程序的全局變量和堆中分配的數據，並通過同步機制保證對數據訪問的一致性。

2. pthread創建

pthread有一個線程ID，類型爲pthread_t，在使用printf打印時，應轉換爲u類型。

pthread_equal可用於比較兩個id是否相等；pthread_self用於獲取當前線程的ID。

pthread_create用於創建新的線程，可以給線程傳入一個void *類型的參數，例如一個結構體指針或者一個數值。

系統並不能保證哪個線程會現運行：新創建的線程還是調用線程。

3. pthread終止

a) 從線程函數中返回

b) 被同一進程中的其他線程取消

c) 線程調用pthread_exit

注意，線程的返回值需要轉換爲void *類型。

pthread_exit(void *ret)

pthread_join(pthread_t id, void **ret)

ret均可設置爲NULL

4.  mutex 互斥量使用框架

pthread_mutex_t lock;

pthread_mutex_init 或者 PTHREAD_MUTEX_INITIALIZER（僅可用在靜態變量）

pthread_mutex_lock / pthread_mutex_unlock / pthread_mutex_trylock

pthread_mutex_destroy

5. cond 條件變量

pthread_cond_t qready;

pthread_mutex_t qlock;

pthread_mutex_init 或者 PTHREAD_MUTEX_INITIALIZER

pthread_cond_init 或者 PTHREAD_COND_INITIALIZER

pthread_mutex_lock(&qlock...)

pthread_cond_wait(&qready, &qlock...) / pthread_cond_timewait

pthread_mutex_unlock(&qlock)
pthread_cond_destroy

//喚醒條件變量

pthread_cond_signal

pthread_cond_broadcast

條件變量是pthread中比較難以理解的一點，主要會產生以下疑惑：

Q1. 假如在調用pthread_{cond_wait | cond_timedwait}之前就調用pthread_cond_{signal | broadcast}會發生什麼？

Q2. pthread_cond_{cond_wait | cond_timewait}爲什麼需要一個已經鎖住的mutex作爲變量？

Q3. pthread_cond_{signal | broadcast}使用之前必須獲取wait中對應的mutex嗎？

Q4. 假如pthread_cond_{signal | broadcast}必須獲取mutex，那麼下列兩種形式，哪種正確？爲什麼？

 1)

 lock(lock_for_X);

 change(X);

 unlock(lock_for_X);

 pthread_cond_{signal | broadcast};

 2)

 lock(lock_for_X);

 change(X);

 pthread_cond_{signal | broadcast};

 unlock(lock_for_X);

----思考-------思考-------思考-------思考------思考-------思考------思考------思考-------思考-------

A1: 什麼都不會發生，也不會出錯，僅僅造成這次發送的signal丟失。

A2: 一般場景如下，我們需要檢查某個條件是否滿足（如隊列X是否爲空、布爾Y是否爲真），假如沒有條件變量，我們唯一的選擇是

while (1) {
  lock(lock_for_X);

  if (X is not empty) {
    unlock(lock_for_X);
    break;
  } else { //X is empty, loop continues
    unlock(lock_for_X);
    sleep(10);
  }
}
//X is not empty, loop ends
process(X);

明顯這種輪詢的方式非常耗費CPU時間，這時候我們很容易的想到，如果有一種機制，可以異步通知我們隊列的狀態發生了變化，那麼我們便無須再輪詢，只要等到通知到來時再檢查條件是否滿足即可，其他時間則將程序休眠，因此現在代碼變成這樣：

while (1) {
  lock(lock_for_X);
  if (X is not empty) {
    unlock(lock_for_X);
    break;
  } else {
    unlock(lock_for_X); //must
called before my_wait(), otherwise no one can acquire the lock and make
change to X
    -------------------------------------->窗口，由於已經解鎖，其他程序可能改變X，並且試圖喚醒mywait，但在一個繁忙的系統中，可能此時my_還沒被調用！
    my_wait(); //go to sleep and wait for the
notification
  }
}

my_wait是一個假想的函數，作用如註釋所示。

不難發現，這樣做以後，我們無須再輪詢了，只需要等待my_wait()被喚醒以後檢查條件是否滿足。

但是請注意，正如圖中所示，存在1個時間窗口。若其他程序在這個窗口中試圖喚醒my_wait，由於此時my_wait還沒有被調用，那麼這個信號將丟失，造成my_wait一直阻塞。解決的辦法就是，要將unlock和my_wait合併成一個原子操作，這樣就不會被其他程序插入執行。我想到這裏，你應該已經明白了，這個原子操作的函數就是pthread_cond_{signal | broadcast}.

A3: 是的。

詳見：http://stackoverflow.com/questions/4544234/calling-pthread-cond-signal-without-locking-mutex

A4: 對於1)，在不同的操作系統中，可能會造成不確定的調度結果（可能會造成調度優先級反轉）；對於2）可以保證無論在何種操作系統中都將獲得預期的調度順序。

設想一個場景：有兩個消費者線程A和B，我們設定A的優先級比B高，A正在等待條件變量被出發，即已經調用了pthread_wait，並且處於阻塞狀態：

lock(lock_for_X);
while (X is empty) {
  pthread_cond_wait(&qready, &lock_for_X);
}
unlock(lock_for_X);

B中沒有調用pthread_wait，而是做類似如下的處理：

while(1) {
  lock(lock_for_X);
  dequeue(X);
  unlock(lock_for_X);
}

另一個線程C，爲生產者，採用1)方案，則代碼如下，先unlock，再發出signal：

 lock(lock_for_X);

 change(X);

 unlock(lock_for_X);

 pthread_cond_{signal | broadcast};

當發出unlock以後，發送signal之前，此時消費者B已經滿足了運行條件，而消費者A雖然優先級比B高，但是由於其運行條件還需要signal，所以不具備立刻運行的條件，此時就看操作系統如何實現調度算法了。有些操作系統，可能會因爲A不具備立刻運行條件，即使它的優先級比B高，此時還是讓B線程先運行，那麼，後續將分成兩種情況：

(a) B獲得了lock，但是還沒有將X隊列中的剛剛加入的條目移除，此時C調用了signal，A接收到了signal，由於A的優先級高，那麼A搶佔B，A從函數pthread_cond_wait返回之前需要再次將lock上鎖，但是A搶佔後發現，lock被人鎖住了（還沒有被B釋放），只好再次休眠，等待鎖被釋放，結果B又被喚醒，也可能因此造成A和B的死鎖，這個具體要看操作系統的調度算法。

(b) B獲得了lock，並且執行了dequeue，然後釋放了鎖。此時C調用了signal，A接收到了signal，由於A的優先級高，那麼A搶佔B，A這次順利的獲取了鎖得以從pthread_cond_wait中返回，但是在檢查條件時，卻發現隊列是空的，於是乎再次進入pthread_cond_wait休眠。結果A又無法被執行，A可能由此進入飢餓狀態。

但是如果C採用2)方案：

 lock(lock_for_X);

 change(X);

 pthread_cond_{signal | broadcast};

 unlock(lock_for_X);

在unlock以後，A、B都具備了立即運行的條件，由於A比B的優先級高，因此操作系統必定會先調度A執行，就避免了前面一種不確定的調度結果。

主要參考：http://groups.google.com/group/comp.programming.threads/msg/a3721a2fc9b21c64?hl=ky

6. 綜合實例

/*
 * =====================================================================================
 *
 * Filename: pthread.c
 *
 * Description:
 *
 * Version: 1.0
 * Created: 08/17/11
11:06:35
 * Revision: none
 * Compiler: gcc
 *
 * Author: YOUR NAME (),
 * Company:
 *
 * =====================================================================================
 */
#include <stdio.h>
#include <pthread.h>
#include <error.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

pthread_cond_t qready;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;

struct foo {
    int cnt;
    pthread_mutex_t f_lock;
};

void cleanup(void *arg)
{
    printf("clean up: %s\n", (char *)arg);
}

void printids(char *str)
{
    printf("%s pid = %u tid = %u / 0x%x\n",
            str, (unsigned int)getpid(), (unsigned int)pthread_self(), (unsigned int)pthread_self());
}

void *thread1(void *arg)
{
    pthread_mutex_lock(&qlock);
    pthread_cond_wait(&qready, &qlock);
    pthread_mutex_unlock(&qlock);

    printids("thread1:");

    pthread_cleanup_push(cleanup, "thread 1 first cleanup handler");
    pthread_cleanup_push(cleanup, "thread 1 second cleanup handler");
    printf("thread 1 push complete!\n");

    pthread_mutex_lock(&((struct
foo *)arg)->f_lock);
    ((struct foo *)arg)->cnt ;
    printf("thread1: cnt = %d\n", ((struct
foo *)arg)->cnt);
    pthread_mutex_unlock(&((struct
foo *)arg)->f_lock);

    if (arg)
        return ((void *)0);

    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);

    pthread_exit((void *)1);
}

void *thread2(void *arg)
{
    int exit_code = -1;
    printids("thread2:");

    printf("Now unlock thread1\n");

    pthread_mutex_lock(&qlock);
    pthread_mutex_unlock(&qlock);
    pthread_cond_signal(&qready);

    printf("Thread1 unlocked\n");

    pthread_cleanup_push(cleanup, "thread 2 first cleanup handler");
    pthread_cleanup_push(cleanup, "thread 2 second cleanup handler");
    printf("thread 2 push complete!\n");

    if (arg)
        pthread_exit((void *)exit_code);

    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);

    pthread_exit((void *)exit_code);
}

int main(int argc, char *argv[])
{
    int ret;
    pthread_t tid1, tid2;
    void *retval;
    struct foo *fp;

    ret = pthread_cond_init(&qready, NULL);
    if (ret != 0) {
        printf("pthread_cond_init error: %s\n", strerror(ret));
        return -1;
    }



    if ((fp = malloc(sizeof(struct
foo))) == NULL) {
        printf("malloc failed!\n");
        return -1;
    }

    if (pthread_mutex_init(&fp->f_lock, NULL) != 0) {
        free(fp);
        printf("init mutex failed!\n");
    }

    pthread_mutex_lock(&fp->f_lock);

    ret = pthread_create(&tid1, NULL, thread1, (void *)fp);
    if (ret != 0) {
        printf("main thread error: %s\n", strerror(ret));
        return -1;
    }
    ret = pthread_create(&tid2, NULL, thread2, (void *)1);
    if (ret != 0) {
        printf("main thread error: %s\n", strerror(ret));
        return -1;
    }


    ret = pthread_join(tid2, &retval);
    if (ret != 0) {
        printf("pthread join falied!\n");
        return -1;
    }
    else
        printf("thread2 exit code %d\n", (int)retval);

    fp->cnt = 1;
    printf("main thread: cnt = %d\n",fp->cnt);

    pthread_mutex_unlock(&fp->f_lock);

    sleep(1);    //there is no
guarantee the main thread will run before the newly created thread, so we wait for a while
    printids("main thread:");

    printf("Press to exit\n");

    ret = pthread_cond_destroy(&qready);
    if (ret != 0) {
        printf("pthread_cond_destroy error: %s\n", strerror(ret));
        return -1;
    }

    getchar();
    return 0;
}