多執行緒能提高程式的效率，但同時也帶來了相應的問題----資料競爭。當多個執行緒同時操作同一個變數時，就會出現資料競爭。出現數據競爭，一般會用臨界區（Critical Section）、互斥量（Mutex）、訊號量（Semaphore）、事件（Event）這四種方法來完成執行緒同步。

1、臨界區

對於臨界資源，多執行緒必須互斥地對它進行訪問。每個執行緒訪問臨界資源的那段程式碼就稱為臨界區。它保證每次只能有一個執行緒進入臨界區。有一個執行緒進入臨界區後其他試圖訪問臨界區的執行緒會被掛起。臨界區被釋放後，其他執行緒才可以繼續搶佔。幾種同步處理中，臨界區速度最快，但它只能實現同進程中的多個執行緒同步，無法實現多程序同步。c++11並沒有為我們提供臨界區類。

2、互斥量

互斥量與臨界區相似，但臨界區不支援多程序，而mutex支援多程序。c++11標準庫中提供了mutex類。

1. #include "stdafx.h"
2. #include <vector>
3. #include <thread>
4. #include <iostream>
5. #include <mutex>
6. usingnamespace std;  
7. mutex sLock;  
8. int i = 0;  
9. void test()  
10. {  
11.     for (int j = 0; j < 1000; j++)  
12.     {  
13.         sLock.lock();  
14.         i++;  
15.         sLock.unlock();  
16.     }  
17. }  
18. int main(int argc, _TCHAR* argv[])  
19. {  
20.     vector<thread> v;  
21.     for (int j = 0; j < 100; j++)  
22.     {  
23.         v.emplace_back(test);  
24.     }  
25.     for(auto& t : v)  
26.     {  
27.         t.join();  
28.     }  
29.     cout << i << endl;  
30. }  

曾有人對c++11中的thread和mutex效能進行了測試。點選開啟連結根據他的測試結果，std::thread的效能損耗不大，但std::mutex的效能損耗非常大。所以如果設計中要考慮效能的話，應該避免使用c++11標準庫中的mutex

3、訊號量

訊號量物件對執行緒的同步方式與前面幾種方法不同，訊號量允許多個執行緒同時使用共享資源。它的原理是：

P操作 申請資源： 
　　（1）S減1； 
　　（2）若S減1後仍大於等於零，則程序繼續執行； 
　　（3）若S減1後小於零，則該程序被阻塞後進入與該訊號相對應的佇列中，然後轉入程序排程。 
V操作 釋放資源： 
　　（1）S加1； 
　　（2）若相加結果大於零，則程序繼續執行； 
　　（3）若相加結果小於等於零，則從該訊號的等待佇列中喚醒一個等待程序，然後再返回原程序繼續執行或轉入程序排程。 

4、事件

事件物件可以通過通知操作的方式來保持執行緒同步。

什麼是條件變數？

條件變數是一種同步機制，允許執行緒掛起，直到共享資料上的某些條件得到滿足。條件變數上的基本操作有：觸發條件(當條件變為 true 時)；等待條件，掛起執行緒直到其他執行緒觸發條件。條件變數要和互斥量相聯結，以避免出現條件競爭－－一個執行緒預備等待一個條件變數，當它在真正進入等待之前，另一個執行緒恰好觸發了該條件。

什麼意思呢？不清楚沒關係。看了例子就知道了：問題描述:假設有一個bool型全域性變數 isTrue ，現有10個執行緒，執行緒流程如下：當isTrue為真時，doSomething；否則掛起執行緒，直到條件滿足。那麼，用thread和mutex如何實現這個功能呢？

1. #include <vector>
2. #include <iostream>
3. #include <thread>
4. #include <mutex>
5. #include <chrono>
6. usingnamespace  std;  
7. bool isTrue = false;  
8. void doSomething()  
9. {  
10.     cout << "this is : " << this_thread::get_id() << endl;  
11. }  
12. void thread_Func()  
13. {  
14.     while (!isTrue)  
15.         this_thread::yield();  
16.     doSomething();  
17. }  
18. int main()  
19. {  
20.     vector<thread> v;  
21.     v.reserve(10);  
22.     for (int i = 0; i < 10; i++)  
23.     {  
24.         v.emplace_back(thread_Func);  
25.     }  
26.     this_thread::sleep_for(chrono::seconds(2));  
27.     isTrue = true;  
28.     for (auto& t : v)  
29.     {  
30.         t.join();  
31.     }  
32.     return 1;  
33. }  

先來看看條件變數的介紹：

條件變數能夠掛起呼叫執行緒，直到接到通知才會喚醒執行緒。它使用unique_lock<Mutex>來配合完成。下面是用條件變數實現需求：

1. #include <iostream>
2. #include <vector>
3. #include <thread>
4. #include <mutex>
5. #include <chrono>
6. #include <condition_variable>
7. usingnamespace  std;  
8. bool isTrue = false;  
9. std::mutex mtx;  
10. std::condition_variable cv;  
11. void doSomething()  
12. {  
13.     cout << "this is : " << this_thread::get_id() << endl;  
14. }  
15. void thread_Func()  
16. {  
17.     unique_lock<mutex> loc(mtx);  
18.     while (!isTrue)  
19.         cv.wait(loc);  
20.     doSomething();  
21. }  
22. int main()  
23. {  
24.     vector<thread> v;  
25.     v.reserve(10);  
26.     for (int i = 0; i < 10; i++)  
27.     {  
28.         v.emplace_back(thread_Func);  
29.     }  
30.     this_thread::sleep_for(chrono::seconds(2));  
31.     {  
32.         unique_lock<mutex> loc(mtx);  
33.         isTrue = true;  
34.         cv.notify_all();  
35.     }  
36.     for (auto& t : v)  
37.     {  
38.         t.join();  
39.     }  
40.     return 1;  
41. }  

我們把while (!isTrue) cv.wait(loc)拆開：

假如現在1執行完後，時間片輪轉，該子執行緒暫停執行。而恰好在這時，主執行緒修改了條件，並呼叫了cv.notify_all()函式。這種情況下，該子執行緒是收不到通知的，因為它還沒掛起。等下一次排程子執行緒時，子執行緒接著執行2將自己掛起。但現在主執行緒中的notify早已經呼叫過了，不會再調第二次了，所以該子執行緒永遠也無法喚醒了。

1. void thread_Func()  
2. {  
3. unique_lock<mutex> loc(mtx);  
4. cv.wait(loc, []() -> bool { return isTrue;} );  
5. doSomething();  
6. }