std::thread類代表了一個(gè)可執(zhí)行的線程,，它來自頭文件<thread>,。與其它創(chuàng)建線程的API（比如 Windows API中的CreateThread）不同的是， 它可以使用普通函數(shù),、lambda函數(shù)以及仿函數(shù)（實(shí)現(xiàn)了operator（）函數(shù)的類）,。另外，它還允許向線程函數(shù)傳遞任意數(shù)量的參數(shù),。

#include <thread> void func()
{ // do some work } int main()
{
   std::thread t(func);
   t.join(); return 0;
}

在上面的例子中,，t是一個(gè)線程對(duì)象，函數(shù)func()運(yùn)行于該線程之中,。調(diào)用join函數(shù)后,，該調(diào)用線程（本例中指的就是主線程）就會(huì)在join進(jìn)來進(jìn)行執(zhí)行的線程t結(jié)束執(zhí)行之前，一直處于阻塞狀態(tài),。如果該線程函數(shù)執(zhí)行結(jié)束后返回了一個(gè)值,，該值也將被忽略,。不過，該函數(shù)可以接受任意數(shù)量的參數(shù),。

void func(int i, double d, const std::string& s)
{
    std::cout << i << ", " << d << ", " << s << std::endl;
} int main()
{
   std::thread t(func, 1, 12.50, "sample");
   t.join(); return 0;
}

void func(int& a)
{
   a++;
} int main()
{ int a = 42;
   std::thread t(func, std::ref(a));
   t.join();
 
   std::cout << a << std::endl; return 0;
}

上面程序打印結(jié)果為43，但要不是將a封裝到std::ref之中的話,，輸出的將是42,。

除join方法之外，這個(gè)線程類還提供了另外幾個(gè)方法：

• swap: 將兩個(gè)線程對(duì)象的底層句柄進(jìn)行交換
• detatch: 允許執(zhí)行該方法的線程獨(dú)立于本線程對(duì)象的執(zhí)行而繼續(xù)執(zhí)行,。脫離后的線程就再也不能執(zhí)行join了（你不能等待到它執(zhí)行結(jié)束了）

  int main() {
      std::thread t(funct);
      t.detach(); return 0;
  }

try {
    std::thread t1(func);
    std::thread t2(func);
 
    t1.join();
    t2.join();
} catch(const std::exception& ex)
{
    std::cout << ex.what() << std::endl;
}

要在線程間傳遞異常,，你可以先在線程函數(shù)中捕獲它們,，然后再將它們保存到一個(gè)合適的地方，隨后再讓另外一個(gè)線程從這個(gè)地方取得這些異常,。

std::vector<std::exception_ptr>  g_exceptions; void throw_function()
{ throw std::exception("something wrong happened");
} void func()
{ try {
      throw_function();
   } catch(...)
   {
      std::lock_guard<std::mutex> lock(g_mutex);
      g_exceptions.push_back(std::current_exception());
   }
} int main()
{
   g_exceptions.clear();

   std::thread t(func);
   t.join(); for(auto& e : g_exceptions)
   { try { if(e != nullptr)
         {
            std::rethrow_exception(e);
         }
      } catch(const std::exception& e)
      {
         std::cout << e.what() << std::endl;
      }
   } return 0;
}

要獲得更多關(guān)于捕獲并傳遞異常的知識(shí),，你可以閱讀在主線程中處理工作線程拋出的C++異常以及怎樣才能在線程間傳遞異常？,。

在深入討論之前還有一點(diǎn)值得注意,，頭文件<thread>里還在命名空間std::this_thread中提供了一些輔助函數(shù)：

• get_id: 返回膽怯線程的id
• yield: 讓調(diào)度器先運(yùn)行其它的線程，這在忙于等待狀態(tài)時(shí)很有用
• sleep_for: 將當(dāng)前線程置于阻塞狀態(tài),，時(shí)間不少于參數(shù)所指定的時(shí)間段
• sleep_util: 在指定的時(shí)刻來臨前,，一直將當(dāng)前的線程置于阻塞狀態(tài)

鎖

在上一個(gè)例子中,，我需要對(duì)g_exceptions這個(gè)vector進(jìn)行同步訪問,，以確保同一個(gè)時(shí)刻只能有一個(gè)線程向其中壓入新元素。為了實(shí)現(xiàn)同步,，我使用了一個(gè)互斥量,，并在該互斥量上進(jìn)行了鎖定?；コ饬渴且粋€(gè)核心的同步原語,，C++11的<mutex>頭文件中包含了四種不同的互斥量,。

• mutex: 提供了核心的lock()函數(shù)和unlock()函數(shù)，以及非阻塞式的try_lock()方法,，該方法在互斥量不可用時(shí)會(huì)立即返回,。
• recursive_mutex: 運(yùn)行在同一線程中，多次獲得同一個(gè)互斥量,。
• timed_mutex: 同第一條中的mutex類似，但它還帶來了另外兩個(gè)方法try_lock_for()和try_lock_until(),，分別用于在某個(gè)時(shí)間段內(nèi)或在某個(gè)時(shí)刻到來之前獲得該互斥量,。
• recursive_timed_mutex: 結(jié)合了第二條的timed_mutex和第三條的recusive_mutex。

以下所列就是一個(gè)使用std::mutex（注意其中g(shù)et_id()和sleep_for()這兩個(gè)前文所述的輔助函數(shù)的用法）的例子,。

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
 
std::mutex g_lock; void func()
{
    g_lock.lock();
 
    std::cout << "entered thread " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(rand() % 10));
    std::cout << "leaving thread " << std::this_thread::get_id() << std::endl;
 
    g_lock.unlock();
} int main()
{
    srand((unsigned int)time(0));
 
    std::thread t1(func);
    std::thread t2(func);
    std::thread t3(func);
 
    t1.join();
    t2.join();
    t3.join(); return 0;
}

