[導讀]本章將分為兩大部分進行講解，前半部分將引出線程的使用場景及基本概念，通過示例代碼來說明一個線程創(chuàng)建到退出到回收的基本流程。后半部分則會通過示例代碼來說明如何控制好線程，從臨界資源訪問與線程的執(zhí)行順序控制上引出互斥鎖、信號量的概念與使用方法。

本章將分為兩大部分進行講解，前半部分將引出線程的使用場景及基本概念，通過示例代碼來說明一個線程創(chuàng)建到退出到回收的基本流程。后半部分則會通過示例代碼來說明如何控制好線程，從臨界資源訪問與線程的執(zhí)行順序控制上引出互斥鎖、信號量的概念與使用方法。

5.1 線程的使用

5.1.1 為什么要使用多線程

在編寫代碼時，是否會遇到以下的場景會感覺到難以下手？

場景一：寫程序在拷貝文件時，需要一邊去拷貝文件，一邊去向用戶展示拷貝文件的進度時，傳統(tǒng)做法是通過每次拷貝完成結(jié)束后去更新變量，再將變量轉(zhuǎn)化為進度顯示出來。其中經(jīng)歷了拷貝->計算->顯示->拷貝->計算->顯示...直至拷貝結(jié)束。

這樣的程序架構(gòu)及其的低效，必須在單次拷貝結(jié)束后才可以刷新當前拷貝進度，若可以將進程分支，一支單獨的解決拷貝問題，一支單獨的解決計算刷新問題，則程序效率會提升很多。

場景二：用阻塞方式去讀取數(shù)據(jù)，實時需要發(fā)送數(shù)據(jù)的時候。例如在進行串口數(shù)據(jù)傳輸或者網(wǎng)絡(luò)數(shù)據(jù)傳輸?shù)臅r候，我們往往需要雙向通信，當設(shè)置讀取數(shù)據(jù)為阻塞模式時候，傳統(tǒng)的單線程只能等到數(shù)據(jù)接收來臨后才能沖過阻塞，再根據(jù)邏輯進行發(fā)送。

當我們要實現(xiàn)隨時發(fā)送、隨時接收時，無法滿足我們的業(yè)務(wù)需求。若可以將進程分支，一支單純的處理接收數(shù)據(jù)邏輯，一支單純的解決發(fā)送數(shù)據(jù)邏輯，就可以完美的實現(xiàn)功能。基于以上場景描述，多線程編程可以完美的解決上述問題。

5.1.2 線程概念

所謂線程，就是操作系統(tǒng)所能調(diào)度的最小單位。普通的進程，只有一個線程在執(zhí)行對應(yīng)的邏輯。我們可以通過多線程編程，使一個進程可以去執(zhí)行多個不同的任務(wù)。

相比多進程編程而言，線程享有共享資源，即在進程中出現(xiàn)的全局變量，每個線程都可以去訪問它，與進程共享“4G”內(nèi)存空間，使得系統(tǒng)資源消耗減少。本章節(jié)來討論Linux下POSIX線程。

5.1.3 線程的標識pthread_t

對于進程而言，每一個進程都有一個唯一對應(yīng)的PID號來表示該進程，而對于線程而言，也有一個“類似于進程的PID號”，名為tid，其本質(zhì)是一個pthread_t類型的變量。線程號與進程號是表示線程和進程的唯一標識，但是對于線程號而言，其僅僅在其所屬的進程上下文中才有意義。

在程序中，可以通過函數(shù)，pthread_self，來返回當前線程的線程號，例程1是打印線程tid號。

獲取線程號
#include <pthread.h>
pthread_t pthread_self(void);
成功：返回線程號

測試例程1：（Phtread_txex1.c）

1 #include <pthread.h>
2 #include <stdio.h>
3
4 int main()
5 {
6  pthread_t tid = pthread_self();//獲取主線程的tid號
7  printf("tid = %lu\n",(unsigned long)tid);
8  return 0;
9 }

注意：

因采用POSIX線程接口，故在要編譯的時候包含pthread庫，使用gcc編譯應(yīng)gcc xxx.c -lpthread 方可編譯多線程程序。

編譯運行結(jié)果：

5.1.4 線程的創(chuàng)建

創(chuàng)建線程
#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
成功：返回0

在傳統(tǒng)的程序中，一個進程只有一個線程，可以通過函數(shù)pthread_create來創(chuàng)建線程。

該函數(shù)第一個參數(shù)為pthread_t類型的線程號地址，當函數(shù)執(zhí)行成功后會指向新建線程的線程號；

第二個參數(shù)表示了線程的屬性，一般傳入NULL表示默認屬性；

