在C++學習過程中，要想“更上一層樓”的話，多線程編程是必不可少的一步，前面的文章多半是基礎方面的內容，這節的話稍微有點拔高。所以說，我們在看這篇文章的時候，大家需要更多的思考是為什么這么做？這樣做的好處是什么？以及多線程編程都可以應用在哪里？話不多說，跟著我一起認真探討這塊內容。

1、多線程 傳統的C++（C++11標準之前）中并沒有引入線程這個概念，在C++11出來之前，如果我們想要在C++中實現多線程，需要借助操作系統平臺提供的API，比如Linux的，或者windows下的。 C++11提供了語言層面上的多線程，包含在頭文件中。它解決了跨平臺的問題，提供了管理線程、保護共享數據、線程間同步操作、原子操作等類。C++11 新標準中引入了5個頭文件來支持多線程編程，如下圖所示：

1.1、多進程與多線程

多進程并發

使用多進程并發是將一個應用程序劃分為多個獨立的進程（每個進程只有一個線程），這些獨立的進程間可以互相通信，共同完成任務。由于操作系統對進程提供了大量的保護機制，以避免一個進程修改了另一個進程的數據，使用多進程比使用多線程更容易寫出相對安全的代碼。但是這也造就了多進程并發的兩個缺點：

在進程間的通信，無論是使用信號、套接字，還是文件、管道等方式，其使用要么比較復雜，要么就是速度較慢或者兩者兼而有之。

運行多個線程的開銷很大，操作系統要分配很多的資源來對這些進程進行管理。

當多個進程并發完成同一個任務時，不可避免的是：操作同一個數據和進程間的相互通信，上述的兩個缺點也就決定了多進程的并發并不是一個好的選擇。所以就引入了多線程的并發。

多線程并發

多線程并發指的是在同一個進程中執行多個線程。 優點： 有操作系統相關知識的應該知道，線程是輕量級的進程，每個線程可以獨立的運行不同的指令序列，但是線程不獨立的擁有資源，依賴于創建它的進程而存在。也就是說，同一進程中的多個線程共享相同的地址空間，可以訪問進程中的大部分數據，指針和引用可以在線程間進行傳遞。這樣，同一進程內的多個線程能夠很方便的進行數據共享以及通信，也就比進程更適用于并發操作。 缺點： 由于缺少操作系統提供的保護機制，在多線程共享數據及通信時，就需要程序員做更多的工作以保證對共享數據段的操作是以預想的操作順序進行的，并且要極力的避免死鎖(deadlock)。

1.2、多線程理解

單CPU內核的多個線程。

一個時間片運行一個線程的代碼，并不是真正意義的并行計算。

多個cpu或者多個內核

可以做到真正的并行計算。

1.3、創建線程

創建線程很簡單，只需要把函數添加到線程當中即可。

形式1：

std::thread myThread ( thread_fun);
//函數形式為void thread_fun()
myThread.join();
//同一個函數可以代碼復用，創建多個線程

形式2：

std::thread myThread ( thread_fun(100));
myThread.join();
//函數形式為void?thread_fun(int?x)
//同一個函數可以代碼復用，創建多個線程

形式3：

std::thread (thread_fun,1).detach();
//直接創建線程，沒有名字
//函數形式為void thread_fun(int x)

For Example

使用g++編譯下列代碼的方式：

g++?test.cc?-o?test?-l?pthread

#include
#include
using namespace std;