其輸出將類似如下所示：

entered thread 10144 leaving thread 10144 entered thread 4188 leaving thread 4188 entered thread 3424 leaving thread 3424 

lock()和unlock()這兩個(gè)方法顧名思義,，頭一個(gè)方法用來對(duì)互斥量進(jìn)行加鎖，如果互斥量不可得便會(huì)處于阻塞狀態(tài),；第二個(gè)方法用來對(duì)互斥量進(jìn)行解鎖,。

接下來的這個(gè)例子演示的是一個(gè)簡(jiǎn)單的線程安全的容器（內(nèi)部使用的是std::vector）,。這個(gè)容器具有添加單個(gè)元素的add()方法以及添加一批元素的addrange()方法,，addrange()方法內(nèi)只是簡(jiǎn)單的調(diào)用了add()方法。 

template <typename T> class container 
{
    std::mutex _lock;
    std::vector<T> _elements; public: void add(T element) 
    {
        _lock.lock();
        _elements.push_back(element);
        _lock.unlock();
    } void addrange(int num, ...)
    {
        va_list arguments;
 
        va_start(arguments, num); for (int i = 0; i < num; i++)
        {
            _lock.lock();
            add(va_arg(arguments, T));
            _lock.unlock();
        }
 
        va_end(arguments); 
    } void dump()
    {
        _lock.lock(); for(auto e : _elements)
            std::cout << e << std::endl;
        _lock.unlock();
    }
}; void func(container<int>& cont)
{
    cont.addrange(3, rand(), rand(), rand());
} int main()
{
    srand((unsigned int)time(0));
 
    container<int> cont;
 
    std::thread t1(func, std::ref(cont));
    std::thread t2(func, std::ref(cont));
    std::thread t3(func, std::ref(cont));
 
    t1.join();
    t2.join();
    t3.join();
 
    cont.dump(); return 0;
}

這個(gè)程序執(zhí)行起來會(huì)進(jìn)入死鎖狀態(tài),。其原因在于,，該容器多次嘗試獲取同一個(gè)互斥量而之前卻并沒有釋放該互斥量，這么做是行不通的,。這正是std::recursive_mutex的用武之地,，它允許同一個(gè)線程多次獲得同一個(gè)互斥量，可重復(fù)獲得的最大次數(shù)并未具體說明,，但一旦查過一定次數(shù),，再對(duì)lock進(jìn)行調(diào)用就會(huì)拋出std::system錯(cuò)誤。為了修復(fù)上面所列代碼的死鎖問題（不通過修改addrange方法的實(shí)現(xiàn),，讓它不對(duì)lock和unlock方法進(jìn)行調(diào)用),，我們可以將互斥量改為std::recursive_mutex。

template <typename T> class container 
{
    std::recursive_mutex _lock; // ... 
};

經(jīng)過修改之后,，該程序的輸出會(huì)同如下所示類似：

6334 18467 41 6334 18467 41 6334 18467 41 

明眼的讀者可能已經(jīng)發(fā)現(xiàn)了,，每次調(diào)用func()所產(chǎn)生的數(shù)字序列都完全相同。這是因?yàn)閷?duì)srad的初始化是要分線程進(jìn)行的,，對(duì)srand()的調(diào)用只是在主線程中進(jìn)行了初始化,。在其它的工作線程中，srand并沒有得到初始化,，所以每次產(chǎn)生的數(shù)字序列就是完全相同的了,。

