1. 執行緒概念

1.1 什么是執行緒

??在作業系統中，如果我們執行了某一應用程式，那么作業系統就會對這個應用程式創建一系列的資源以用來讓這個程式在作業系統中運行起來，而整個創建程序以及創建成功后所產生的資源，我們將其稱為一個行程，
??所以說，行程是作業系統分配資源的基本單位，而執行緒通俗來講就是一個行程中一個執行流，這里以串行與并行下載檔案舉例，如果我們使用串行的方式去下載多個檔案，那么得到的結果是，將這些檔案逐個按個的下載，即上一個下載完成之后才會下載接下來的檔案，如果使用并行的方式下載，那么這些檔案就會一次同時下載多個檔案，而不是等待上一個下載完后才繼續下載接下來的，大大的提高了下載效率，
??通過上述例子，可以看出一個行程中可以同時執行多段程式代碼片段，而這種同時有多個程式片段在執行就稱為多執行緒，而其中的每一個執行流就被稱為一個執行緒，

1.2 從作業系統看執行緒

我們先來看一看行程是如何組織的，

執行緒又是如何組織的？

我們又稱執行緒位輕量級行程(LWP)，因為在linux內核中并沒有描述執行緒的結構體，執行緒與行程都使用struct task_struct{...}，所以在執行緒中pid被稱為執行緒號，tgid被稱為執行緒組id，對標行程id，
執行緒是作業系統調度的基本單位，行程是作業系統分配資源的基本單位

輕量級執行緒在哪里體現輕量級？
??在創建行程時，需要對該行程分配一系列的資源，資源如上圖所示，但是在創建執行緒時，就不需要開辟那些資源，與行程共用虛擬地址空間，大大減少了開銷，但執行緒也有自身獨立的空間執行緒號，堆疊，errno，信號屏蔽字，暫存器，調度優先級，共享空間有：檔案描述符、信號處理方式、當前的作業目錄、用戶id與組id，

1.3 執行緒的分類

執行緒分為主執行緒與作業執行緒，
主執行緒

• pid = tgid
• 一個行程中絕對有一個主執行緒

作業執行緒

• 同一個行程中的執行緒的執行緒組是相同的，標識是同一個行程
• 但pid不同，標識不同的行程
  

注意：多執行緒在作業執行時，也是搶占式執行的，所有當有很多行程同時在執行時，cpu采用時間片輪轉的方式，輪流執行所有行程，

1.4 執行緒的優缺點

優點

• 創建執行緒的代價要小于創建行程
• 與行程切換相比，執行緒之間的切換需要作業系統做的作業很少，執行緒切換只需要交換背景關系資訊即可
• 執行緒占用的資源比行程少很多
• 可以充分利用多處理器的可并行數量
• 在等待慢速I/O操作結束的同時，系統可以執行其他的計算任務
• 計算密集型應用，為了能在多處理器系統上運行，將計算分解到多個執行緒中實作
• I/O密集型應用，為了提高性能，將I/O操作重疊，執行緒可以同時等待不同的I/O操作

缺點

• 性能損失
  如果一個行程中的多個執行緒在頻繁的進行切換，則程式的運行效率會降低，因為性能損失在了執行緒切換當中，行程的執行效率，隨著執行緒數量的增多，性能呈現出正態分布的狀況，
• 代碼健壯性降低
  一個執行緒的崩潰，會導致整個行程的崩潰
• 缺乏訪問控制
  多個執行緒在訪問同一個變數時可能會導致程式結果的二義性

2. 執行緒控制

2.1 執行緒創建

函式介面

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);
// 引數
//   tread: pthread_t執行緒識別符號型別，回傳執行緒ID，出參
//   attr: 執行緒屬性，一般情況傳遞NULL，采用默認屬性
//   start_routine: 執行緒的入口函式，執行緒創建完畢、啟動后執行的函式
//   art: 傳遞給執行緒啟動函式的引數

// 回傳值: 成功回傳0，失敗回傳1 

代碼測驗

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

struct ThreadNum
{
    int thread_num_;
};


void* MyThreadStrat(void* arg)
{
    struct ThreadNum* tn = (struct ThreadNum*)arg;
    while(1)
    {
        printf("MyThreadStrat: %d\n", tn->thread_num_);
        sleep(1);
    }
    delete tn;
    return NULL;
}

