1.執行緒池概念

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

2.執行緒池概念圖

• 沒有執行緒池好比銀行業務視窗只有一個，那么人越多，等待時間越長，效率越低，內核就好比單一視窗里面的服務人員，長時間大量處理業務，難免會出現問題，執行緒池的概念就好比多開放幾個視窗，來節省時間，提高效率，
• 在服務器接收來自用戶發來的任務時，需要創建執行緒去處理任務，而這都需要花時間為代價，如果任務佇列接受一個任務創建一個執行緒的去處理任務，那么在面對大量任務的同時，對用戶來說，需要等待很長時間，效率很低，對內核來說，需要頻繁的內核申請，創建執行緒，銷毀執行緒，造成內核過度呼叫，降低性能與效率，

3.執行緒池的應用場景

1. 需要大量的執行緒來完成任務，且完成任務的時間比較短， WEB服務器完成網頁請求這樣的任務，使用執行緒池技術是非常合適的，因為單個任務小，而任務數量巨大，你可以想象一個熱門網站的點擊次數， 但對于長時間的任務，比如一個Telnet連接請求，執行緒池的優點就不明顯了，因為Telnet會話時間比執行緒的創建時間大多了，
2. 對性能要求苛刻的應用，比如要求服務器迅速回應客戶請求，
3. 接受突發性的大量請求，但不至于使服務器因此產生大量執行緒的應用，

4.執行緒池的種類

1. 創建固定數量執行緒池，回圈從任務佇列中獲取任務物件，
2. 獲取到任務物件后，執行任務物件中的任務介面

5.代碼示例

//ThreadPool.hpp

#pragma once
#include<iostream>
#include<queue>
#include<math.h>
#include<unistd.h>

#define NUM 5 //執行緒數量

class Task //任務（求一個數的平方）
{
  private:
    int base;
  public:
    Task()
    {}
    Task(int _b):base(_b)
    {}
    void Run()
    {
      std::cout<< "pthread id:["<< pthread_self()<<"] "<<base<< ":" <<"pow is: "<< pow(base,2) <<std::endl;
    }
    ~Task()
    {}
};

class ThreadPool 
{
  private:
    std::queue<Task*> q; //任務佇列
    int max_num;  //執行緒數量
    pthread_t *t; //執行緒陣列
    pthread_mutex_t lock; //互斥鎖
    pthread_cond_t cond;//只有消費者需要環境變數，生產者不需要，如果需要說明環形佇列任務已滿，
  public:
    void LockQueue() 
    {
      pthread_mutex_lock(&lock);
    }
    bool Isempty()
    {
      return q.size()==0;
    }
    void ThreadWait()
    {
      pthread_cond_wait(&cond,&lock);
    }
    void UnLockQueue()
    {
      pthread_mutex_unlock(&lock);
    }
    void ThreadWakeup()
    {
      //pthread_cond_signal(&cond);
      pthread_cond_broadcast(&cond);
    }
  public:
    ThreadPool(int _max = NUM):max_num(_max)
    {}
    static void *Rountine(void* arg)
    {
      ThreadPool *tp = (ThreadPool*)arg;
      while(1)
      { 
        sleep(2);
        tp->LockQueue(); // 給任務佇列上鎖，保持互斥
        while(tp->Isempty())
        {
          tp->ThreadWait(); //如果為空則掛起（沒有任務執行緒無序處理等待任務到來）
        }
        Task t;  
        tp->Get(t); // 有任務并拿走任務
        tp->UnLockQueue(); // 解鎖
        t.Run(); // 處理任務
      }
      sleep(2);
    }
    void ThreadPoolInit()
    {
        pthread_mutex_init(&lock,nullptr); //初始化鎖
        pthread_cond_init(&cond,nullptr); //初始化環境變數
        pthread_t *t=new pthread_t[max_num]; // 創建執行緒陣列
        for(int i=0;i<max_num;i++)
        {
            pthread_create(t+i,nullptr,Rountine,this); //創建執行緒
        }
    }
    void Put(Task &in) // 給任務佇列里面放任務
    {
        LockQueue();
        q.push(&in);
        UnLockQueue();
        
        ThreadWakeup();
    }

    void Get(Task &out) //拿任務
    {
        Task *t = q.front();
        q.pop();
        out = *t;
    }
    ~ThreadPool()
    {
      pthread_mutex_destroy(&lock); //銷毀鎖
      pthread_cond_destroy(&cond); //銷毀環境變數
      delete []t; //銷毀陣列
    }
};

//main.cpp

#include "ThreadPool.hpp"

int main()
{
  ThreadPool *tp = new ThreadPool(5); //創建執行緒池
  tp->ThreadPoolInit(); //初始換執行緒池

  while(1) //主執行緒創建任務
  {
    int x=rand()%10 + 1;  //計算1到10之間亂數的平方
    Task t(x);
    tp->Put(t); //將任務放進任務佇列
    sleep(1);
  }
  return 0;
}

5.1 運行結果

5.1.1 只喚醒單個執行緒

