C++11 併發程式設計教程&學習筆記

​ 為了能夠編譯本文的示例程式碼，你需要有一個支援 C++11 的編譯器，筆者使用的是 TDM-GCC4.9.2

C++11 併發程式設計教程 - Part 1 : thread 初探

啟動執行緒

​ 建立一個 std::thread 的例項時，便會自行啟動。

​ 建立執行緒例項時，必須提供該執行緒將要執行的函式，方法之一是傳遞一個函式指標。

#include <thread>
#include <iostream>
using std::cout;
using std
 
::endl;
using std::thread;
void hello(){
    cout << "Hello from thread" << endl;
}

int main(){
    thread t1(hello);
    t1.join(); // 直到t1結束後，main才返回，若不加該句，則可能t1未完成main就返回了
    return 0;
}

​ 所有的執行緒工具均置於標頭檔案 thread 中。

​ 這個例子中值得注意的是對函式 join() 的呼叫。該呼叫將導致當前執行緒等待被 join 的執行緒結束（在本例中即執行緒 main 必須等待執行緒 t1 結束後方可繼續執行）。如果你忽略掉對 join() 的呼叫，其結果是未定義的 —— 程式可能打印出 “Hello from thread” 以及一個換行，或者只打印出 “Hello from thread” 卻沒有換行，甚至什麼都不做，那是因為執行緒main 可能線上程 t1 結束之前就返回了。

區分執行緒

 每個執行緒都有唯一的 ID 以便我們加以區分。使用 std::thread 類的 get_id() 便可獲取標識對應執行緒的唯一 ID。

​ 使用 std::this_thread 來獲取當前執行緒的引用。下面的例子將建立一些執行緒並使它們列印自己的 ID：

#include <thread>
#include <iostream>
#include <vector>
using namespace std;

void hello(){
    // std::this_thread 當前執行緒的引用
    // get_id()獲取標識程序執行緒的唯一ID
 

    cout << "Hello from thread" << this_thread::get_id() << endl;
}

int main(){
    vector<thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(thread(hello));
    }

    for(auto& th : threads){
        th.join();
    }
    return 0;
}

執行緒之間存在 interleaving ，某個執行緒可能隨時被搶佔。

又因為輸出到 ostream 分幾個步驟（首先輸出一個 string，然後是 ID，最後輸出換行），

因此一個執行緒可能執行了第一個步驟後就被其他執行緒搶佔了，直到其他所有執行緒列印完之後才能進行後面的步驟。

使用Lambda表示式啟動執行緒

​ 當執行緒所要執行的程式碼非常短小時，沒有必要專門為之建立一個函式，可使用 Lambda表示式。

#include <thread>
#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<thread> threads;
    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread(
            [](){
            cout << "Hello from thread " << this_thread::get_id() << endl;
        }));
    }
    for(auto& th : threads){
        th.join();
    }
    return 0;
}

C++11 併發程式設計教程 - Part 2 : 保護共享資料

上面的程式碼中，執行緒互相獨立，通常情況下，執行緒之間可能用到共享資料。一旦對共享資料進行操作，就面臨著一個新的問題 —— 同步。

同步問題

我們就拿一個簡單的計數器作為示例吧。

這個計數器是一個結構體，他擁有一個計數變數，以及增加或減少計數的函式，看起來像這個樣子：

#include <thread>
#include <iostream>
#include <vector>
using namespace std;

struct Counter {
    int m_nValue;

    Counter(int n = 0) : m_nValue(n){}

    void increment(){ ++m_nValue; }
};

int main(){
    Counter counter;
    vector<thread> threads;
    for(int i = 0; i < 5; ++i){
        threads.push_back(thread([&counter](){
            for(int i = 0; i < 999999; ++i){
                counter.increment();
            }
        }));
    }

    for(auto& th : threads){
        th.join();
    }

    cout << counter.m_nValue << endl;
    return 0;
}

每次執行結果會不同，因為計數器的increment()操作並非原子操作，而是由3個獨立的操作組成的：

1、讀取m_nValue變數的當前值。

2、將讀取的當前值+1

3、將+1後的值寫回value變數。

當單執行緒執行上述程式碼，每次執行的結果是一樣的，上述三個步驟會按順序進行。但是在多程序情況下，可能存在如下執行順序：

1. 執行緒a：讀取 m_nValue的當前值，得到值為 0。加1。得到1，但還沒來得及寫回記憶體

2. 執行緒b：讀取 m_nValue的當前值，得到值為 0。加1。得到1，但還沒來得及寫回記憶體。

3. 執行緒a：將 1 寫回 m_nValue 記憶體並返回 1。

4. 執行緒b：將 1 寫回 m_nValue記憶體並返回 1。

這種情況源於執行緒間的 interleaving（交叉執行）。

Interleaving 描述了多執行緒同時執行幾句程式碼的各種情況。就算僅僅只有兩個執行緒同時執行這三個操作，也會存在很多可能的 interleaving。當你有許多執行緒同時執行多個操作時，要想枚舉出所有 interleaving，幾乎是不可能的。而且如果執行緒在執行單個操作的不同指令之間被搶佔，也會導致 interleaving 的發生。