void thread_1()
{
cout<<"子線程1"<

	1.4、join與detach方式

	當線程啟動后，一定要在和線程相關聯的thread銷毀前，確定以何種方式等待線程執行結束。比如上例中的join。

	detach方式，啟動的線程自主在后臺運行，當前的代碼繼續往下執行，不等待新線程結束。

	join方式，等待啟動的線程完成，才會繼續往下執行。

	可以使用joinable判斷是join模式還是detach模式。

	if (myThread.joinable()) foo.join();

	（1）join舉例

	下面的代碼，join后面的代碼不會被執行，除非子線程結束。

#include
#include
using namespace std;
void thread_1()
{
  while(1)
  {
  //cout<<"子線程1111"<
  }
}
void thread_2(int x)
{
  while(1)
  {
  //cout<<"子線程2222"<
  }
}
int main()
{
    thread first ( thread_1); // 開啟線程，調用：thread_1()
    thread second (thread_2,100); // 開啟線程，調用：thread_2(100)


    first.join(); // pauses until first finishes 這個操作完了之后才能destroyed
    second.join(); // pauses until second finishes//join完了之后，才能往下執行。
    while(1)
    {
      std::cout << "主線程
";
??  }
    return 0;
}

	（2）detach舉例

	下列代碼中，主線程不會等待子線程結束。如果主線程運行結束，程序則結束。

#include
#include
using namespace std;


void thread_1()
{
  while(1)
  {
??    cout<<"子線程1111"<
  }
}


void thread_2(int x)
{
    while(1)
    {
        cout<<"子線程2222"<
    }
}


int main()
{
    thread first ( thread_1);  // 開啟線程，調用：thread_1()
    thread second (thread_2,100); // 開啟線程，調用：thread_2(100)


    first.detach();                
    second.detach();            
    for(int i = 0; i < 10; i++)
    {
        std::cout << "主線程
";
    }
    return 0;
}

	1.5、this_thread

	this_thread是一個類，它有4個功能函數，具體如下：

				函數
			

				使用
			

				說明
		

				get_id
			

				std::get_id()
			

				獲取線程id
		

				yield
			

				std::yield()
			

				放棄線程執行，回到就緒狀態
		

				sleep_for
			

				std::seconds(1));
			

				暫停1秒
		

				sleep_until
			

				如下
			

				一分鐘后執行嗎，如下
		

using std::system_clock;
std::time_t tt = system_clock::to_time_t(system_clock::now());
struct std::tm * ptm = std::localtime(&tt);
cout << "Waiting for the next minute to begin...
";
++ptm->tm_min; //加一分鐘
ptm->tm_sec = 0; //秒數設置為0//暫停執行，到下一整分執行
this_thread::from_time_t(mktime(ptm)));
2、mutex mutex頭文件主要聲明了與互斥量(mutex)相關的類。mutex提供了4種互斥類型，如下表所示。

				類型
			

				說明
		

				std::mutex
			

				最基本的 Mutex 類。
		

				std::recursive_mutex
			

				遞歸 Mutex 類。
		

				std::time_mutex
			

				定時 Mutex 類。
		

				std::recursive_timed_mutex
			

				定時遞歸 Mutex 類。
		

	std::mutex 是C++11 中最基本的互斥量，std::mutex 對象提供了獨占所有權的特性——即不支持遞歸地對 std::mutex 對象上鎖，而 std::recursive_lock 則可以遞歸地對互斥量對象上鎖。

	2.1、lock與unlock

	mutex常用操作：

	lock()：資源上鎖

	unlock()：解鎖資源

	trylock()：查看是否上鎖，它有下列3種類情況：

	（1）未上鎖返回false，并鎖住； （2）其他線程已經上鎖，返回true； （3）同一個線程已經對它上鎖，將會產生死鎖。

	死鎖：是指兩個或兩個以上的進程在執行過程中，由于競爭資源或者由于彼此通信而造成的一種阻塞的現象，若無外力作用，它們都將無法推進下去。此時稱系統處于死鎖狀態或系統產生了死鎖，這些永遠在互相等待的進程稱為死鎖進程。

	下面結合實例對lock和unlock進行說明。 同一個mutex變量上鎖之后，一個時間段內，只允許一個線程訪問它。例如：

#include// std::cout
#include// std::thread
#include// std::mutex