5.1.2 一次喚醒所有執行緒

• 驚群效應：
• 驚群效應（thundering herd）是指多行程（多執行緒）在同時阻塞等待同一個事件的時候（休眠狀態），如果等待的這個事件發生，那么他就會喚醒等待的所有行程（或者執行緒），但是最終卻只能有一個行程（執行緒）獲得這個時間的“控制權”，對該事件進行處理，而其他行程（執行緒）獲取“控制權”失敗，只能重新進入休眠狀態，這種現象和性能浪費就叫做驚群效應，

6.執行緒池存在價值

1. 有任務，立馬有執行緒進行服務，省掉了執行緒創建的時間，
2. 有效防止服務器中執行緒過多，導致系統過載的問題，

6.1 執行緒池 VS 行程池

1. 執行緒池占用資源更少，但是健壯性（魯棒性）不強，
2. 行程池占用資源更多，但是健壯性（魯棒性）很強，

7. 執行緒安全的單例模式

7.1 什么是單例模式

• 單例模式是一種 “經典的, 常用的, 常考的” 設計模式，

7.2 什么是設計模式

• IT行業這么火, 涌入的人很多. 俗話說林子大了啥鳥都有. 大佬和菜雞們兩極分化的越來越嚴重. 為了讓菜雞們不太拖大佬的后腿, 于是大佬們針對一些經典的常見的場景, 給定了一些對應的解決方案, 這個就是 設計模式，

7.4 單例模式的特點

• 某些類, 只應該具有一個物件(實體), 就稱之為單例,例如一個男人只能有一個媳婦，
• 在很多服務器開發場景中, 經常需要讓服務器加載很多的資料 (上百G) 到記憶體中. 此時往往要用一個單例的類來管理這些資料，

8. 其他常見的各種鎖

• 悲觀鎖：在每次取資料時，總是擔心資料會被其他執行緒修改，所以會在取資料前先加鎖（讀鎖，寫鎖，行鎖等），當其他執行緒想要訪問資料時，被阻塞掛起，
• 樂觀鎖：每次取資料時候，總是樂觀的認為資料不會被其他執行緒修改，因此不上鎖，但是在更新資料前，會判斷其他資料在更新前有沒有對資料進行修改，主要采用兩種方式：版本號機制和CAS操作，
• CAS操作：當需要更新資料時，判斷當前記憶體值和之前取得的值是否相等，如果相等則用新值更新，若不等則失敗，失敗則重試，一般是一個自旋的程序，即不斷重試，
• 自旋鎖，公平鎖，非公平鎖，

9. 讀者寫者問題

• 在撰寫多執行緒的時候，有一種情況是十分常見的，那就是，有些公共資料修改的機會比較少，相比較改寫，它們讀的機會反而高的多，通常而言，在讀的程序中，往往伴隨著查找的操作，中間耗時很長，給這種代碼段加鎖，會極大地降低我們程式的效率，那么有沒有一種方法，可以專門處理這種多讀少寫的情況呢？ 有，那就是讀寫鎖，
  
• 注意：寫獨占，讀共享，讀鎖優先級高，

9.1 生產者消費者 VS 讀者寫者

讀者寫者：

• 讀者讀者之間是共享關系，讀者寫者之間是互斥同步關系，寫者之間互斥關系，
• 生產者消費者VS讀者寫者：消費者會取走資料，而讀者不會，只看到資料就行，

9.2 讀寫鎖介面

讀寫鎖的初始化與銷毀 ：

• 引數rwlock表示的是一個讀寫鎖，attr是讀寫鎖的屬性，一般設定為NULL；

讀加鎖：

寫加鎖：

• rdlock若申請不到鎖，則自旋，tryrdlock若申請不到鎖，則回傳，由用戶自旋；

解鎖：

10.自旋鎖

自旋鎖的型別：

• 普通自旋鎖
• 讀寫自旋鎖
• big-reader自旋鎖

10.1 自旋鎖介面

• 初始化以及銷毀鎖：
  
• 上鎖：
  
• 解鎖：
  

10.2 自旋鎖缺點

• 如果執行緒執行的任務需要非常長的時間，或者執行緒對共享資料的競爭相當激烈,那么使用自旋鎖的效率就很低，因為自旋的程序中，一直無法獲取到鎖，一直在白白的浪費CPU的資源，
• 可能引起死鎖
• 過多的占用CPU資源

10.3 自旋鎖與互斥鎖的異同：

• 自旋鎖與互斥鎖都是為對臨界資源進行保護而創造的一種鎖機制，不同之處在于，執行單元在持有互斥鎖期間，其它需要該資源的執行單元是要進入睡眠狀態的，而執行單元持有自旋鎖期間，其它需要該資源的執行單元是進行不斷的嘗試的，直到持有自旋鎖的單元釋放自旋鎖，則可以獲得該資源，自旋鎖這個名字也是由此得來，而且，由于需要獲得該鎖的單元不斷進行嘗試，所以，自旋鎖的效率是遠高于互斥鎖的，