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

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

1.1、多進程與多線程

多進程并發(fā)

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

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

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

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

多線程并發(fā)

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

1.2、多線程理解

單CPU內核的多個線程。

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

多個cpu或者多個內核

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

1.3、創(chuàng)建線程

創(chuàng)建線程很簡單，只需要把函數(shù)添加到線程當中即可。

形式1：

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

形式2：

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

形式3：

std::thread (thread_fun,1).detach();
//直接創(chuàng)建線程，沒有名字
//函數(shù)形式為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方式

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

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

	join方式，等待啟動的線程完成，才會繼續(xù)往下執(zhí)行。

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

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

	（1）join舉例

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

#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完了之后，才能往下執(zhí)行。
    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個功能函數(shù)，具體如下：

				函數(shù)
			

				使用
			

				說明
		

				get_id
			

				std::get_id()
			

				獲取線程id
		

				yield
			

				std::yield()
			

				放棄線程執(zhí)行，回到就緒狀態(tài)
		

				sleep_for
			

				std::seconds(1));
			

				暫停1秒
		

				sleep_until
			

				如下
			

				一分鐘后執(zhí)行嗎，如下
		

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; //秒數(shù)設置為0//暫停執(zhí)行，到下一整分執(zhí)行
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）同一個線程已經對它上鎖，將會產生死鎖。

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

	下面結合實例對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變量，因為不涉及到同一資源的競爭，所以以下代碼運行可 能會出現(xiàn)交替打印的情況，或者另一個線程可以修改共同的全局變量！

#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 創(chuàng)建lock_guard對象時，它將嘗試獲取提供給它的互斥鎖的所有權。當控制流離開lock_guard對象的作用域時，lock_guard析構并釋放互斥量。 lock_guard的特點：

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

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

	不能復制

	代碼舉例

#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的特點：

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

	可以隨時加鎖解鎖

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

	不可復制，可移動

	條件變量需要該類型的鎖作為參數(shù)（此時必須使用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;
}

	說明：

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

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

	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是一個類，這個類既有構造函數(shù)也有析構函數(shù)，使用時需要構造對應的condition_variable對象，調用對象相應的函數(shù)來實現(xiàn)上面的功能。

	?

				類型
			

				說明
		

				condition_variable
			

				構建對象
		

				析構
			

				刪除
		

				wait
			

				Wait until notified
		

				wait_for
			

				Wait for timeout or until notified
		

				wait_until
			

				Wait until notified or time point
		

				notify_one
			

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

				notify_all
			

				解鎖所有線程
		

				cv_status
			

				這是一個類，表示variable 的狀態(tài)，如下所示
		

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

#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);//自動上鎖
//第二個參數(shù)為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(非阻塞)，也就是子線程可以繼續(xù)往下執(zhí)行。

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

	3.2、wait_for

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

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

	另外，wait_for 的重載版本的最后一個參數(shù)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、概念

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

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

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

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

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

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

	4.2、線程池的實現(xiàn)

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

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

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

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

	append：用于添加任務的接口

	線程池實現(xiàn)代碼：

#ifndef _THREADPOOL_H
#define _THREADPOOL_H
#include
#include
#include
#include
#include
#include
#include//unique_ptr
#include
const int MAX_THREADS = 1000; //最大線程數(shù)目
template 
class threadPool
{
public:
    threadPool(int number = 1);//默認開一個線程
    ~threadPool();
std::queuetasks_queue; //任務隊列
bool append(T *request);//往請求隊列＜task_queue＞中添加任務
private:
//工作線程需要運行的函數(shù),不斷的從任務隊列中取出并執(zhí)行
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//構造函數(shù)，創(chuàng)建線程
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();//可以在析構函數(shù)中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)//來任務了，開始執(zhí)行
            request->process();
          }
    }
}
#endif
說明：

	構造函數(shù)創(chuàng)建所需要的線程數(shù)

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

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

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

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

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

	測試代碼：

#include "mythread.h"
#include
#include
using namespace std;
class Task
{
public:
void process()
{
//cout << "run........." << endl;//測試任務數(shù)量
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，因為只有固定的線程數(shù)
  ??????cout<<"添加的任務數(shù)量："<

	編輯：黃飛

	?