int main()
{
    pthread_t tid;
    for(int i = 0; i < 2; i++)
    {
        struct ThreadNum* tn = new ThreadNum;
        if(tn == NULL)
        {
            exit(1);
        }

        tn->thread_num_ = i;
        int ret = pthread_create(&tid, NULL, MyThreadStrat, (void*)tn);
        if(ret != 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    while(1)
    {
        printf("i am main thread\n");
        sleep(1);
    }
    return 0;
}

注意：

• 執行緒入口函式的引數最好不傳遞臨時變數，因為臨時變數在創建完畢后會銷毀，而執行緒中的arg指標就變成了野指標，盡量傳遞堆上開辟空間，
• 執行緒入口函式的引數如果傳遞的為堆上開辟的空間，則釋放時是在執行緒不去使用這塊空間的條件下釋放，
• 執行緒入口函式的引數不僅可以傳遞內置型別還可以傳遞自定義型別，

2.2 執行緒終止

1. 執行緒入口函式的return回傳，當前執行緒也進行了退出

2. 函式退出

函式一：
void pthread_exit(void* retval);
// 作用：誰呼叫誰退出
// 引數：執行緒在退出的時候回傳的內容

函式二：
int pthread_canael(pthread_t thread);
// 作用: 退出thread執行緒，thread為執行緒描述符

pthread_t pthread_self(void);
// 作用: 誰呼叫回傳誰的執行緒識別符號

代碼測驗

#include <stdio.h>      
#include <stdlib.h>      
#include <unistd.h>      
#include <pthread.h>                                                                                                                     
                                                                                                                                         
void* MyThreadStrat(void* arg)      
{      
	// 兩種退出方法，退出則不會列印下方內容
    pthread_exit(NULL);                                                                                                                                                  
    pthread_cancel(pthread_self());  
                                                                                                                                                               
    printf("MyThreadStrat :%s\n", (char*)arg);                                                                                                                 
                                                                                                                                                               
    return NULL;                                                                                                                                               
}                                                                                                                                                              
                                                                                                                                                               
int main()                                                                                                                                                     
{                                                                                                                                                              
    pthread_t tid;                                                                                                                                             
    for(int i = 0; i < 2; i++)                                                                                                                                 
    {                                                                                                                                                          
        int ret = pthread_create(&tid, NULL, MyThreadStrat, NULL);                                                                                             
        if(ret != 0)                                                                                                                                           
        {                                                                                                                                                      
            perror("pthread_create");                                                                                                                          
            return 0;                                                                                                                                          
        }                                                                                                                                                      
    }                                                                                                                                                          
                                                                                                                                                               
    while(1)                                                                                                                                                   
    {                                                                                                                                                          
        printf("i am main thread\n");                                                                                                                          
        sleep(1);                                                                                                                                              
    }                                                                                                                                                          
    return 0;
}

注意：

默認創建執行緒時，執行緒的屬性時joinable屬性，joinable會導致執行緒在退出時，需要別人來回收自己的退出資源(即執行緒退出了，但是執行緒在共享區當中的空間還沒有釋放)，所以就需要執行緒等待或者執行緒分離，來解決當前問題，

2.3 執行緒等待

已經退出的執行緒，其空間沒有被釋放，仍然在行程的地址空間內，創建新的執行緒不會復用剛才退出執行緒的地址空間，

int pthread_join(pthread_t thread, void **retval);
// 作用: 等待行程退出
// 引數:
//   thread: 執行緒識別符號，想要等待哪一個執行緒退出
//   retval: 
//		1.如果thread執行緒通過return回傳,value_ ptr所指向的單元里存放的是thread執行緒函式的回傳值，
//		2. 如果thread執行緒被別的執行緒呼叫pthread_ cancel例外終掉,value_ ptr所指向的單元里存放的是常數PTHREAD_CANCELED，
//		3. 如果thread執行緒是自己呼叫pthread_exit終止的,value_ptr所指向的單元存放的是傳給pthread_exit的引數，
//		4. 如果對thread執行緒的終止狀態不感興趣,可以傳NULL給value_ ptr引數，
// 回傳值：成功回傳0；失敗回傳錯誤碼

代碼測驗

#include <stdio.h>    
#include <stdlib.h>    
#include <string.h>    
#include <unistd.h>    
#include <pthread.h>    
    
void *thread1(void *arg)    
{    
    printf("thread 1 returning ... \n");    
    int *p = (int*)malloc(sizeof(int));    
    *p = 1;    
    
    return (void*)p;    
}    
    
void *thread2(void *arg)    
{    
    printf("thread 2 exiting ...\n");    
    int *p = (int*)malloc(sizeof(int));    
    *p = 2;    
    pthread_exit((void*)p);    
    
}    
    
void *thread3(void *arg)    
{    
    while ( 1)    
    {    
        printf("thread 3 is running ...\n");    
        sleep(1);    
    }    
    
    return NULL;    
}    
    
int main()    
{    
    pthread_t tid;    
    void *ret;    
    
    // thread 1 return    
    pthread_create(&tid, NULL, thread1, NULL);    
    pthread_join(tid, &ret);    
 	printf("thread return, thread id %X, return code:%d\n", tid, *(int*)ret);    
    free(ret);    
    
    // thread 2 exit    
    pthread_create(&tid, NULL, thread2, NULL);    
    pthread_join(tid, &ret);    
  	printf("thread return, thread id %X, return code:%d\n", tid, *(int*)ret);    
    free(ret);    
    
    // thread 3 cancel by other    
    pthread_create(&tid, NULL, thread3, NULL);    
    sleep(3);    
    pthread_cancel(tid);    
    pthread_join(tid, &ret);    
    
    if ( ret == PTHREAD_CANCELED  )    
      printf("thread return, thread id %X, return code:PTHREAD_CANCELED\n", tid);    
    else    
      printf("thread return, thread id %X, return code:NULL\n", tid);    

	return 0;
}     

現象

2.4 執行緒分離

一個執行緒被設定為分離屬性，則該執行緒在退出之后，不需要其他執行流回收該行程的資源，而是由作業系統統一回收，

函式介面

int pthread_detach(pthread_t thread)
// 給thread執行緒設定分離屬性，thread執行緒也可以是自己

代碼實作

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


void* MyThreadStrat(void* arg)
{
    (void)arg;
    pthread_detach(pthread_self());
    
    while(1)
    {
        printf("i am MyThreadStrat\n");
        pthread_cancel(pthread_self());
        sleep(1);
    }

    sleep(20);
    return NULL;
}

int main()
{
    pthread_t tid;

    int ret = pthread_create(&tid, NULL, MyThreadStrat, NULL);
    if(ret != 0)
    {
        perror("pthread_create");
        return 0;
    }

    while(1)
    {
        printf("i am main thread\n");
        sleep(1);
    }
    return 0;
}

執行一遍 函式內部資料就進行退出，退出時不需要手動釋放資源，而是由作業系統進行資源的釋放，

3. 執行緒安全

3.1 執行緒不安全的現象

以下大致模擬了一個黃牛搶票的系統，使用4個執行緒同時去搶1000張票，我們的預期結果是，4個執行緒沒人拿到的票都不相同，不會拿到同一張票，但是：

代碼

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

#define THREADNUM 4

int g_val = 100;

void* buyTicket(void* arg)
{
    while (1)
    {
        if (g_val > 0)
        {
            printf("%p:have ticket %d\n", pthread_self(), g_val);
            g_val--;
        }
        else
        {
            break;
        }
    }

    return NULL;
}

int main()
{
    pthread_t tid[THREADNUM];
    for (int i = 0; i < THREADNUM; i++)
    {
        int ret = pthread_create(&tid[i], NULL, buyTicket, NULL);
        if (ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    for (int i = 0; i < THREADNUM; i++)
    {
        pthread_join(tid[i], NULL);
    }

    return 0;
}

如上就是我們說的執行緒不安全的現象

當多個執行緒訪問同一個資源時，這個資源不能夠保持原子性，就有可能發生結果錯誤，

總結

假設有一個cpu，兩個執行緒A和B，執行緒AB都想對全域變數g_i做++操作，假設執行緒A先運行，但是執行緒A將g_i讀取到暫存器后，A的時間片使用完了被執行緒切換了，但是A沒有對g_i的值修改完成，而是被執行緒B讀取修改完成了，等到執行緒切換回來之后，執行緒A還是對原本的g_i修改，不是對執行緒B修改完后的值進行修改，兩個執行緒都進行了++操作，但是結果不符合預期，所以造成了結果的錯誤，

3.1 如何解決–互斥鎖

??上述黃牛搶票的問題，如果我們給上述的4個黃牛，只給一個特殊的令牌，只有搶到這個令牌之后，才有資格買票，但是買完票之后必須把令牌交出來，4個人再次公平競爭，搶到令牌的才可以去買票，這樣就保證了每個人買的票都是唯一的，不會出現多人買一張票，我們將上述的令牌就叫做互斥鎖，

3.1.1 互斥鎖原理

??互斥鎖保證多個執行流在訪問同一個臨界資源時，其操作時原子性的，

名詞解釋

• 執行流: 執行緒
• 臨界資源: 多個執行緒都能訪問到的資源
• 臨界區: 訪問臨界資源的代碼區被稱為臨界區
• 原子操作: 要么執行流還沒有開始執行臨界區代碼，要么已經執行完畢臨界區代碼

原理
??互斥鎖的底層是一個互斥量，互斥量的本質時一個計數器，該計數器的取值只能為0或者1，0代表不能獲取互斥鎖，1標識可以獲取互斥鎖，

加鎖時原理

如何保證我們拿鎖的這個程序是原子性操作？

??為了實作互斥鎖操作,大多數體系結構都提供了swap或exchange指令,該指令的作用是把暫存器和記憶體單元的資料相交換,由于只有一條指令,保證了原子性,即使是多處理器平臺,訪問記憶體的 總線周期也有先后,一個處理器上的交換指令執行時另一個處理器的交換指令只能等待總線周期，
??在加鎖之前，申請一個暫存器，暫存器中放入0，直接入記憶體中的值進行交換，交換后暫存器值有兩種結果: 暫存器中為1: 加鎖成功；暫存器中為0: 加鎖失敗，

解鎖時原理
直接將暫存器中的值置為1，不關心記憶體的值，直接交換完成就是解鎖的程序，

3.1.2 互斥鎖介面

1. 初始化介面

1.動態初始化: 必須手動銷毀否則記憶體泄露
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
              const pthread_mutexattr_t *restrict attr);
// 引數:
//    pthread_mutex_t mutex: 互斥鎖型別，傳遞一個互斥鎖變數給該地址
// 	  attr: 一般傳遞NULL，采用默認屬性

2.靜態初始化: 系統自動回收
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// 使用宏進行初始化

2. 銷毀介面

int pthread_mutex_destroy(pthread_mutex_t *mutex);
// 銷毀指定互斥量

3. 加鎖介面

阻塞加鎖: 如果沒加上鎖就一直加鎖
int pthread_mutex_lock(pthread_mutex_t *mutex);

非阻塞加鎖: 需要搭配回圈判斷回傳值
int pthread_mutex_trylock(pthread_mutex_t *mutex);

帶有超時時間的加鎖介面
int pthread_mutex_timelock(pthread_mutex_t* restrict mutex,
			const struct timspec* restrict abs_timeout);
// 引數：struct timspec { 
//			time_t tv_sec;  // 秒
//			long tv_nesc:   // 納秒
//      }

注意: 加鎖位置一定要放在訪問臨界資源之前

4. 解鎖介面

以上三種加鎖的方式，都可以使用該介面解鎖
int pthread_mutex_unlock(pthread_mutex_t *mutex);

注意: 在所有可能導致執行緒退出的地方進行解鎖，否則可能造成死鎖得情況

黃牛搶票改良

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

#define THREADNUM 4

int g_val = 100;
pthread_mutex_t g_lock;

void* buyTicket(void* arg)
{
    while (1)
    {
        // 即將訪問臨界資源，加鎖
        pthread_mutex_lock(&g_lock);

        if (g_val > 0)
        {
            printf("%p:have ticket %d\n", pthread_self(), g_val);
            g_val--;
        }
        else
        {
            // 可能會導致退出 解鎖
            pthread_mutex_unlock(&g_lock);
            break;
        }

        // 可能會導致退出 還鎖
        // 如果不在此處進行解鎖的操作，則本次回圈結束后，還是會進行拿鎖，但是鎖在上方并沒有還掉
        pthread_mutex_unlock(&g_lock);
    }

    return NULL;
}

int main()
{
    // 初始化互斥鎖
    pthread_mutex_init(&g_lock, NULL);

    pthread_t tid[THREADNUM];
    for (int i = 0; i < THREADNUM; i++)
    {
        int ret = pthread_create(&tid[i], NULL, buyTicket, NULL);
        if (ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    for (int i = 0; i < THREADNUM; i++)
    {
        pthread_join(tid[i], NULL);
    }

	// 銷毀互斥鎖         
	pthread_mutex_destroy(&g_lock); 
       
    return 0;
}

程式運行之后，發現多人搶到一張票得情況消失，

3.2 死鎖

3.2.1 死鎖的現象

1.如果執行流加載完畢之后不進行解鎖操作則會造成死鎖現象

void* buyTicket(void* arg)
{
   while (1)
   {
       // 即將訪問臨界資源，加鎖
       pthread_mutex_lock(&g_lock);

       if (g_val > 0)
       {
           printf("%p:have ticket %d\n", pthread_self(), g_val);
           g_val--;
       }
       else
       {
           break;
       }
   }

   return NULL;
}

上述代碼會不會造成死鎖現象，答案是會的，如果一開始這個行程拿到了鎖，但是這個程式在回圈結束后沒有釋放鎖，并且在下一次回圈還要去申請鎖，就會導致阻塞在一直拿鎖得這個地方，這就是所謂的死鎖，

2.執行緒A獲取到了1鎖，執行緒B獲取到了2鎖，同時執行緒A還想獲取1鎖，執行緒B還想獲取2鎖，

pthread_mutex_t g_lock1;
pthread_mutex_t g_lock2;

void* MyThreadStartA(void* arg)
{
    pthread_mutex_lock(&g_lock1);
    sleep(3);
    pthread_mutex_lock(&g_lock2);

    return NULL;
}

void* MyThreadStartB(void* arg)
{
    pthread_mutex_lock(&g_lock2);
    sleep(3);
    pthread_mutex_lock(&g_lock1);

    return NULL;
}

這個表現得是兩不相讓，我有鎖但是我不釋放，你就是拿不走，互相制約就造成了死鎖，

3.2.2 死鎖的必要條件

• 互斥條件：一個執行流獲取了互斥鎖之后，其他執行流不能獲取該鎖
• 不可剝奪：A執行流拿著互斥鎖，其他執行不能釋放
• 回圈等待：多個執行流各自拿著對方想要的鎖，并且各個執行流還去請求對方的鎖
• 請求與保持：拿著一把鎖還去申請別的鎖

3.2.3 避免產生死鎖的方法

• 破環死鎖的必要條件：回圈等待，請求與保持
• 加鎖順序一致
• 避免鎖未釋放的場景
• 資源一次性分配

3.2.3 gdb除錯排查死鎖位置

1. 發生了死鎖

2.查找行程號 ps aux 命令


3.除錯正在死鎖的行程gdb attach [pid]命令

4. 查看所有執行緒的堆疊 thread apply all bt命令

5. 進入執行緒的堆疊t 堆疊號命令

6. 查看當前堆疊內容，并進入自定義函式內部

7. 列印行程鎖變數查看具體資訊
ower欄位標識行程鎖目前在那個執行緒手中，

如上就是查看互斥鎖在哪個位置發生了死鎖，

3.3 執行緒同步

??執行緒同步指的是，在保證資料安全的情況下(互斥鎖)，讓多個執行流按照特定的順序進行臨界區資源的訪問，稱之為同步，

??為什么要讓多個執行流按照特定的順序進行臨界區的資源訪問呢？

這里我們舉一個取盤子與放盤子的例子，規定放盤子時要保證桌面上是空的沒有盤子，取盤子時桌子上有且只有一個盤子，
??因為盤子屬于臨界區資源，如果我們要取或者放時，必須保證這個操作是原子性的，所以在取和放動作之前都要進行加鎖，但是對這個操作加鎖了之后就能夠完全保證桌面上只會出現兩種情況嗎？答案是不能的，因為取和放這兩個操作是同步執行的，依靠兩個執行緒的競爭能力去競爭那把鎖，如果有放盤子執行緒的競爭能力特別強，那么就會出現桌面上的盤子已經放了高高一沓了，但是取盤子卻一直都取不到盤子，這種結果顯然不是我們想看到的，所以在這里用到了執行緒同步，讓多個執行緒按照順序去訪問，
??比如說，桌面上沒有盤子時去通知放盤子的執行緒向桌面上放盤子，當桌面上有一個盤子時，放盤子的動作就應該停止，讓取盤子的動作去取桌面上的盤子，這樣就可以看到我們想看到結果，

3.3.1 條件變數

條件變數的本質是一個PCB等待佇列，在該佇列中存放的是執行緒或者行程的PCB，如果有多個執行緒，則將這些執行緒放入該等待佇列，這些佇列按照佇列的方式順序的出入隊，

當一個執行緒互斥地訪問某個變數時，它可能發現在其它執行緒改變狀態之前，它什么也做不了，
例如一個執行緒訪問佇列時，發現佇列為空，它只能等待，直到其它執行緒將一個節點添加到佇列中，這種情況就需要用到條件變數，

3.3.1 執行緒同步的介面函式

1. 初始化介面

動態初始化: 搭配銷毀函式使用
int pthread_cond_init(pthread_cond_t *restrict cond,
              const pthread_condattr_t *restrict attr);
// pthread_cond_t cond:: 條件變數型別，接收一個條件變數定義的變數地址
// attr: 條件變數的屬性，一般傳遞NULL，使用默認屬性

靜態初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

2. 銷毀介面

int pthread_cond_destroy(pthread_cond_t *cond);

3. 等待介面

int pthread_cond_wait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex);
// 作用：誰呼叫就將誰放入等待佇列
// 引數：cond 條件變數，mutex 互斥鎖

注意

• 為什么等待介面需要傳入互斥鎖變數？
  ??在等待函式內部，需要對互斥鎖進行釋放，釋放之后其它執行緒才可以拿到鎖正常的進行其它操作，當函式呼叫回傳時，回傳到了臨界區內，所以該函式又會讓執行緒重新持有該鎖，
  ??eg: 我們在取盤子時，如果桌面上沒有盤子，則無法取盤子要通知放盤子的動作取放盤子，但是放盤子的動作是需要訪問臨界資源的，現在的鎖在取盤子的執行緒中，所以放盤子拿不到鎖就無法向桌面上放盤子，執行緒就進入了死鎖狀態，因此我們需要將取盤子執行緒放入等待佇列時，把鎖釋放掉，放盤子就可以拿到鎖，進而正常操作，

4. 喚醒介面

喚醒一個執行緒
int pthread_cond_signal(pthread_cond_t *cond);

喚醒所有執行緒
int pthread_cond_broadcast(pthread_cond_t *cond);

代碼示例

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

int g_val = 1;

pthread_mutex_t g_lock;
pthread_cond_t g_cond;

void* Product(void* arg)
{
    while (true)
    {
        pthread_mutex_lock(&g_lock);

        while (g_val >= 1)
        {
            // 等待消費者消費完
            pthread_cond_wait(&g_cond, &g_lock);
        }

        g_val++;
        printf("Product done..:%d\n", g_val);

        pthread_mutex_unlock(&g_lock);

        // 通知消費者進行消費
        pthread_cond_signal(&g_cond);                                                                                                                                                                                                                                                                                                                                             
    }
}

void* Consume(void* arg)
{
    while (true)
    {
        pthread_mutex_lock(&g_lock);

        while (g_val <= 0)
        {
            pthread_cond_wait(&g_cond, &g_lock);
        }
        g_val--;
        printf("Consume done..: %d\n", g_val);

        pthread_mutex_unlock(&g_lock);
        pthread_cond_signal(&g_cond);
    }
}

int main()
{
    pthread_t pt, ct;
    pthread_mutex_init(&g_lock, NULL);
    pthread_cond_init(&g_cond, NULL);

    pthread_create(&pt, NULL, Product, NULL);
    pthread_create(&ct, NULL, Consume, NULL);

    pthread_join(pt, NULL);
    pthread_join(ct, NULL);

    return 0;
}

3.3.2 注意

如果有多個生產消費者，那么只用一個條件變數夠嗎？

上述代碼中，只有單消費者，單生產者，如果有多個生產消費者，那么我們只有一個條件變數是不可以的，所有生產消費者都使用一個等待佇列，那么一定會造成阻塞，即所有生產消費者全部都阻塞在一個等待佇列中，

解釋
如果所有生產消費者使用一個等待佇列，那么它們一定會同時去搶同一個鎖，誰有了鎖誰就有了操作臨界區資源的權力，
用上面放盤子的例子舉例，如果開始桌面上沒有盤子，那么取盤子的執行緒1拿到了鎖，可以取盤子，但是沒有盤子，取盤子執行緒1就會進入阻塞佇列并且通知放盤子的人取放盤子，放盤子執行緒3搶到了鎖，就會在桌面上放盤子，并且把鎖放出來，如果放盤子執行緒4搶到了鎖，放盤子4就會進入阻塞佇列并且釋放鎖，那么這個時候如果放盤子3又搶到了鎖，看到桌面上有盤子，它也被放入了阻塞佇列，這個時候外面就只剩一個取盤子執行緒2了，這個執行緒一定會拿到鎖，并且把桌面上的盤子取出來，取完之后，取盤子執行緒1會從函式呼叫回傳，并且和執行緒2一起在阻塞佇列外準備搶鎖，這個時候取盤子執行緒2拿到了鎖，一看桌子上沒盤子了，進等待佇列，鎖就到了執行緒1手里，同樣也進入了等待佇列，那么這個時候，4個執行緒全部都在等待佇列中，沒有人去通知了，那么4個執行緒一直等待，程式死鎖，

如何解決

生產者與消費者一定要有兩個不同的等待佇列，去相互喚醒才不會造成上述的局面，

改正后代碼

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

int g_val = 1;

pthread_mutex_t g_lock;
pthread_cond_t p_cond;   // 生產者的佇列
pthread_cond_t c_cond;   // 消費者的佇列

void* Product(void* arg)
{
    while (true)
    {
        pthread_mutex_lock(&g_lock);

        while (g_val >= 1)
        {
            // 等待消費者消費完
            pthread_cond_wait(&p_cond, &g_lock);
        }

        g_val++;
        printf("Product done..:%d\n", g_val);

        pthread_mutex_unlock(&g_lock);

        // 通知消費者進行消費
        pthread_cond_signal(&c_cond);
    }
}

void* Consume(void* arg)
{
    while (true)
    {
        pthread_mutex_lock(&g_lock);

        while (g_val <= 0)
        {
            pthread_cond_wait(&c_cond, &g_lock);
        }
        g_val--;
        printf("Consume done..: %d\n", g_val);

        pthread_mutex_unlock(&g_lock);
        pthread_cond_signal(&p_cond);
    }
}

int main()
{
    pthread_t pt, ct;
    pthread_mutex_init(&g_lock, NULL);
    pthread_cond_init(&p_cond, NULL);
    pthread_cond_init(&c_cond, NULL);

    pthread_create(&pt, NULL, Product, NULL);
    pthread_create(&ct, NULL, Consume, NULL);

    pthread_join(pt, NULL);
    pthread_join(ct, NULL);

    pthread_mutex_destroy(&g_lock);
    pthread_cond_destroy(&p_cond);
    pthread_cond_destroy(&c_cond);                                                                                                                                                                                                                             

    return 0;
}

4. 生產者與消費者模型

為何要使用生產者消費者模型?

??生產者消費者模式就是通過一個容器來解決生產者和消費者的強耦合問題，生產者和消費者彼此之間不直接通訊，而通過阻塞佇列來進行通訊，所以生產者生產完資料之后不用等待消費者處理，直接扔給阻塞佇列，消費者不找生產者要資料，而是直接從阻塞佇列里取，阻塞佇列就相當于一個緩沖區，平衡了生產者和消費者的處理能力，這個阻塞佇列就是用來給生產者和消費者解耦的，

例如：我們在超市購物，購買商品都是從超市中購買，而不是從每個商品的生產廠家去購買，如果我們從生產廠家直接去購買，就會非常麻煩，每個商品都有很多生產廠家，而且又有很多商品，如果我們用一個中間媒介，將生產廠家的物品全部放入這個媒介中，顧客在這個媒介就可以隨意的挑選很多生產廠家其中的一個物品，大大提高了顧客的便利性，也讓顧客與廠家的關系沒有這么強，

關系
生產者消費者模型,本質上就是在一塊記憶體空間中，多個執行緒負責生產，多個執行緒負責消費，

其中生產者與消費者的關系是:

• 生產者與生產者: 互斥關系，任何時間只允許一個操作臨時變數
• 生產者與消費者: 同步關系
• 消費者與消費者: 互斥關系

使用該模型的代碼實作

main函式
#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

#include "BlockQueue.hpp"


void* Consume(void* arg)
{
    BlockQueue* bq = (BlockQueue*)arg;

    int data;
    while (true)
    {
        bq->PopData(data);
        cout << "consume: " << data << endl;
        sleep(1);
    }
}

void* Product(void* arg)
{
    BlockQueue* bq = (BlockQueue*)arg;

    int data;
    while (true)
    {
        data = rand() % 5;
        bq->PushData(data);
        cout << "product: " << data << endl;
    }
}

int main()
{
    BlockQueue* bq = new BlockQueue;

    pthread_t c, p;

    pthread_create(&c, NULL, Consume, (void*)bq);
    pthread_create(&p, NULL, Product, (void*)bq);

    pthread_join(c, NULL);
    pthread_join(p, NULL);

    return 0;                                                                                                                                                                                                                                                                                                         
}


//
/阻塞佇列//

#pragma once    
    
#include <iostream>    
#include <queue>    
#include <stdlib.h>    
#include <pthread.h>    
using namespace std;    
    
#define NUM 5     
    
class BlockQueue    
{    
public:    
    BlockQueue(int cap = NUM)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
        : _cap(cap)    
    {    
        pthread_mutex_init(&lock, NULL);    
        pthread_cond_init(&c_cond, NULL);    
        pthread_cond_init(&p_cond, NULL);    
    }    
    
    // 生產者將屬于放入阻塞佇列
    void PushData(const int& data)    
    {    
        LockQueue();    
        while (IsFull())    
        {    
            NotifyConsume();    
            ProductWait();    
            std::cout << "queue full, NotifyConsume" << std::endl;    
        }    
    
        q.push(data);    
        NotifyConsume();    
        UnlockQueue();    
    }    
    
    // 從阻塞佇列中去數資料
    void PopData(int& data)    
    {    
        LockQueue();    
        while (IsEmpty())    
        {    
            NotifyProduct();    
            ConsumeWait();    
            std::cout << "queue empty, NotifyProduct" << std::endl;    
        }    
    
        data = q.front();    
        q.pop();    
        NotifyConsume();    
        UnlockQueue();    
    }    
    
    ~BlockQueue()    
    {    
        pthread_mutex_destroy(&lock);    
        pthread_cond_destroy(&c_cond);    
        pthread_cond_destroy(&p_cond);    
    }    
    
private:    
    void LockQueue()    
    {    
        pthread_mutex_lock(&lock);    
    }    
    
    void UnlockQueue()    
    {    
        pthread_mutex_unlock(&lock);    
    }    
    
    void ProductWait()    
    {    
        pthread_cond_wait(&p_cond, &lock);    
    }    
    
    void ConsumeWait()    
    {    
        pthread_cond_wait(&c_cond, &lock);    
    }    
    
    void NotifyProduct()    
    {    
        pthread_cond_signal(&p_cond);    
    }    
    
    void NotifyConsume()    
    {    
        pthread_cond_signal(&c_cond);    
    }    
    
    bool IsEmpty()    
    {    
        return q.empty();    
    }    
    
    bool IsFull()    
    {    
      return q.size() >= _cap;    
    }    
    
private:    
    std::queue<int> q;    
    int _cap;    
    pthread_mutex_t lock;    
    pthread_cond_t p_cond; // 生產者同步    
    pthread_cond_t c_cond; // 消費者同步    
};    

5. 信號量

POSIX信號量和SystemV信號量作用相同，都是用于同步操作，達到無沖突的訪問共享資源目的， 但POSIX可以用于執行緒間同步，這里我們介紹的信號量為POSIX標準下的，

5.1 信號量本質

??信號量的本質其實是一個計數器+PCB等待佇列共同構成，其中計數器是描述臨界資源有效個數的一個計數器，其中計數器的操作一定是原子性的，當多個執行緒想要獲取信號量時，都會對信號量中的資源計數器進行-1操作，
??在信號量中，我們不用過多關心其中的原子性如何保持的，在介面內部已經將這種機制實作了，

資源計數器

• > 0: 表示還有多少資源可以使用
• = 0: 表示沒有資源可以被使用
• < 0: 表示有多少執行緒在等待資源

5.2 信號量的同步與互斥

互斥

初始化信號量的資源計數器為1，表示當前只有一個資源可以被使用，意味著只有同一個執行緒在同一時刻可以獲取到信號量，

同步

資源計數器在初始化時為當前的資源數量，因為在對資源使用時，介面會自動管理當前計數器的數值，

5.3 信號量的介面函式

1. 初始化介面

int sem_init(sem_t *sem, int pshared, usigned int value);
引數:
	sem: 傳入待要初始化的信號量
	pshard: 表示信號量用于執行緒間還是行程間
			0 執行緒間    非0 行程間
	value: 表示初始化的資源數量

2. 銷毀介面

int sem_destroy(sem_t* sem);

3. 等待介面

呼叫該介面函式，會對資源計數器執行-1操作
int sem_wait(sem_t* sem);
// 阻塞等待

4. 發布介面

呼叫該介面，會對資源計數器進行+1操作
int sem_post(sem_t* sem);

5.4 基于信號量完成生產者消費模型

此示例中使用回圈佇列存放任務

RingQueue.hpp/
#pragma once 

#include <iostream>
#include <vector>
#include <unistd.h>
#include <semaphore.h>

class RingQueue
{
public:
    RingQueue(int cap = 10)
        : _cap(cap)
        , q(cap)
    {
        sem_init(&data_sem, 0, 0);
        sem_init(&blank_sem, 0, cap);
        sem_init(&lock_sem, 0, 1);
    
        c_index = 0;
        p_index = 0;
    }

    void Put(int& data)
    {
        P(data_sem);
        
        sem_wait(&lock_sem);
        q[c_index] = data;
        c_index++;
        c_index = c_index % _cap;
        sem_post(&lock_sem);
        
        V(blank_sem);
    }

    void Get(int& data)
    {
        P(blank_sem);
        
        sem_wait(&lock_sem);
        data = q[p_index];
        p_index++;
        p_index = p_index % _cap;
        sem_post(&lock_sem);
        
        V(data_sem);
    }

    ~RingQueue()
    {
        sem_destroy(&data_sem);
        sem_destroy(&blank_sem);
    }

private:
    void P(sem_t &s)
    {
        sem_wait(&s);
    }

    void V(sem_t &s)
    {
        sem_post(&s);
    }

private:
    std::vector<int> q;
    int _cap;
    sem_t data_sem;  // 消費者
    sem_t blank_sem; // 生產者
    sem_t lock_sem;  // 保證互斥關系
    
    int c_index;     // 消費者下標
    int p_index;     // 生產者下標
};

//

//modle///

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

#include "RingQueue.hpp"

#define THREADNUM 4

void* Consume(void* arg)
{
    RingQueue* rq = (RingQueue*)arg;

    int data = 0;
    while (true)
    {
        rq->Get(data);
        cout << "consume:" << data << endl;
        sleep(1);
    }
}

void* Product(void* arg)
{
    RingQueue* rq = (RingQueue*)arg;

    int data = 0;
    while (true)
    {
        rq->Put(data);
        data++;
        cout << "product finish " << endl;

        if (data == 10)
        {
            data = 0;
        }
    }
}

int main()
{
    pthread_t c[THREADNUM], p[THREADNUM];
    RingQueue* rq = new RingQueue;
    
    for (int i = 0; i < THREADNUM; i++)
    {
        pthread_create(&c[i], NULL, Consume, rq);
        pthread_create(&p[i], NULL, Product, rq);
    }
    
    for (int i = 0; i < THREADNUM; i++)
    {
        pthread_join(c[i], NULL);
        pthread_join(p[i], NULL);
    }

    delete rq;

    return 0;
}

6. 執行緒池

6.1 概念

一種執行緒使用模式，執行緒過多會帶來調度開銷，進而影響快取區域性和整體性能，而執行緒池維護著多個執行緒，等待著監督管理者分配可并發執行的任務，這避免了在處理短時間任務時創建與銷毀執行緒的代價，執行緒池不僅能夠保證內核的充分利用，還能防止過分調度，可用執行緒數量應該取決于可用的并發處理器、處理器內核、記憶體、網路sockets等的數量，

6.2 應用場景

• 需要大量的執行緒來完成任務，且完成任務的時間比較短， WEB服務器完成網頁請求這樣的任務，使用執行緒池技術是非常合適的，因為單個任務小，而任務數量巨大，你可以想象一個熱門網站的點擊次數， 但對于長時間的任務，比如一個Telnet連接請求，執行緒池的優點就不明顯了，因為Telnet會話時間比執行緒的創建時間大多了，
• 對性能要求苛刻的應用，比如要求服務器迅速回應客戶請求，
• 接受突發性的大量請求，但不至于使服務器因此產生大量執行緒的應用，突發性大量客戶請求，在沒有執行緒池情況下，將產生大量執行緒，雖然理論上大部分作業系統執行緒數目最大值不是問題，短時間內產生大量執行緒
  可能使記憶體到達極限，出現錯誤.

6.3 執行緒池的代碼實作

執行緒池代碼

#pragma once     
    
#include <iostream>    
#include <queue>    
#include <pthread.h>    
#include <math.h>    
#include <unistd.h>    
    
class Task    
{    
private:    
    int base;    
    
public:    
    Task()    
    {}    
    
    Task(int _b)    
        : base(_b)    
    {}    
    
    void Run()    
    {    
        std::cout << "pthread[" << pthread_self() << "]task run... done: base: " << base << " pow is: " << pow(base, 2) <<std::endl;    
    }    
    
    ~Task()    
    {    
    
    }    
    
};    
    
class ThreadPool    
{    
private:    
    std::queue<Task*> q;    
    int max_num;    
    pthread_mutex_t lock;    
    pthread_cond_t cond;    // 消費者使用    
    
public:    
    bool quitFlag;    
    
public:    
    void LockQueue()    
    {    
        pthread_mutex_lock(&lock);    
    }    
    
    void UnlockQueue()    
    {    
        pthread_mutex_unlock(&lock);    
    }    
    
    bool IsEmpty()    
    {    
        return q.size() == 0;    
    }    
    
    void ThreadWait()    
    {    
        pthread_cond_wait(&cond, &lock);    
    }    
    
    void ThreadWakeUp()    
    {    
        pthread_cond_signal(&cond);    
    }    
    
    void ThreadsWakeUp()    
    {    
        pthread_cond_broadcast(&cond);    
    }    
    
public:    
    ThreadPool(int max = 5)    
        : max_num(max)    
        , quitFlag(false)    
    {}    
    
    // 執行緒創建后執行的任務函式    
    static void* Routine(void* arg)    
    {    
        ThreadPool* this_pool = (ThreadPool*)arg;    
        while (!this_pool->quitFlag)    
        {    
            this_pool->LockQueue();    
    
            while (!this_pool->quitFlag && this_pool->IsEmpty())    
            {    
               this_pool->ThreadWait();    
            }    
    
            // 取任務    
            Task t;    
            // 如果佇列要退出 并且佇列中沒有任務則不用取任務    
            if (!this_pool->quitFlag && !this_pool->IsEmpty())    
            {    
                this_pool->Get(t);    
            }    
    
            this_pool->UnlockQueue();    
    
            // 處理任務    
            if(!this_pool->quitFlag && this_pool->IsEmpty())    
            {    
                t.Run();    
            }    
        }    
    }    
    
    void ThreadPoolInit()    
    {    
        pthread_mutex_init(&lock, nullptr);    
        pthread_cond_init(&cond, nullptr);    
    
        // 創建執行緒池中的執行緒們    
        pthread_t t;    
        for (int i = 0; i < max_num; i++)    
        {    
            // 引數傳遞this指標，否則無法呼叫成員函式    
            pthread_create(&t, nullptr, Routine, this);    
        }    
    }    
    
    // 向任務佇列中放入任務    
    void Push(Task &in)    
    {    
        LockQueue();    
        q.push(&in);    
        UnlockQueue();    
    
        // 喚醒一個執行緒處理任務    
        ThreadWakeUp();    
    }    
    
    // 取出佇列中的任務 并喚醒一個行程進行處理    
    void Get(Task &out)    
    {    
        Task* t = q.front();    
        q.pop();    
        out = *t;    
    }    
    
    void ThreadQuit()    
    {    
        // 任務沒有執行完 則不退出    
        if (!IsEmpty())    
        {    
            std::cout << "task queue is not IsEmpty" << std::endl;    
            return;    
        }    
    
        quitFlag = true;    
    
        // 喚醒所有執行緒，退出執行緒    
        ThreadsWakeUp();    
        pthread_exit(NULL);    
    }    
    
    ~ThreadPool()    
    {    
        pthread_mutex_destroy(&lock);    
        pthread_cond_destroy(&cond);    
    }    
};                                              

測驗代碼

#include "ThreadPool.hpp"    
    
int main()    
{    
    ThreadPool *tp = new ThreadPool;    
    tp->ThreadPoolInit();    
    
    int count = 20;    
    while(count > 0)    
    {    
    	// 向執行緒池內分配任務
        int data = rand() % 10 + 1;    
        Task t(data);    
        tp->Push(t);    
        sleep(1);    
        count--;    
    }    
    
    // 執行緒執行完后退出執行緒：    
    tp->ThreadQuit();                                                                                                                                                    
    
    return 0;    
}