软件开发平台及语言笔记大全(超详细)

（一）：posix線程及線程間互斥

有了進程的概念，為何還要使用線程呢？

首先，回憶一下上一個系列我們講到的IPC，各個進程之間具有獨立的內存空間，要進行數據的傳遞只能通過通信的方式進行，這種方式不僅費時，而且很不方便。而同一個進程下的線程是共享全局內存的，所以一個線程的數據可以在另一個線程中直接使用，及快捷又方便。

其次，在Linux系統下，啟動一個新的進程必須分配給它獨立的地址空間，建立眾多的數據表來維護它的代碼段、堆棧段和數據段，這是一種"昂貴"的多任務工作方式。而運行於一個進程中的多個線程，它們彼此之間使用相同的地址空間，共享大部分數據，啟動一個線程所花費的空間遠遠小於啟動一個進程所花費的空間，而且，線程間彼此切換所需的時間也遠遠小於進程間切換所需要的時間。

但是，伴隨著這些優點，線程卻帶來了同步與互斥的問題。下面先講講線程基本函數：

###1. 線程的創建pthread_create

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

一個線程由一個線程ID（參數thread）標識，新的線程創建成功，其值通過指針thread返回。

參數attr為線程屬性（比如：優先級、初始棧大小等），通常我們使用默認設置，設為NULL。

參數start_routine為一個函數指針，指向線程執行的函數，最後參數arg為函數start_routine唯一參數，如果需要傳遞多個參數，需要打包為結構，然後將其地址傳給該函數。

pthread_create成功時返回0，失敗為非0值，這和其他linux系統調用的習慣不一樣。

###2. pthread_join函數

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

通過調用該函數等待一個給定線程終止，類似於線程的waitpid函數。

該函數等待參數thread指定的線程終止，該函數會阻塞，直到線程thread終止，將線程返回的(void *)指針賦值為retval指向的位置，然後回收已經終止線程佔用的所有存儲器資源。

###3. pthread_self函數

#include <pthread.h>  
pthread_t pthread_self(void);

該函數用於獲取線程自身線程ID。類似於進程的getpid函數。

###4. pthread_detach函數

#include <pthread.h>  
int pthread_detach(pthread_t thread);

該函數可分離可結合線程，線程可以通過以pthread_self()為參數的pthread_detach調用來分離他們自己。

一個分離線程是不能被其他線程回收或殺死的，他的存儲器資源在他終止時由系統自動釋放。一個可結合線程能夠被其他線程收回其資源和殺死，在被其他線程收回之前，他的存儲器資源是沒有被釋放的。在任何一個時間點上，線程是可結合的或者是可分離的。默認情況下，線程是被創建成可結合的。

為了避免存儲器洩露，每個可結合線程都應該要麼被其他線程現實的收回，要麼通過調用pthread_detach函數被分離。

在現實的程序中，我們一般都使用分離的線程。

5. pthread_exit函數

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

該函數作用就是終止線程。如果該線程未曾分離，他的線程ID和退出狀態將一直保留到調用進程內某個其他線程對他調用pthread_join。

另外，當線程函數（pthread_create第三個參數）返回時，該線程將終止；當創建該線程的進程main函數返回時，該線程也將終止。

下面給一個簡單的示例

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void* func_th(void* arg)
{
    unsigned int*     val = (unsigned int*)arg;

    printf("=======%s->%d==thread%d: %u====\n", __func__, __LINE__,
           *val, (unsigned int)pthread_self());
    return NULL;
}