目前有許多可以解決這一問題的方案：

• Semaphores
• Atomic references
• Monitors
• Condition codes
• Compare and swap
• ……

本文將使用 Semaphores 去解決這一問題。

事實上，我們僅僅使用了Semaphores 中比較特殊的一種 —— 互斥量。

互斥量是一個特殊的物件，在同一時刻只有一個執行緒能夠得到該物件上的鎖。藉助互斥量這種簡而有力的性質，我們便可以解決執行緒同步問題。

使用互斥量保證 Counter 的執行緒安全

在 C++11 的執行緒庫中，互斥量被放置於標頭檔案 mutex，並以 std::mutex 類加以實現。互斥量有兩個重要的函式：lock() 和 unlock()。顧名思義，前者使當前執行緒嘗試獲取互斥量的鎖，後者則釋放已經獲取的鎖。lock() 函式是阻塞式的，執行緒一旦呼叫 lock()，就會一直阻塞直到該執行緒獲得對應的鎖。

為了使計數器具備執行緒安全性，我們需要對其新增 std::mutex 成員，並在成員函式中對互斥量進行 lock()和unlock() 呼叫。

struct Counter {
    int m_nValue;
    mutex mtx;

    Counter() : m_nValue(0){}

    void increment(){
        mtx.lock();
        ++m_nValue;
        mtx.unlock();
    }
};

如果我們現在再次執行之前的測試程式，我們將始終得到正確的輸出。（加鎖之後，會大大降低程式執行效率，所以可以將上面的內迴圈降低至10000）

異常與鎖

現在讓我們來看看另外一種情況會發生什麼。

假設現在我們的計數器擁有一個 derement() 操作，當 value 被減為 0 時丟擲一個異常：

struct Counter {
    int m_nValue;


    Counter() : m_nValue(0){}

    void increment(){
        ++m_nValue;
    }

    void decrement(){
        if(m_nValue == 0){
            throw "Value cannot be less than 0";
        }
        --m_nValue;
    }
};

假設你想在不更改上述程式碼的前提下為其提供執行緒安全性，那麼你需要為其建立一個 Wrapper 類：

struct ConcurrentCounter{
    mutex mtx;
    Counter counter;
    void increment(){
        mtx.lock();
        counter.increment();
        mtx.unlock();
    }
    void decrement(){
        mtx.lock();
        counter.decrement();
        mtx.unlock();
    }
};

這個 Wrapper 將在大多數情況下正常工作，然而一旦 decrement() 丟擲異常，你就遇到大麻煩了，當異常被丟擲時，unlock() 函式將不會被呼叫，這將導致本執行緒獲得的鎖不被釋放，你的程式也就順理成章的被永久阻塞了。為了修復這一問題，你需要使用 try/catch 塊以保證在丟擲任何異常之前釋放獲得的鎖。

void decrement(){
     mtx.lock();
     try{
         counter.decrement();
     } catch(string e) {
         mtx.unlock();
         throw e;
     }
     mtx.unlock();
}

程式碼並不複雜，但是看起來卻很醜陋。試想一下，你現在的函式擁有 10 個返回點，那麼你就需要在每個返回點前呼叫 unlock() 函式，而忘掉其中的某一個的可能性是非常大的。更大的風險在於你又添加了新的函式返回點，卻沒有對應地新增 unlock()。下一節將給出解決此問題的好辦法。

鎖的自動管理

​ 當你想保護整個程式碼段（就本文而言是一個函式，但也可以是某個迴圈體或其他控制結構[即一個作用域]）免受多執行緒的侵害時，有一個辦法將有助於防止忘記釋放鎖：std::lock_guard。

這個類是一個簡單、智慧的鎖管理器。當 std::lock_guard 例項被建立時，它自動地呼叫互斥量的lock() 函式，當該例項被銷燬時，它也順帶釋放掉獲得的鎖。你可以像這樣使用它：

struct ConcurrentSafeCounter{
    mutex mtx;
    Counter counter;
    void increment(){
        lock_guard<mutex> guard(mtx);
        counter.increment();
    }
    void decrement(){
        lock_guard<mutex> guard(mtx);
        counter.decrement();
    }
};

程式碼變得更整潔了不是嗎？

使用這種方法，你無須繃緊神經關注每一個函式返回點是否釋放了鎖，因為這個操作已經被std::lock_guard 例項的解構函式接管了。

注意

現在我們結束了短暫的 Semaphores 之旅。在本章中你學習瞭如何使用 C++ 執行緒庫中的互斥量來保護你的共享資料。**

但有一點請牢記：鎖機制會帶來效率的降低。的確，一旦使用鎖，你的部分程式碼就變得有序[非併發]了。如果你想要設計一個高度併發的應用程式，你將會用到其他一些比鎖更好的機制，但他們已不屬於本文的討論範疇。

C++11 併發程式設計教程 - Part 3 : 鎖的進階與條件變數

上一章使用互斥量解決執行緒同步，這一章將進一步討論互斥量的話題，並介紹C++11併發庫中的另一種同步機制——條件變數。

遞迴鎖

待續。。。