第三個參數(shù)代表返回值為void*，形參為void*的函數(shù)指針，當線程創(chuàng)建成功后，會自動的執(zhí)行該回調(diào)函數(shù)；

第四個參數(shù)則表示為向線程處理函數(shù)傳入的參數(shù)，若不傳入，可用NULL填充，有關(guān)線程傳參后續(xù)小節(jié)會有詳細的說明，接下來通過一個簡單例程來使用該函數(shù)創(chuàng)建出一個線程。

測試例程2：（Phtread_txex2.c）

1  #include <pthread.h>
2  #include <stdio.h>
3  #include <unistd.h>
4  #include <errno.h>
5 
6  void *fun(void *arg)
7  {
8   printf("pthread_New = %lu\n",(unsigned long)pthread_self());//打印線程的tid號
9  }
10
11 int main()
12 {
13
14  pthread_t tid1;
15  int ret = pthread_create(&tid1,NULL,fun,NULL);//創(chuàng)建線程
16  if(ret != 0){
17   perror("pthread_create");
18   return -1;
19  }
20
21  /*tid_main 為通過pthread_self獲取的線程ID，tid_new通過執(zhí)行pthread_create成功后tid指向的空間*/
22  printf("tid_main = %lu tid_new = %lu \n",(unsigned long)pthread_self(),(unsigned long)tid1);
23  
24  /*因線程執(zhí)行順序隨機，不加sleep可能導致主線程先執(zhí)行，導致進程結(jié)束，無法執(zhí)行到子線程*/
25  sleep(1);
26
27  return 0;
28 }
29

運行結(jié)果：

通過pthread_create確實可以創(chuàng)建出來線程，主線程中執(zhí)行pthread_create后的tid指向了線程號空間，與子線程通過函數(shù)pthread_self打印出來的線程號一致。

特別說明的是，當主線程伴隨進程結(jié)束時，所創(chuàng)建出來的線程也會立即結(jié)束，不會繼續(xù)執(zhí)行。并且創(chuàng)建出來的線程的執(zhí)行順序是隨機競爭的，并不能保證哪一個線程會先運行。可以將上述代碼中sleep函數(shù)進行注釋，觀察實驗現(xiàn)象。

去掉上述代碼25行后運行結(jié)果：

上述運行代碼3次，其中有2次被進程結(jié)束，無法執(zhí)行到子線程的邏輯，最后一次則執(zhí)行到了子線程邏輯后結(jié)束的進程。

因此可以說明，線程的執(zhí)行順序不受控制，且整個進程結(jié)束后所產(chǎn)生的線程也隨之被釋放，在后續(xù)內(nèi)容中將會描述如何控制線程執(zhí)行。

5.1.5 向線程傳入?yún)?shù)

pthread_create()的最后一個參數(shù)的為void類型的數(shù)據(jù)，表示可以向線程傳遞一個void數(shù)據(jù)類型的參數(shù)，線程的回調(diào)函數(shù)中可以獲取該參數(shù)，例程3舉例了如何向線程傳入變量地址與變量值。

測試例程3：（Phtread_txex3.c）

1  #include <pthread.h>
2  #include <stdio.h>
3  #include <unistd.h>
4  #include <errno.h>
5 
6  void *fun1(void *arg)
7  {
8   printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
9  }
10
11 void *fun2(void *arg)
12 {
13  printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
14 }
15
16 int main()
17 {
18
19  pthread_t tid1,tid2;
20  int a = 50;
21  int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);//創(chuàng)建線程傳入變量a的地址
22  if(ret != 0){
23   perror("pthread_create");
24   return -1;
25  }
27  ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);//創(chuàng)建線程傳入變量a的值
28  if(ret != 0){
29   perror("pthread_create");
30   return -1;
31  }
32  sleep(1);
33  printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
34  return 0;
35 }
36

運行結(jié)果：

本例程展示了如何利用線程創(chuàng)建函數(shù)的第四個參數(shù)向線程傳入數(shù)據(jù)，舉例了如何以地址的方式傳入值、以變量的方式傳入值，例程代碼的21行，是將變量a先行取地址后，再次強制類型轉(zhuǎn)化為void后傳入線程，線程處理的回調(diào)函數(shù)中，先將萬能指針void轉(zhuǎn)化為int*，再次取地址就可以獲得該地址變量的值，其本質(zhì)在于地址的傳遞。例程代碼的27行，直接將int類型的變量強制轉(zhuǎn)化為void進行傳遞（針對不同位數(shù)機器，指針對其字數(shù)不同，需要int轉(zhuǎn)化為long在轉(zhuǎn)指針，否則可能會發(fā)生警告），在線程處理回調(diào)函數(shù)中，直接將void數(shù)據(jù)轉(zhuǎn)化為int類型即可，本質(zhì)上是在傳遞變量a的值。