int main(int argc, const char* argv[])
{
    pthread_t   tid1, tid2;
    int         a, b;

    a = 1;

    if (0 != pthread_create(&tid1, NULL, func_th, &a)) {
        printf("pthread_create failed!\n");
        return -1;
    }

    b = 2;

    if (0 != pthread_create(&tid2, NULL, func_th, &b)) {
        printf("pthread_create failed!\n");
        return -1;
    }


    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

執行2次輸出為：

# ./target_bin  
=======func_th->9==thread1: 3077856064====  
=======func_th->9==thread2: 3069463360====  
# ./target_bin  
=======func_th->9==thread2: 3069315904====  
=======func_th->9==thread1: 3077708608====

類似於進程，線程的調度隨機的。

在前面開始我們說到同一個進程內的線程是共享全局內存的，那麼當多個線程同時去修改一個全局變量的時候就會出問題，如果一個線程在修改某個變量時中途被掛起，操作系統去調度另外一個線程執行，那就可能導致錯誤。我們無法保證操作系統對這些操作都是原子的。

在我們在現在的例子中這樣去復現這種問題：一個線程對一個全局變量（100）進行讀-加1-讀操作，另個變量對該全局進行減1操作，我們通過sleep來實現加線程先執行，減線程在加線程的加和讀之間進行，最後來查看加操作是否是我們期望的結果（101）。例子如下：

（該示例只是為了強化運行時出錯，並對這種錯誤有一個宏觀的瞭解而寫）

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

int gval = 100;

void* func_add_th(void* arg)
{
    int*     val = (int*)arg;

    printf("==do %s==thread%d: %u====\n", __func__,
           *val, (unsigned int)pthread_self());

    printf("before add 1, gval=%d\n", gval);
    gval += 1;

    sleep(4);//此時add線程掛起，sub線程執行鍵操作

    printf("after add 1, gval=%d\n", gval);
    return NULL;
}

void* func_sub_th(void* arg)
{
    int*     val = (int*)arg;

    printf("==do %s==thread%d: %u====\n", __func__,
           *val, (unsigned int)pthread_self());

    gval -= 1;

    return NULL;
}

int main(int argc, const char* argv[])
{
    pthread_t   tid1, tid2;
    int         a, b;

    a = 1;

    if (0 != pthread_create(&tid1, NULL, func_add_th, &a)) {
        printf("pthread_create failed!\n");
        return -1;
    }

    sleep(1);  //保證add線程先被調度
    b = 2;

    if (0 != pthread_create(&tid2, NULL, func_sub_th, &b)) {
        printf("pthread_create failed!\n");
        return -1;
    }


    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

執行結果如下：

# ./target_bin  
==do func_add_th==thread1: 3078355776====  
before add 1, gval=100  
==do func_sub_th==thread2: 3069963072====  
after add 1, gval=100

通過輸出我們可以看到sub操作在加1和讀之間操作，最終讀取出來的值仍然是100，不是我們期望的101。

這就是兩個線程不是互斥帶來的結果，所以我們希望在某某一線程一段代碼執行期間，只有一個線程在運行，當運行完成之後，下一個線程運行該部分代碼，所以我們需要將該部分代碼加鎖。這就是線程編程，也是併發編程需要考慮的問題。

解決多線程共享的問題就是使用互斥鎖（mutex，即mutual exliusion）來保護共享數據。在執行某一段代碼是首先要持有該互斥鎖，執行完成之後再釋放該鎖。互斥鎖是類型為pthread_mutex_t的變量。使用如下方法來加鎖和解鎖操作。

派生到我的代碼片

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

首先我們需要初始化鎖，初始化方法有兩種，一種是靜態初始化，給鎖變量賦值PTHREAD_MUTEX_INITIALIZER，一種動態初始化，使用函數pthread_mutex_init。

我們使用靜態方法初始化：

pthread_mutex_t     mutex = PTHREAD_MUTEX_INITIALIZER;

當試圖使用pthread_mutex_lock（）獲得一個已經被另外線程加鎖的鎖時，本線程將阻塞，直到互斥鎖被解鎖為止。函數pthread_mutex_trylock為獲取鎖的非阻塞版本，當獲取失敗時會立即返回。

我們修改add和sub線程函數分別如下：

void* func_add_th(void* arg)
{
    int*     val = (int*)arg;

    pthread_mutex_lock(&mutex);//此處加鎖
    printf("==do %s==thread%d: %u====\n", __func__,
           *val, (unsigned int)pthread_self());

    printf("before add 1, gval=%d\n", gval);
    gval += 1;

    sleep(4);

    printf("after add 1, gval=%d\n", gval);
    pthread_mutex_unlock(&mutex);//此處釋放鎖
    return NULL;
}
void* func_sub_th(void* arg)
{
    int*     val = (int*)arg;

    pthread_mutex_lock(&mutex);
    printf("==do %s==thread%d: %u====\n", __func__,
           *val, (unsigned int)pthread_self());

    gval -= 1;
    pthread_mutex_unlock(&mutex);

    return NULL;
}

執行結果為：

# ./target_bin  
==do func_add_th==thread1: 3077614400====  
before add 1, gval=100  
after add 1, gval=101  
==do func_sub_th==thread2: 3069221696====

通過結果輸出可以看到，sub操作是在add操作執行完成之後才執行的，而add線程輸出結果也是我們預期的，所以我們的加鎖是成功的。但是如果add線程要執行很久的話，sub線程就要阻塞很久，我們可以將sub線程加鎖函數改為非阻塞版本，當加鎖失敗時，立即返回。

修改後的sub線程函數：

void* func_sub_th(void* arg)
{
    int*     val = (int*)arg;

    if (0 != pthread_mutex_trylock(&mutex)) {
        printf("failed to lock!\n");
        return NULL;
    }

    printf("==do %s==thread%d: %u====\n", __func__,
           *val, (unsigned int)pthread_self());

    gval -= 1;
    pthread_mutex_unlock(&mutex);

    return NULL;
}

運行輸出為：

# ./target_bin  
==do func_add_th==thread1: 3077638976====  
before add 1, gval=100  
failed to lock!  
after add 1, gval=101

當多個線程同時需要多個相同鎖時，可能會出現死鎖的情況。比如兩個線程同時需要互斥鎖1和互斥鎖2，線程a先獲得鎖1，線程b獲得鎖2，這是線程a、b分別還需要鎖2和鎖1，但此時兩個鎖都被加鎖了，都阻塞在那裡等待對方釋放鎖，這樣死鎖就出現了。我們來實現一下死鎖的情況，將之前兩個例子的線程函數修改如下：

pthread_mutex_t     mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t     mutex_sec = PTHREAD_MUTEX_INITIALIZER;

void* func_add_th(void* arg)
{
    int*     val = (int*)arg;

    pthread_mutex_lock(&mutex);//1. add線程先加第一個鎖mutex
    printf("==do %s==thread%d: %u====\n", __func__,
           *val, (unsigned int)pthread_self());
    sleep(2);//等待2秒，讓sub線程加第二個鎖mutex_sec
    pthread_mutex_lock(&mutex_sec);//4. add線程加鎖mutex_sec失敗

    printf("before add 1, gval=%d\n", gval);
    gval += 1;

    sleep(4);

    printf("after add 1, gval=%d\n", gval);
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex_sec);
    return NULL;
}

void* func_sub_th(void* arg)
{
    int*     val = (int*)arg;

    pthread_mutex_lock(&mutex_sec);//2. Sub線程比add線程先加鎖mutex_sec
    pthread_mutex_lock(&mutex);//3. Sub線程加鎖mutex失敗

    printf("==do %s==thread%d: %u====\n", __func__,
           *val, (unsigned int)pthread_self());

    gval -= 1;
    pthread_mutex_unlock(&mutex);
    pthread_mutex_unlock(&mutex_sec);

    return NULL;
}

上面兩個線程按照函數註釋中1-2-3-4順序執行，運行時程序就卡在那裡出現了死鎖。

可以使用非阻塞版本的加鎖函數來加鎖，不過也要注意在第二個鎖加鎖不成功情況下，需要釋放第一個鎖再返回，不然其他線程仍然得不到第一個鎖。有時在線程需要多個互斥鎖時，讓線程按照指定的同樣順序進行加鎖也可以避免死鎖。程序死鎖出現時很難定位，所以程序猿在編程（尤其是在設計）時需要注意避免這個問題。

本節示例代碼下載：

http://download.csdn.net/detail/gentleliu/8270863

软件开发平台及语言笔记大全(超详细)

（一）：posix線程及線程間互斥

5. pthread_exit函數

Linux命令大全搜索工具

Linux 内核揭密

嵌入式 Linux 知识库

Spring Framework 4.x 参考文档中文版

Serverless 架构应用开发指南

gulp 入门指南