std::mutex mtx;  // mutex for critical section
void print_block (int n, char c) 
{
// critical section (exclusive access to std::cout signaled by locking mtx):
    mtx.lock();
for (int i=0; i
    {
       std::cout << c; 
????}
    std::cout << '
';
    mtx.unlock();
}
int main ()
{
    std::thread th1 (print_block,50,'');//線程1：打印*
    std::thread th2 (print_block,50,'$');//線程2：打印$


    th1.join();
    th2.join();
return 0;
}
輸出：

**************************************************
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
? 如果是不同mutex變量，因為不涉及到同一資源的競爭，所以以下代碼運行可 能會出現交替打印的情況，或者另一個線程可以修改共同的全局變量！

#include  // std::cout
#include  // std::thread
#include  // std::mutex


std::mutex mtx_1; // mutex for critical section
std::mutex mtx_2;  // mutex for critical section
int test_num = 1;


void print_block_1 (int n, char c)
{
// critical section (exclusive access to std::cout signaled by locking mtx):
    mtx_1.lock();
for (int i=0; i
    {
//std::cout << c;
        test_num = 1;
        std::cout<
2.2、lock_guard 創建lock_guard對象時，它將嘗試獲取提供給它的互斥鎖的所有權。當控制流離開lock_guard對象的作用域時，lock_guard析構并釋放互斥量。 lock_guard的特點：

	創建即加鎖，作用域結束自動析構并解鎖，無需手工解鎖

	不能中途解鎖，必須等作用域結束才解鎖

	不能復制

	代碼舉例

#include
#include
#include
int g_i = 0;
std::mutex g_i_mutex;  // protects g_i，用來保護g_i


void safe_increment()
{
const std::lock_guard lock(g_i_mutex);
    ++g_i;
std::cout << std::get_id() << ": " << g_i << '
';// g_i_mutex自動解鎖}int main(){
std::cout << "main id: " <
?說明：

	該程序的功能為，每經過一個線程，g_i 加1。

	因為涉及到共同資源g_i ，所以需要一個共同mutex：g_i_mutex。

	main線程的id為1，所以下次的線程id依次加1。

	2.3、unique_lock

	簡單地講，unique_lock 是 lock_guard 的升級加強版，它具有 lock_guard 的所有功能，同時又具有其他很多方法，使用起來更加靈活方便，能夠應對更復雜的鎖定需要。 unique_lock的特點：

	創建時可以不鎖定（通過指定第二個參數為std::defer_lock），而在需要時再鎖定

	可以隨時加鎖解鎖

	作用域規則同 lock_grard，析構時自動釋放鎖

	不可復制，可移動

	條件變量需要該類型的鎖作為參數（此時必須使用unique_lock）

	所有 lock_guard 能夠做到的事情，都可以使用 unique_lock 做到，反之則不然。那么何時使lock_guard呢？很簡單，需要使用鎖的時候，首先考慮使用 lock_guard，因為lock_guard是最簡單的鎖。 下面是代碼舉例：

#include
#include
#include
struct Box {
explicit Box(int num) : num_things{num} {}
int num_things;
std::mutex m;
};
void transfer(Box &from, Box &to, int num)
{
// defer_lock表示暫時unlock，默認自動加鎖
std::unique_lock lock1(from.m, std::defer_lock);
std::unique_lock lock2(to.m, std::defer_lock);//兩個同時加鎖
std::lock(lock1, lock2);//或者使用lock1.lock()


    from.num_things -= num;
    to.num_things += num;//作用域結束自動解鎖,也可以使用lock1.unlock()手動解鎖
}
int main()
{
Box acc1(100);
Box acc2(50);


std::thread t1(transfer, std::ref(acc1), std::ref(acc2), 10);
std::thread t2(transfer, std::ref(acc2), std::ref(acc1), 5);


    t1.join();
    t2.join();
std::cout << "acc1 num_things: " << acc1.num_things << std::endl;
std::cout << "acc2 num_things: " << acc2.num_things << std::endl;
}

	說明：

	該函數的作用是，從一個結構體中的變量減去一個num，加載到另一個結構體的變量中去。

	std::mutex m;在結構體中，mutex不是共享的。但是只需要一把鎖也能鎖住，因為引用傳遞后，同一把鎖傳給了兩個函數。

	cout需要在join后面進行，要不然cout的結果不一定是最終算出來的結果。

	std::ref 用于包裝按引用傳遞的值。

	std::cref 用于包裝按const引用傳遞的值。

	3、condition_variable condition_variable頭文件有兩個variable類，一個是condition_variable，另一個是condition_variable_any。condition_variable必須結合unique_lock使用。condition_variable_any可以使用任何的鎖。下面以condition_variable為例進行介紹。 condition_variable條件變量可以阻塞（wait、wait_for、wait_until）調用的線程直到使用（notify_one或notify_all）通知恢復為止。condition_variable是一個類，這個類既有構造函數也有析構函數，使用時需要構造對應的condition_variable對象，調用對象相應的函數來實現上面的功能。

	?

				類型
			

				說明
		

				condition_variable
			

				構建對象
		

				析構
			

				刪除
		

				wait
			

				Wait until notified
		

				wait_for
			

				Wait for timeout or until notified
		

				wait_until
			

				Wait until notified or time point
		

				notify_one
			

				解鎖一個線程，如果有多個，則未知哪個線程執行
		

				notify_all
			

				解鎖所有線程
		

				cv_status
			

				這是一個類，表示variable 的狀態，如下所示
		

	
enum class cv_status { no_timeout, timeout };
3.1、wait 當前線程調用 wait() 后將被阻塞(此時當前線程應該獲得了鎖（mutex），不妨設獲得鎖 lck)，直到另外某個線程調用 notify_* 喚醒了當前線程。 在線程被阻塞時，該函數會自動調用 lck.unlock() 釋放鎖，使得其他被阻塞在鎖競爭上的線程得以繼續執行。另外，一旦當前線程獲得通知(notified，通常是另外某個線程調用 notify_* 喚醒了當前線程)，wait()函數也是自動調用 lck.lock()，使得lck的狀態和 wait 函數被調用時相同。 代碼示例：

#include            // std::cout
#include              // std::thread, std::yield
#include               // std::mutex, std::unique_lock
#include  // std::condition_variable


std::mutex mtx;
std::condition_variable cv;
int cargo = 0;
bool shipment_available()
{
return cargo!=0;
}
void consume (int n)
{
for (int i=0; i
    {
std::unique_lock lck(mtx);//自動上鎖
//第二個參數為false才阻塞（wait），阻塞完即unlock，給其它線程資源
        cv.wait(lck,shipment_available);// consume:
std::cout << cargo << '
';
        cargo=0;
    }
}
int main ()
{
std::thread consumer_thread (consume,10);
for (int i=0; i<10; ++i) 
    {
//每次cargo每次為0才運行。
    ????while?(shipment_available())??std::yield();
std::unique_lock lck(mtx);
        cargo = i+1;
        cv.notify_one();
    }


????consumer_thread.join();
????return?0;
}

	說明：

	主線程中的while，每次在cargo=0才運行。

	每次cargo被置為0，會通知子線程unblock(非阻塞)，也就是子線程可以繼續往下執行。

	子線程中cargo被置為0后，wait又一次啟動等待。也就是說shipment_available為false，則等待。

	3.2、wait_for

	與std::wait() 類似，不過 wait_for可以指定一個時間段，在當前線程收到通知或者指定的時間 rel_time 超時之前，該線程都會處于阻塞狀態。而一旦超時或者收到了其他線程的通知，wait_for返回，剩下的處理步驟和 wait()類似。

	template 
cv_status wait_for (unique_lock& lck,
??????????????????????const?chrono::duration&?rel_time);

	另外，wait_for 的重載版本的最后一個參數pred表示 wait_for的預測條件，只有當 pred條件為false時調用 wait()才會阻塞當前線程，并且在收到其他線程的通知后只有當 pred為 true時才會被解除阻塞。

template 
bool wait_for (unique_lock& lck,
?????????const?chrono::duration&?rel_time,?Predicate?pred);
代碼示例：

#include// std::cout
#include// std::thread
#include// std::seconds
#include// std::mutex, std::unique_lock
#include// std::condition_variable, std::cv_status


std::condition_variable cv;
int value;
void read_value()
{
std::cin >> value;
    cv.notify_one();
}
int main ()
{
std::cout << "Please, enter an integer (I'll be printing dots): 
";
std::thread th (read_value);


std::mutex mtx;
std::unique_lock lck(mtx);
while (cv.wait_for(lck,std::seconds(1))==std::timeout) 
    {
std::cout << '.' << std::endl;
    }
std::cout << "You entered: " << value << '
';


    th.join();
return 0;
}

	通知或者超時都會解鎖，所以主線程會一直打印。

	示例中只要過去一秒，就會不斷的打印。

	4、線程池

	4.1、概念

	在一個程序中，如果我們需要多次使用線程，這就意味著，需要多次的創建并銷毀線程。而創建并銷毀線程的過程勢必會消耗內存，線程過多會帶來調動的開銷，進而影響緩存局部性和整體性能。 線程的創建并銷毀有以下一些缺點：

	創建太多線程，將會浪費一定的資源，有些線程未被充分使用。

	銷毀太多線程，將導致之后浪費時間再次創建它們。

	創建線程太慢，將會導致長時間的等待，性能變差。

	銷毀線程太慢，導致其它線程資源饑餓。

	線程池維護著多個線程，這避免了在處理短時間任務時，創建與銷毀線程的代價。

	4.2、線程池的實現

	因為程序邊運行邊創建線程是比較耗時的，所以我們通過池化的思想：在程序開始運行前創建多個線程，這樣，程序在運行時，只需要從線程池中拿來用就可以了．大大提高了程序運行效率． 一般線程池都會有以下幾個部分構成：

	線程池管理器（ThreadPoolManager）:用于創建并管理線程池，也就是線程池類

	工作線程（WorkThread）: 線程池中線程

	任務隊列task: 用于存放沒有處理的任務。提供一種緩沖機制。

	append：用于添加任務的接口

	線程池實現代碼：

#ifndef _THREADPOOL_H
#define _THREADPOOL_H
#include
#include
#include
#include
#include
#include
#include//unique_ptr
#include
const int MAX_THREADS = 1000; //最大線程數目
template 
class threadPool
{
public:
    threadPool(int number = 1);//默認開一個線程
    ~threadPool();
std::queuetasks_queue; //任務隊列
bool append(T *request);//往請求隊列＜task_queue＞中添加任務
private:
//工作線程需要運行的函數,不斷的從任務隊列中取出并執行
static void *worker(void arg);
void run();
private:
std::vector work_threads; //工作線程


std::mutex queue_mutex;
std::condition_variable condition;  //必須與unique_lock配合使用
bool stop;
};//end class//構造函數，創建線程
template 
threadPool::threadPool(int number) : stop(false)
{
if?(number?<=?0?||?number?>?MAX_THREADS)
throw?std::exception();
for?(int?i?=?0;?i?
inline threadPool::~threadPool()
{
????std::unique_lock?lock(queue_mutex);
????stop?=?true;
????
    condition.notify_all();
for (auto &ww : work_threads)
        ww.join();//可以在析構函數中join
}
//添加任務
template 
bool threadPool::append(T *request)
{
????//操作工作隊列時一定要加鎖，因為他被所有線程共享
    queue_mutex.lock();//同一個類的鎖
    tasks_queue.push(request);
    queue_mutex.unlock();
????condition.notify_one();??//線程池添加進去了任務，自然要通知等待的線程
return true;
}//單個線程
template 
void threadPool::worker(void *arg)
{
    threadPool pool = (threadPool *)arg;
    pool->run();//線程運行
return pool;
}
template 
void threadPool::run()
{
while (!stop)
{
std::unique_lock lk(this->queue_mutex);
/*　unique_lock() 出作用域會自動解鎖　/
    this->condition.wait(lk, [this] 
    { 
      return !this->tasks_queue.empty(); 
    });//如果任務為空，則wait，就停下來等待喚醒//需要有任務，才啟動該線程，不然就休眠
    if (this->tasks_queue.empty())//任務為空，雙重保障
    {  
        assert(0&&"斷了");//實際上不會運行到這一步，因為任務為空，wait就休眠了。
        continue;
    }else{
        T *request = tasks_queue.front();
        tasks_queue.pop();
        if (request)//來任務了，開始執行
            request->process();
          }
    }
}
#endif
說明：

	構造函數創建所需要的線程數

	一個線程對應一個任務，任務隨時可能完成，線程則可能休眠，所以任務用隊列queue實現（線程數量有限），線程用采用wait機制。

	任務在不斷的添加，有可能大于線程數，處于隊首的任務先執行。

	只有添加任務(append)后，才開啟線程condition.notify_one()。

	wait表示，任務為空時，則線程休眠，等待新任務的加入。

	添加任務時需要添加鎖，因為共享資源。

	測試代碼：

#include "mythread.h"
#include
#include
using namespace std;
class Task
{
public:
void process()
{
//cout << "run........." << endl;//測試任務數量
long i=1000000;
while(i!=0)
        {
int j = sqrt(i);
????????????i--;
        }
    }
};
int?main(void){
    threadPoolpool(6);//6個線程，vector
std::string str;
while (1)
    {
        Task *tt = new Task();//使用智能指針
        pool.append(tt);//不停的添加任務，任務是隊列queue，因為只有固定的線程數
  ??????cout<<"添加的任務數量："<

	編輯：黃飛

	?