上述兩種方法均可得到所要的值，但是要注意其本質(zhì)，一個為地址傳遞，一個為值的傳遞。當變量發(fā)生改變時候，傳遞地址后，該地址所對應(yīng)的變量也會發(fā)生改變，但傳入變量值的時候，即使地址指針所指的變量發(fā)生變化，但傳入的為變量值，不會受到指針的指向的影響，實際項目中切記兩者之間的區(qū)別。具體說明見例程4.

測試例程4：（Phtread_txex4.c）

1  #include <pthread.h>
2  #include <stdio.h>
3  #include <unistd.h>
4  #include <errno.h>
5 
6  void *fun1(void *arg)
7  {
8   while(1){
9   
10   printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
11   sleep(1);
12  }
13 }
14
15 void *fun2(void *arg)
16 {
17  while(1){
18  
19   printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
20   sleep(1);
21  }
22 }
23
24 int main()
25 {
26
27  pthread_t tid1,tid2;
28  int a = 50;
29  int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
30  if(ret != 0){
31   perror("pthread_create");
32   return -1;
33  }
34  sleep(1);
35  ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);
36  if(ret != 0){
37   perror("pthread_create");
38   return -1;
39  }
40  while(1){
41   a++;
42   sleep(1);
43   printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
44  }
45  return 0;
46 }
47

運行結(jié)果：

上述例程講述了如何向線程傳遞一個參數(shù)，在處理實際項目中，往往會遇到傳遞多個參數(shù)的問題，我們可以通過結(jié)構(gòu)體來進行傳遞，解決此問題。

測試例程5：（Phtread_txex5.c）

1  #include <pthread.h>
2  #include <stdio.h>
3  #include <unistd.h>
4  #include <string.h>
5  #include <errno.h>
6 
7  struct Stu{
8   int Id;
9   char Name[32];
10  float Mark;
11 };
12
13 void *fun1(void *arg)
14 {
15  struct Stu *tmp = (struct Stu *)arg;
16  printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,tmp->Id,tmp->Name,tmp->Mark);
17  
18 }
19
20 int main()
21 {
22
23  pthread_t tid1,tid2;
24  struct Stu stu;
25  stu.Id = 10000;
26  strcpy(stu.Name,"ZhangSan");
27  stu.Mark = 94.6;
28
29  int ret = pthread_create(&tid1,NULL,fun1,(void *)&stu);
30  if(ret != 0){
31   perror("pthread_create");
32   return -1;
33  }
34  printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,stu.Id,stu.Name,stu.Mark);
35  sleep(1);
36  return 0;
37 }
38

運行結(jié)果：

5.1.6 線程的退出與回收

線程的退出情況有三種：第一種是進程結(jié)束，進程中所有的線程也會隨之結(jié)束。第二種是通過函數(shù)pthread_exit來主動的退出線程。第三種通過函數(shù)pthread_cancel被其他線程被動結(jié)束。

當線程結(jié)束后，主線程可以通過函數(shù)pthread_join/pthread_tryjoin_np來回收線程的資源，并且獲得線程結(jié)束后需要返回的數(shù)據(jù)。

線程退出
#include <pthread.h>
void pthread_exit(void *retval);

該函數(shù)為線程退出函數(shù)，在退出時候可以傳遞一個void*類型的數(shù)據(jù)帶給主線程，若選擇不傳出數(shù)據(jù)，可將參數(shù)填充為NULL。

線程資源回收（阻塞）
#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
成功：返回0

該函數(shù)為線程回收函數(shù)，默認狀態(tài)為阻塞狀態(tài)，直到成功回收線程后被沖開阻塞。第一個參數(shù)為要回收線程的tid號，第二個參數(shù)為線程回收后接受線程傳出的數(shù)據(jù)。

線程資源回收（非阻塞）
#define _GNU_SOURCE            
#include <pthread.h>
 int pthread_tryjoin_np(pthread_t thread, void **retval);
成功：返回0

該函數(shù)為非阻塞模式回收函數(shù)，通過返回值判斷是否回收掉線程，成功回收則返回0，其余參數(shù)與pthread_join一致。

該函數(shù)傳入一個tid號，會強制退出該tid所指向的線程，若成功執(zhí)行會返回0：

線程退出（指定線程號）
#include <pthread.h>
int pthread_cancel(pthread_t thread);
成功：返回0

上述描述簡單的介紹了有關(guān)線程回收的API，下面通過例程來說明上述API。

測試例程6：（Phtread_txex6.c）


