[[434554]]

一、線程概述

線程是輕量級的進程（LWP：light weight process），在 Linux 環境下線程的本質仍是進程。在計算機上運行的程序是一組指令及指令參數的組合，指令按照既定的邏輯控制計算機運行。操作系統會以進程為單位，分配系統資源，可以這樣理解，進程是資源分配的最小單位，線程是操作系統調度執行的最小單位。

先從概念上了解一下線程和進程之間的區別：

    1.  進程有自己獨立的地址空間，多個線程共用同一個地址空間

•  線程更加節省系統資源，效率不僅可以保持的，而且能夠更高
•  在一個地址空間中多個線程獨享：每個線程都有屬于自己的棧區，寄存器 (內核中管理的)
•  在一個地址空間中多個線程共享：代碼段，堆區，全局數據區，打開的文件 (文件描述符表) 都是線程共享的

    2.  線程是程序的最小執行單位，進程是操作系統中最小的資源分配單位

•  每個進程對應一個虛擬地址空間，一個進程只能搶一個 CPU 時間片
•  一個地址空間中可以劃分出多個線程，在有效的資源基礎上，能夠搶更多的 CPU 時間片

    3.  CPU 的調度和切換：線程的上下文切換比進程要快的多

上下文切換：進程 / 線程分時復用 CPU 時間片，在切換之前會將上一個任務的狀態進行保存，下次切換回這個任務的時候，加載這個狀態繼續運行，任務從保存到再次加載這個過程就是一次上下文切換。

    4.  線程更加廉價，啟動速度更快，退出也快，對系統資源的沖擊小。

在處理多任務程序的時候使用多線程比使用多進程要更有優勢，但是線程并不是越多越好，如何控制線程的個數呢？

1.  文件 IO 操作：文件 IO 對 CPU 是使用率不高，因此可以分時復用 CPU 時間片，線程的個數 = 2 * CPU 核心數 (效率最高)
2.  處理復雜的算法 (主要是 CPU 進行運算，壓力大)，線程的個數 = CPU 的核心數 (效率最高)

二、創建線程

2.1 線程函數

每一個線程都有一個唯一的線程 ID，ID 類型為 pthread_t，這個 ID 是一個無符號長整形數，如果想要得到當前線程的線程 ID，可以調用如下函數： 

pthread_t pthread_self(void); // 返回當前線程的線程ID 

在一個進程中調用線程創建函數，就可得到一個子線程，和進程不同，需要給每一個創建出的線程指定一個處理函數，否則這個線程無法工作。 

#include <pthread.h>  
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,  
                   void *(*start_routine) (void *), void *arg);  
// Compile and link with -pthread, 線程庫的名字叫pthread, 全名: libpthread.so libptread.a 

參數:

•  thread: 傳出參數，是無符號長整形數，線程創建成功，會將線程 ID 寫入到這個指針指向的內存中
•  attr: 線程的屬性，一般情況下使用默認屬性即可，寫 NULL
•  start_routine: 函數指針，創建出的子線程的處理動作，也就是該函數在子線程中執行。
•  arg: 作為實參傳遞到 start_routine 指針指向的函數內部

返回值：線程創建成功返回 0，創建失敗返回對應的錯誤號

2.2 創建線程

下面是創建線程的示例代碼，在創建過程中一定要保證編寫的線程函數與規定的函數指針類型一致：void *(*start_routine) (void *): 