顯式的加鎖和解鎖可能會(huì)導(dǎo)致一定的問題，比如忘了解鎖或者加鎖的順序不對(duì)都有可能導(dǎo)致死鎖,。本標(biāo)準(zhǔn)提供了幾個(gè)類和函數(shù)用于幫助解決這類問題,。使用這些封裝類就能夠以相互一致的、RAII風(fēng)格的方式使用互斥量了,，它們可以在相應(yīng)的代碼塊的范圍內(nèi)進(jìn)行自動(dòng)的加鎖和解鎖動(dòng)作,。這些封裝類包括：

• lock_guard: 該類的對(duì)象在構(gòu)造之時(shí)會(huì)試圖獲得互斥量的擁有權(quán)（通過調(diào)用lock()實(shí)現(xiàn)），而在析構(gòu)之時(shí)會(huì)自動(dòng)釋放它所獲得的互斥量（通過調(diào)用unlock()實(shí)現(xiàn)）,。這是一個(gè)不可復(fù)制的類,。
• unique_lock: 是一個(gè)通用的互斥量封裝類。與lock_quard不同,，它還支持延遲加鎖,、時(shí)間鎖、遞歸鎖,、鎖所有權(quán)的轉(zhuǎn)移并且還支持使用條件變量,。這也是一個(gè)不可復(fù)制的類，但它是可以移動(dòng)的類,。

使用這些封裝類,，我們可以象這樣來改寫我們的容器：

template <typename T> class container 
{
    std::recursive_mutex _lock;
    std::vector<T> _elements; public: void add(T element) 
    {
        std::lock_guard<std::recursive_mutex> locker(_lock);
        _elements.push_back(element);
    } void addrange(int num, ...)
    {
        va_list arguments;
 
        va_start(arguments, num); for (int i = 0; i < num; i++)
        {
            std::lock_guard<std::recursive_mutex> locker(_lock);
            add(va_arg(arguments, T));
        }
 
        va_end(arguments); 
    } void dump()
    {
        std::lock_guard<std::recursive_mutex> locker(_lock); for(auto e : _elements)
            std::cout << e << std::endl;
    }
};

有人會(huì)說，既然dump()方法并不會(huì)對(duì)容器的狀態(tài)做出任何修改,，所以它應(yīng)該定義為congst的方法,。但要是你真的這么改了之后，編譯器就會(huì)報(bào)告出如下的錯(cuò)誤：

‘std::lock_guard<_Mutex>::lock_guard(_Mutex &)' : cannot convert parameter 1 from ‘const std::recursive_mutex' to ‘std::recursive_mutex &'

template <typename T> class container 
{
   mutable std::recursive_mutex _lock;
   std::vector<T> _elements; public: void dump() const {
      std::lock_guard<std::recursive_mutex> locker(_lock); for(auto e : _elements)
         std::cout << e << std::endl;
   }
};

這些封裝類都具有可以接受一個(gè)用來指導(dǎo)加鎖策略的參數(shù)的構(gòu)造器，可用的加鎖策略有：

• defer_lockof typedefer_lock_t: 不要取得互斥量的擁有權(quán)
• try_to_lockof typetry_to_lock_t: 在不會(huì)被阻塞的情況下嘗試獲得互斥量的擁有權(quán)
• adopt_lockof typeadopt_lock_t: 假設(shè)調(diào)用線程已經(jīng)獲得了互斥量的擁有權(quán)

這些策略的定義如下所示：

struct defer_lock_t { }; 
struct try_to_lock_t { }; 
struct adopt_lock_t { }; 
constexpr std::defer_lock_t defer_lock = std::defer_lock_t(); 
constexpr std::try_to_lock_t try_to_lock = std::try_to_lock_t(); 
constexpr std::adopt_lock_t adopt_lock = std::adopt_lock_t();

• lock: 使用一種可避免死鎖的算法對(duì)互斥量進(jìn)行加鎖（通過調(diào)用tolock(),、try_lock()以及unlock()）,。
• try_lock: 通過調(diào)用try_lock()i按照參數(shù)里指定的互斥量的順序?qū)Χ鄠€(gè)互斥量進(jìn)行加鎖。

這里舉一個(gè)造成死鎖的例子：我們有一個(gè)保存元素的容器,，還有一個(gè)叫做exchange()的方法,，用來將一個(gè)元素從一個(gè)容器中取出來放入另外一個(gè)容器。為了成為線程安全的函數(shù),，這個(gè)函數(shù)通過獲得每個(gè)容器的互斥量,，對(duì)兩個(gè)容器的訪問進(jìn)行了同步處理。

