前言

執行緒同步

這裡的“同”不是同時、一起執行的意思，而是指協同、協助、互相配合。執行緒同步是指多個執行緒協同步調，按預定的先後次序進行執行。

執行緒A和B一塊配合，A執行到一定程度時要依靠B的某個結果，於是停下來，示意B執行；B依言執行，再將結果給A；A再繼續操作。

所謂同步，就是在發出一個功能呼叫時，在沒有得到結果之前，該呼叫就不返回，同時其它執行緒也不能呼叫這個方法。

定義：即當有一個執行緒在對記憶體進行操作時，其他執行緒都不可以對這個記憶體地址進行操作，直到該執行緒完成操作，其他執行緒才能對該記憶體地址進行操作，而其他執行緒又處於等待狀態。

目前實現執行緒同步的方法有很多：

1、臨界區（Critical Section）：通過對多執行緒的序列化來訪問公共資源或一段程式碼，速度快，適合控制資料訪問。在任意時刻只允許一個執行緒對共享資源進行訪問，如果有多個執行緒試圖訪問公共資源，那麼在有一個執行緒進入後，其他試圖訪問公共資源的執行緒將被掛起，並一直等到進入臨界區的執行緒離開，臨界區在被釋放後，其他執行緒才可以搶佔。

2、互斥量（Mutex）：採用互斥物件機制。 只有擁有互斥物件的執行緒才有訪問公共資源的許可權，因為互斥物件只有一個，所以能保證公共資源不會同時被多個執行緒訪問。互斥不僅能實現同一應用程式的公共資源安全共享，還能實現不同應用程式的公共資源安全共享

3、訊號量（Semaphore）

4、事件（Event）：通過通知操作的方式來保持執行緒的同步，還可以方便實現對多個執行緒的優先順序比較的操作

（一）< mutex>標頭檔案

Mutex 又稱互斥量，C++ 11中與 Mutex 相關的類（包括鎖型別）和函式都宣告在 < mutex> 標頭檔案中，所以如果你需要使用 std::mutex，就必須包含 < mutex> 標頭檔案。

Mutex 系列類（四種）

• std::mutex，最基本的 Mutex 類。
• std::recursive_mutex，遞迴 Mutex 類。
• std::time_mutex，定時 Mutex 類。
• std::recursive_timed_mutex，定時遞迴 Mutex 類。

Lock 類（兩種）

• std::lock_guard，與 Mutex RAII 相關，方便執行緒對互斥量上鎖。
• std::unique_lock，與 Mutex RAII 相關，方便執行緒對互斥量上鎖，但提供了更好的上鎖和解鎖控制。

其他型別

• std::once_flag
• std::adopt_lock_t
• std::defer_lock_t
• std::try_to_lock_t

函式

• std::try_lock，嘗試同時對多個互斥量上鎖。
• std::lock，可以同時對多個互斥量上鎖。
• std::call_once，如果多個執行緒需要同時呼叫某個函式，call_once 可以保證多個執行緒對該函式只調用一次。

（二）Mutex 系列類

1 std::mutex

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

1.1 std::mutex的成員函式

1. 建構函式
   std::mutex不允許拷貝構造，也不允許 move 拷貝，最初產生的 mutex 物件是處於 unlocked 狀態的。
2. lock()
   呼叫執行緒將鎖住該互斥量。
   執行緒呼叫該函式會發生下面 3 種情況：
   （1）如果該互斥量當前沒有被鎖住，則呼叫執行緒將該互斥量鎖住，直到呼叫 unlock之前，該執行緒一直擁有該鎖。
   （2）如果當前互斥量被其他執行緒鎖住，則當前的呼叫執行緒被阻塞住。
   （3）如果當前互斥量被當前呼叫執行緒鎖住，則會產生死鎖(deadlock)。
3. unlock()
   解鎖，釋放對互斥量的所有權。
4. try_lock()
   嘗試鎖住互斥量，如果互斥量被其他執行緒佔有，則當前執行緒也不會被阻塞。
   執行緒呼叫該函式會出現線面 3 種情況：
   （1）如果當前互斥量沒有被鎖住免責呼叫執行緒將該互斥量鎖住，知道呼叫unlock之前，該執行緒一直擁有該鎖。
   （2）如果當前互斥量已經被其他執行緒鎖住了，則當前呼叫執行緒返回 false ，而並不會被阻塞。
   （3）如果當前互斥量被當前呼叫執行緒鎖住，會產生死鎖（deadlock）。

例子

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex

volatile int counter(0); // non-atomic counter
std::mutex mtx;           // locks access to counter

void attempt_10k_increases() {
    for (int i=0; i<10000; ++i) {
        if (mtx.try_lock()) {   // only increase if currently not locked:
            ++counter;
            mtx.unlock();
        }
    }
}

int main (int argc, const char* argv[]) {
    std::thread threads[10];
    for (int i=0; i<10; ++i)
        threads[i] = std::thread(attempt_10k_increases);

    for (auto& th : threads) th.join();
    std::cout << counter << " successful increases of the counter.\n";

    return 0;
}

2 std::recursive_mutex

std::recursive_mutex 與 std::mutex 一樣，也是一種可以被上鎖的物件，但是和 std::mutex 不同的是，std::recursive_mutex 允許同一個執行緒對互斥量多次上鎖（即遞迴上鎖），來獲得對互斥量物件的多層所有權，std::recursive_mutex 釋放互斥量時需要呼叫與該鎖層次深度相同次數的 unlock()，可理解為 lock) 次數和 unlock() 次數相同 。

除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同

3 std::time_mutex