// pthread_create.c   
#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <pthread.h>  
// 子線程的處理代碼  
void* working(void* arg)  
{  
    printf("我是子線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<9; ++i)  
    {  
        printf("child == i: = %d\n", i);  
    }  
    return NULL;  
}  
int main()  
{  
    // 1. 創建一個子線程  
    pthread_t tid;  
    pthread_create(&tid, NULL, working, NULL);  
    printf("子線程創建成功, 線程ID: %ld\n", tid);  
    // 2. 子線程不會執行下邊的代碼, 主線程執行  
    printf("我是主線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<3; ++i)  
    {  
        printf("i = %d\n", i);  
    }  
     // 休息, 休息一會兒...  
    // sleep(1);   
     return 0;  
} 

編譯測試程序，會看到如下錯誤信息： 

$ gcc pthread_create.c   
/tmp/cctkubA6.o: In function `main': 
pthread_create.c:(.text+0x7f): undefined reference to `pthread_create'  
collect2: error: ld returned 1 exit status 

錯誤原因是因為編譯器鏈接不到線程庫文件（動態庫），需要在編譯的時候通過參數指定出來，動態庫名為 libpthread.so 需要使用的參數為 -l，根據規則掐頭去尾最終形態應該寫成：-lpthread（參數和參數值中間可以有空格）。正確的編譯命令為： 

# pthread_create 函數的定義在某一個庫中, 編譯的時候需要加庫名 pthread  
$ gcc pthread_create.c -lpthread  
$ ./a.out   
子線程創建成功, 線程ID: 139712560109312 
我是主線程, 線程ID: 139712568477440  
i = 0 
i = 1  
i = 2 

在打印的日志輸出中為什么子線程處理函數沒有執行完畢呢（只看到了子線程的部分日志輸出）？

主線程一直在運行，執行期間創建出了子線程，說明主線程有 CPU 時間片，在這個時間片內將代碼執行完畢了，主線程就退出了。子線程被創建出來之后需要搶 cpu 時間片, 搶不到就不能運行，如果主線程退出了, 虛擬地址空間就被釋放了, 子線程就一并被銷毀了。但是如果某一個子線程退出了, 主線程仍在運行, 虛擬地址空間依舊存在。

得到的結論：在沒有人為干預的情況下，虛擬地址空間的生命周期和主線程是一樣的，與子線程無關。

目前的解決方案：讓子線程執行完畢，主線程再退出，可以在主線程中添加掛起函數 sleep();

三、線程退出

在編寫多線程程序的時候，如果想要讓線程退出，但是不會導致虛擬地址空間的釋放（針對于主線程），我們就可以調用線程庫中的線程退出函數，只要調用該函數當前線程就馬上退出了，并且不會影響到其他線程的正常運行，不管是在子線程或者主線程中都可以使用。 

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

•  參數：線程退出的時候攜帶的數據，當前子線程的主線程會得到該數據。如果不需要使用，指定為 NULL

下面是線程退出的示例代碼，可以在任意線程的需要的位置調用該函數： 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <pthread.h>  
// 子線程的處理代碼  
void* working(void* arg)  
{  
    sleep(1);  
    printf("我是子線程, 線程ID: %ld\n", pthread_self()); 
    for(int i=0; i<9; ++i)  
    {  
        if(i==6)  
        {  
            pthread_exit(NULL); // 直接退出子線程  
        }   
        printf("child == i: = %d\n", i);  
    }  
    return NULL;  
} 
int main()  
{  
    // 1. 創建一個子線程  
    pthread_t tid;  
    pthread_create(&tid, NULL, working, NULL);  
    printf("子線程創建成功, 線程ID: %ld\n", tid);  
    // 2. 子線程不會執行下邊的代碼, 主線程執行  
    printf("我是主線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<3; ++i)  
    {  
        printf("i = %d\n", i);  
    }  
    // 主線程調用退出函數退出, 地址空間不會被釋放  
    pthread_exit(NULL);   
     return 0; 
} 

四、線程回收

4.1 線程函數

線程和進程一樣，子線程退出的時候其內核資源主要由主線程回收，線程庫中提供的線程回收函叫做 pthread_join()，這個函數是一個阻塞函數，如果還有子線程在運行，調用該函數就會阻塞，子線程退出函數解除阻塞進行資源的回收，函數被調用一次，只能回收一個子線程，如果有多個子線程則需要循環進行回收。

另外通過線程回收函數還可以獲取到子線程退出時傳遞出來的數據，函數原型如下： 

#include <pthread.h>  
// 這是一個阻塞函數, 子線程在運行這個函數就阻塞  
// 子線程退出, 函數解除阻塞, 回收對應的子線程資源, 類似于回收進程使用的函數 wait()  
int pthread_join(pthread_t thread, void **retval); 

參數:

•  thread: 要被回收的子線程的線程 ID
•  retval: 二級指針，指向一級指針的地址，是一個傳出參數，這個地址中存儲了 pthread_exit () 傳遞出的數據，如果不需要這個參數，可以指定為 NULL

返回值：線程回收成功返回 0，回收失敗返回錯誤號。

4.2 回收子線程數據

在子線程退出的時候可以使用 pthread_exit() 的參數將數據傳出，在回收這個子線程的時候可以通過 phread_join() 的第二個參數來接收子線程傳遞出的數據。接收數據有很多種處理方式，下面來列舉幾種：

4.2.1 使用子線程棧通過函數 pthread_exit(void *retval); 可以得知，子線程退出的時候，需要將數據記錄到一塊內存中，通過參數傳出的是存儲數據的內存的地址，而不是具體數據，由因為參數是 void* 類型，所有這個萬能指針可以指向任意類型的內存地址。先來看第一種方式，將子線程退出數據保存在子線程自己的棧區： 

// pthread_join.c  
#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <pthread.h>  
// 定義結構  
struct Persion  
{  
    int id;  
    char name[36];  
    int age;  
};  
// 子線程的處理代碼  
void* working(void* arg)  
{  
    printf("我是子線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<9; ++i)  
    {  
        printf("child == i: = %d\n", i);  
        if(i == 6)  
        {  
            struct Persion p;  
            p.age  =12;  
            strcpy(p.name, "tom");  
            p.id = 100;  
            // 該函數的參數將這個地址傳遞給了主線程的pthread_join()  
            pthread_exit(&p);  
        }  
    }  
    return NULL; // 代碼執行不到這個位置就退出了  
}  
int main()  
{  
    // 1. 創建一個子線程  
    pthread_t tid;  
    pthread_create(&tid, NULL, working, NULL);  
    printf("子線程創建成功, 線程ID: %ld\n", tid);  
    // 2. 子線程不會執行下邊的代碼, 主線程執行  
    printf("我是主線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<3; ++i)  
    {  
        printf("i = %d\n", i);  
    }  
    // 阻塞等待子線程退出  
    void* ptr = NULL;  
    // ptr是一個傳出參數, 在函數內部讓這個指針指向一塊有效內存  
    // 這個內存地址就是pthread_exit() 參數指向的內存  
    pthread_join(tid, &ptr);  
    // 打印信息  
    struct Persion* pp = (struct Persion*)ptr;  
    printf("子線程返回數據: name: %s, age: %d, id: %d\n", pp->name, pp->age, pp->id);  
    printf("子線程資源被成功回收...\n");  
    return 0;  
} 

編譯并執行測試程序: 

# 編譯代碼  
$ gcc pthread_join.c -lpthread  
# 執行程序  
$ ./a.out   
子線程創建成功, 線程ID: 140652794640128  
我是主線程, 線程ID: 140652803008256  
i = 0  
i = 1  
i = 2  
我是子線程, 線程ID: 140652794640128  
child == i: = 0  
child == i: = 1  
child == i: = 2  
child == i: = 3  
child == i: = 4  
child == i: = 5  
child == i: = 6  
子線程返回數據: name: , age: 0, id: 0  
子線程資源被成功回收... 

通過打印的日志可以發現，在主線程中沒有沒有得到子線程返回的數據信息，具體原因是這樣的：

如果多個線程共用同一個虛擬地址空間，每個線程在棧區都有一塊屬于自己的內存，相當于棧區被這幾個線程平分了，當線程退出，線程在棧區的內存也就被回收了，因此隨著子線程的退出，寫入到棧區的數據也就被釋放了。

4.2.2 使用全局變量

位于同一虛擬地址空間中的線程，雖然不能共享棧區數據，但是可以共享全局數據區和堆區數據，因此在子線程退出的時候可以將傳出數據存儲到全局變量、靜態變量或者堆內存中。在下面的例子中將數據存儲到了全局變量中： 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <pthread.h>  
// 定義結構  
struct Persion  
{  
    int id;  
    char name[36];  
    int age;  
};  
struct Persion p; // 定義全局變量  
// 子線程的處理代碼  
void* working(void* arg)  
{  
    printf("我是子線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<9; ++i)  
    {  
        printf("child == i: = %d\n", i);  
        if(i == 6)  
        {  
            // 使用全局變量  
            p.age  =12;  
            strcpy(p.name, "tom");  
            p.id = 100;  
            // 該函數的參數將這個地址傳遞給了主線程的pthread_join()  
            pthread_exit(&p);  
        }  
    }  
    return NULL;  
}  
int main()  
{  
    // 1. 創建一個子線程  
    pthread_t tid;  
    pthread_create(&tid, NULL, working, NULL);  
    printf("子線程創建成功, 線程ID: %ld\n", tid);  
    // 2. 子線程不會執行下邊的代碼, 主線程執行 
     printf("我是主線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<3; ++i)  
    {  
        printf("i = %d\n", i);  
    }  
    // 阻塞等待子線程退出  
    void* ptr = NULL;  
    // ptr是一個傳出參數, 在函數內部讓這個指針指向一塊有效內存  
    // 這個內存地址就是pthread_exit() 參數指向的內存  
    pthread_join(tid, &ptr);  
    // 打印信息  
    struct Persion* pp = (struct Persion*)ptr;  
    printf("name: %s, age: %d, id: %d\n", pp->name, pp->age, pp->id);  
    printf("子線程資源被成功回收...\n");  
     return 0; 
} 

4.2.3 使用主線程棧

雖然每個線程都有屬于自己的棧區空間，但是位于同一個地址空間的多個線程是可以相互訪問對方的棧空間上的數據的。由于很多情況下還需要在主線程中回收子線程資源，所以主線程一般都是最后退出，基于這個原因在下面的程序中將子線程返回的數據保存到了主線程的棧區內存中： 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <pthread.h>  
// 定義結構  
struct Persion  
{  
    int id;  
    char name[36];  
    int age;  
};  
// 子線程的處理代碼  
void* working(void* arg)  
{  
    struct Persion* p = (struct Persion*)arg;  
    printf("我是子線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<9; ++i)  
    {  
        printf("child == i: = %d\n", i);  
        if(i == 6)  
        {  
            // 使用主線程的棧內存  
            p->age  =12;  
            strcpy(p->name, "tom");  
            p->id = 100;  
            // 該函數的參數將這個地址傳遞給了主線程的pthread_join()  
            pthread_exit(p);  
        }  
    }  
    return NULL;  
} 
int main()  
{  
    // 1. 創建一個子線程  
    pthread_t tid;  
    struct Persion p;  
    // 主線程的棧內存傳遞給子線程  
    pthread_create(&tid, NULL, working, &p);  
    printf("子線程創建成功, 線程ID: %ld\n", tid);  
    // 2. 子線程不會執行下邊的代碼, 主線程執行  
    printf("我是主線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<3; ++i)  
    {  
        printf("i = %d\n", i);  
    }  
    // 阻塞等待子線程退出  
    void* ptr = NULL;  
    // ptr是一個傳出參數, 在函數內部讓這個指針指向一塊有效內存  
    // 這個內存地址就是pthread_exit() 參數指向的內存  
    pthread_join(tid, &ptr);  
    // 打印信息  
    printf("name: %s, age: %d, id: %d\n", p.name, p.age, p.id);  
    printf("子線程資源被成功回收...\n");   
     return 0;  
} 

在上面的程序中，調用 pthread_create() 創建子線程，并將主線程中棧空間變量 p 的地址傳遞到了子線程中，在子線程中將要傳遞出的數據寫入到了這塊內存中。也就是說在程序的 main() 函數中，通過指針變量 ptr 或者通過結構體變量 p 都可以讀出子線程傳出的數據。

五、線程分離

在某些情況下，程序中的主線程有屬于自己的業務處理流程，如果讓主線程負責子線程的資源回收，調用 pthread_join() 只要子線程不退出主線程就會一直被阻塞，主要線程的任務也就不能被執行了。

在線程庫函數中為我們提供了線程分離函數 pthread_detach()，調用這個函數之后指定的子線程就可以和主線程分離，當子線程退出的時候，其占用的內核資源就被系統的其他進程接管并回收了。線程分離之后在主線程中使用 pthread_join() 就回收不到子線程資源了。 

#include <pthread.h>  
// 參數就子線程的線程ID, 主線程就可以和這個子線程分離了  
int pthread_detach(pthread_t thread); 

下面的代碼中，在主線程中創建子線程，并調用線程分離函數，實現了主線程和子線程的分離： 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <pthread.h>  
// 子線程的處理代碼  
void* working(void* arg)  
{  
    printf("我是子線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<9; ++i)  
    {  
        printf("child == i: = %d\n", i);  
    }  
    return NULL;  
} 
int main()  
{  
    // 1. 創建一個子線程  
    pthread_t tid;  
    pthread_create(&tid, NULL, working, NULL);  
    printf("子線程創建成功, 線程ID: %ld\n", tid);  
    // 2. 子線程不會執行下邊的代碼, 主線程執行  
    printf("我是主線程, 線程ID: %ld\n", pthread_self()); 
    for(int i=0; i<3; ++i)  
    {  
        printf("i = %d\n", i);  
    }  
    // 設置子線程和主線程分離  
    pthread_detach(tid);  
    // 讓主線程自己退出即可  
    pthread_exit(NULL);   
     return 0; 
} 

六、其他線程函數

6.1 線程取消

線程取消的意思就是在某些特定情況下在一個線程中殺死另一個線程。使用這個函數殺死一個線程需要分兩步：

•  在線程 A 中調用線程取消函數 pthread_cancel，指定殺死線程 B，這時候線程 B 是死不了的
•  在線程 B 中進程一次系統調用（從用戶區切換到內核區），否則線程 B 可以一直運行。

這其實和七步斷腸散、含笑半步癲的功效是一樣的，吃了毒藥不動或者不笑也沒啥事兒 

#include <pthread.h>  
// 參數是子線程的線程ID  
int pthread_cancel(pthread_t thread); 

•  參數：要殺死的線程的線程 ID
•  返回值：函數調用成功返回 0，調用失敗返回非 0 錯誤號。

在下面的示例代碼中，主線程調用線程取消函數，只要在子線程中進行了系統調用，當子線程執行到這個位置就掛掉了。 

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <string.h>  
#include <pthread.h>  
// 子線程的處理代碼  
void* working(void* arg)  
{  
    int j=0;  
    for(int i=0; i<9; ++i)  
    {  
        j++;  
    }  
    // 這個函數會調用系統函數, 因此這是個間接的系統調用  
    printf("我是子線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<9; ++i)  
    {  
        printf(" child i: %d\n", i);  
    }  
    return NULL;  
}  
int main()  
{  
    // 1. 創建一個子線程  
    pthread_t tid;  
    pthread_create(&tid, NULL, working, NULL);  
    printf("子線程創建成功, 線程ID: %ld\n", tid);  
    // 2. 子線程不會執行下邊的代碼, 主線程執行  
    printf("我是主線程, 線程ID: %ld\n", pthread_self());  
    for(int i=0; i<3; ++i)  
    { 
        printf("i = %d\n", i);  
    }  
    // 殺死子線程, 如果子線程中做系統調用, 子線程就結束了  
    pthread_cancel(tid);  
    // 讓主線程自己退出即可  
    pthread_exit(NULL);   
     return 0;  
} 

關于系統調用有兩種方式：

1.   直接調用 Linux 系統函數
2.   調用標準 C 庫函數，為了實現某些功能，在 Linux 平臺下標準 C 庫函數會調用相關的系統函數

6.2 線程 ID 比較

在 Linux 中線程 ID 本質就是一個無符號長整形，因此可以直接使用比較操作符比較兩個線程的 ID，但是線程庫是可以跨平臺使用的，在某些平臺上 pthread_t 可能不是一個單純的整形，這中情況下比較兩個線程的 ID 必須要使用比較函數，函數原型如下： 

#include <pthread.h>  
int pthread_equal(pthread_t t1, pthread_t t2); 

•  參數：t1 和 t2 是要比較的線程的線程 ID
•  返回值：如果兩個線程 ID 相等返回非 0 值，如果不相等返回 0