1  #include <pthread.h>
2  #include <stdio.h>
3  #include <unistd.h>
4  #include <errno.h>
5 
6  void *fun1(void *arg)
7  {
8   static int tmp = 0;//必須要static修飾，否則pthread_join無法獲取到正確值
9   //int tmp = 0;
10  tmp = *(int *)arg;
11  tmp+=100;
12  printf("%s:Addr = %p tmp = %d\n",__FUNCTION__,&tmp,tmp);
13  pthread_exit((void *)&tmp);//將變量tmp取地址轉(zhuǎn)化為void*類型傳出
14 }
15
16
17 int main()
18 {
19
20  pthread_t tid1;
21  int a = 50;
22  void *Tmp = NULL;//因pthread_join第二個參數(shù)為void**類型
23  int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
24  if(ret != 0){
25   perror("pthread_create");
26   return -1;
27  }
28  pthread_join(tid1,&Tmp);
29  printf("%s:Addr = %p Val = %d\n",__FUNCTION__,Tmp,*(int *)Tmp);
30  return 0;
31 }
32

運行結(jié)果：

上述例程先通過23行將變量以地址的形式傳入線程，在線程中做出了自加100的操作，當線程退出的時候通過線程傳參，用void*類型的數(shù)據(jù)通過pthread_join接受。

此例程去掉了之前加入的sleep函數(shù)，原因是pthread_join函數(shù)具備阻塞的特性，直至成功收回掉線程后才會沖破阻塞，因此不需要靠考慮主線程會執(zhí)行到30行結(jié)束進程的情況。

特別要說明的是例程第8行，當變量從線程傳出的時候，需要加static修飾，對生命周期做出延續(xù)，否則無法傳出正確的變量值。

測試例程7：（Phtread_txex7.c）

1  #define _GNU_SOURCE 
2  #include <pthread.h>
3  #include <stdio.h>
4  #include <unistd.h>
5  #include <errno.h>
6 
7  void *fun(void *arg)
8  {
9   printf("Pthread:%d Come !\n",(int )(long)arg+1);
10  pthread_exit(arg);
11 }
12
13
14 int main()
15 {
16  int ret,i,flag = 0;
17  void *Tmp = NULL;
18  pthread_t tid[3];
19  for(i = 0;i < 3;i++){
20   ret = pthread_create(&tid[i],NULL,fun,(void *)(long)i);
21   if(ret != 0){
22    perror("pthread_create");
23    return -1;
24   }
25  }
26  while(1){//通過非阻塞方式收回線程，每次成功回收一個線程變量自增，直至3個線程全數(shù)回收
27   for(i = 0;i <3;i++){
28    if(pthread_tryjoin_np(tid[i],&Tmp) == 0){
29     printf("Pthread : %d exit !\n",(int )(long )Tmp+1);
30     flag++; 
31    }
32   }
33   if(flag >= 3) break;
34  }
35  return 0;
36 }
37

運行結(jié)果：

例程7展示了如何使用非阻塞方式來回收線程，此外也展示了多個線程可以指向同一個回調(diào)函數(shù)的情況。例程6通過阻塞方式回收線程幾乎規(guī)定了線程回收的順序，若最先回收的線程未退出，則一直會被阻塞，導致后續(xù)先退出的線程無法及時的回收。

通過函數(shù)pthread_tryjoin_np，使用非阻塞回收，線程可以根據(jù)退出先后順序自由的進行資源的回收。

測試例程8：（Phtread_txex8.c）

1  #define _GNU_SOURCE 
2  #include <pthread.h>
3  #include <stdio.h>
4  #include <unistd.h>
5  #include <errno.h>
6 
7  void *fun1(void *arg)
8  {
9   printf("Pthread:1 come!\n");
10  while(1){
11   sleep(1);
12  }
13 }
14
15 void *fun2(void *arg)
16 {
17  printf("Pthread:2 come!\n");
18  pthread_cancel((pthread_t )(long)arg);//殺死線程1，使之強制退出
19  pthread_exit(NULL);
20 }
21
22 int main()
23 {
24  int ret,i,flag = 0;
25  void *Tmp = NULL;
26  pthread_t tid[2];
27  ret = pthread_create(&tid[0],NULL,fun1,NULL);
28  if(ret != 0){
29   perror("pthread_create");
30   return -1;
31  }
32  sleep(1);
33  ret = pthread_create(&tid[1],NULL,fun2,(void *)tid[0]);//傳輸線程1的線程號
34  if(ret != 0){
35   perror("pthread_create");
36   return -1;
37  }
38  while(1){//通過非阻塞方式收回線程，每次成功回收一個線程變量自增，直至2個線程全數(shù)回收

39   for(i = 0;i <2;i++){
40    if(pthread_tryjoin_np(tid[i],NULL) == 0){
41     printf("Pthread : %d exit !\n",i+1);
42     flag++; 
43    }
44   }
45   if(flag >= 2) break;
46  }
47  return 0;
48 }
49