template <typename T> class container 
{ public:
    std::mutex _lock;
    std::set<T> _elements; void add(T element) 
    {
        _elements.insert(element);
    } void remove(T element) 
    {
        _elements.erase(element);
    }
}; void exchange(container<int>& cont1, container<int>& cont2, int value)
{
    cont1._lock.lock();
    std::this_thread::sleep_for(std::chrono::seconds(1)); // <-- forces context switch to simulate the deadlock  cont2._lock.lock();    
 
    cont1.remove(value);
    cont2.add(value);
 
    cont1._lock.unlock();
    cont2._lock.unlock();
}

假設(shè)這個(gè)函數(shù)是從兩個(gè)不同的線程中進(jìn)行調(diào)用的,，在第一個(gè)線程中有一個(gè)元素從第一個(gè)容器中取出來，放到了第二個(gè)容器中,，在第二個(gè)線程中該元素又從第二個(gè)容器中取出來放回到了第一個(gè)容器中,。這樣會(huì)導(dǎo)致死鎖（如果線程上下文正好在獲得第一個(gè)鎖的時(shí)候從一個(gè)線程切換到了另一個(gè)線程的時(shí)候就會(huì)發(fā)生死鎖）。

int main()
{
    srand((unsigned int)time(NULL));
 
    container<int> cont1; 
    cont1.add(1);
    cont1.add(2);
    cont1.add(3);
 
    container<int> cont2; 
    cont2.add(4);
    cont2.add(5);
    cont2.add(6);
 
    std::thread t1(exchange, std::ref(cont1), std::ref(cont2), 3);
    std::thread t2(exchange, std::ref(cont2), std::ref(cont1), 6);
 
    t1.join();
    t2.join(); return 0;
}

要解決該問題,，你可以使用以能夠避免死鎖的方式獲得鎖的std::lock：

void exchange(container<int>& cont1, container<int>& cont2, int value)
{
    std::lock(cont1._lock, cont2._lock); 
 
    cont1.remove(value);
    cont2.add(value);
 
    cont1._lock.unlock();
    cont2._lock.unlock();
}

條件變量

C++11還提供了對(duì)另外一個(gè)同步原語的支持，這個(gè)原語就是條件變量,。使用條件變量可以將一個(gè)或多個(gè)線程進(jìn)入阻塞狀態(tài),，直到收到另外一個(gè)線程的通知，或者超時(shí)或者發(fā)生了虛假喚醒,，才能退出阻塞狀態(tài),。頭文件<condition_variable>中包含的條件變量有兩種實(shí)現(xiàn)：

• condition_variable: 要求任何想等待該條件變量的線程必需先獲得std::unique_lock鎖。
• condition_variable_any: 該實(shí)現(xiàn)更加通用,，它可以用于任何滿足基本條件的鎖（只要實(shí)現(xiàn)了lock()和unlock()方法即可）,。因?yàn)樗褂闷饋泶鷥r(jià)要更高一些（從性能和操作系統(tǒng)的字樣的角度講），所以,，應(yīng)該在只有它所提供的額外的靈活性是必不可少的情況下才會(huì)選用它,。

• 必須至少要有一個(gè)等待條件變?yōu)閠rue的線程,。等待中的線程必須首先獲得一個(gè)unique_lock鎖,。 該鎖將會(huì)傳遞給wait()方法，然后wait()方法會(huì)釋放互斥量并將該線程暫停,，直到條件變量得到相應(yīng)的信號(hào),。當(dāng)接受到信號(hào)，線程被喚醒后，該鎖就又被重新獲得了,。
• 必須至少要有一個(gè)線程發(fā)送信號(hào)使得條件變?yōu)閠rue,。信號(hào)可以通過調(diào)用notify_one()來發(fā)送，發(fā)用這個(gè)方法發(fā)送后就會(huì)將處于阻塞狀態(tài)的等待該條件獲得信號(hào)的線程中的某一個(gè)線程（任意一個(gè)線程）恢復(fù)執(zhí)行,；還可以通過調(diào)用notify_all()將等待該條件的所以線程喚醒,。
• 因?yàn)樵诙嗵幚砥鞯沫h(huán)境下，要讓條件喚醒成為完全可預(yù)測(cè)會(huì)有一些復(fù)雜情況難以克服,，所以就會(huì)出現(xiàn)一些虛假喚醒,。也就是說，線程甚至在沒有人向條件變量發(fā)送信號(hào)的情況下就有可能會(huì)被喚醒,。因此,，在線程喚醒后，仍然需要檢測(cè)條件是不是還為true,。而且因?yàn)樘摷賳拘芽赡軙?huì)多次發(fā)生,，所以該檢測(cè)必須用一個(gè)循環(huán)來進(jìn)行。