C++11 多线程同步

多线程能提高程序的效率，但同时也带来了相应的问题----数据竞争。当多个线程同时操作同一个变量时，就会出现数据竞争。出现数据竞争，一般会用临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event）这四种方法来完成线程同步。

1、临界区

对于临界资源，多线程必须互斥地对它进行访问。每个线程访问临界资源的那段代码就称为临界区。它保证每次只能有一个线程进入临界区。有一个线程进入临界区后其他试图访问临界区的线程会被挂起。临界区被释放后，其他线程才可以继续抢占。几种同步处理中，临界区速度最快，但它只能实现同进程中的多个线程同步，无法实现多进程同步。c++11并没有为我们提供临界区类。

2、互斥量

互斥量与临界区相似，但临界区不支持多进程，而mutex支持多进程。c++11标准库中提供了mutex类。

[cpp] 
   view plain
    copy 
    
   
 #include "stdafx.h"  
 #include <vector>  
 #include <thread>  
 #include <iostream>  
 #include <mutex>  
 using namespace std;  
   
 mutex sLock;  
 int i = 0;  
 void test()  
 {  
     for (int j = 0; j < 1000; j++)  
     {  
         sLock.lock();  
         i++;  
         sLock.unlock();  
     }  
 }  
   
 int main(int argc, _TCHAR* argv[])  
 {  
     vector<thread> v;  
   
     for (int j = 0; j < 100; j++)  
     {  
         v.emplace_back(test);  
     }  
   
     for(auto& t : v)  
     {  
         t.join();  
     }  
   
     cout << i << endl;  
 }  

曾有人对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如何实现这个功能呢？

[cpp] 
   view plain
    copy 
    
   
 #include <vector>  
 #include <iostream>  
 #include <thread>  
 #include <mutex>  
 #include <chrono>  
 using namespace  std;  
   
 bool isTrue = false;  
   
 void doSomething()  
 {  
     cout << "this is : " << this_thread::get_id() << endl;  
 }  
   
 void thread_Func()  
 {  
     while (!isTrue)  
         this_thread::yield();  
   
     doSomething();  
 }  
   
 int main()  
 {  
     vector<thread> v;  
     v.reserve(10);  
       
     for (int i = 0; i < 10; i++)  
     {  
         v.emplace_back(thread_Func);  
     }  
   
     this_thread::sleep_for(chrono::seconds(2));  
   
     isTrue = true;  
   
     for (auto& t : v)  
     {  
         t.join();  
     }  
     return 1;  
 }  

这段代码虽然能满足需求，但有一个大缺点，就是当条件为假时，子线程会不停的测试条件，这样会消耗系统资源。我们的思想是，当条件为假时，子线程挂起，直到条件为真时，才唤醒子线程。
nice，条件变量就是干这事的！

先来看看条件变量的介绍：

条件变量能够挂起调用线程，直到接到通知才会唤醒线程。它使用unique_lock<Mutex>来配合完成。下面是用条件变量实现需求：

[cpp] 
   view plain
    copy 
    
   
 #include <iostream>  
 #include <vector>  
 #include <thread>  
 #include <mutex>  
 #include <chrono>  
 #include <condition_variable>  
   
 using namespace  std;  
   
 bool isTrue = false;  
 std::mutex mtx;  
 std::condition_variable cv;  
   
 void doSomething()  
 {  
     cout << "this is : " << this_thread::get_id() << endl;  
 }  
   
 void thread_Func()  
 {  
     unique_lock<mutex> loc(mtx);  
     while (!isTrue)  
         cv.wait(loc);  
   
     doSomething();  
 }  
   
   
   
 int main()  
 {  
     vector<thread> v;  
     v.reserve(10);  
   
     for (int i = 0; i < 10; i++)  
     {  
         v.emplace_back(thread_Func);  
     }  
   
     this_thread::sleep_for(chrono::seconds(2));  
   
     {  
         unique_lock<mutex> loc(mtx);  
         isTrue = true;  
         cv.notify_all();  
     }  
   
     for (auto& t : v)  
     {  
         t.join();  
     }  
     return 1;  
 }  

我们发现，在条件变量cv的wait函数中，我们传入了一个lock参数，为什么要用锁呢？因为isTrue为临界变量，主线程中会“写”它，子线程中要“读”它，这样就产生了数据竞争，并且这个竞争很危险。

我们把while (!isTrue) cv.wait(loc)拆开：

1、条件判断
2、挂起线程

假如现在1执行完后，时间片轮转，该子线程暂停执行。而恰好在这时，主线程修改了条件，并调用了cv.notify_all()函数。这种情况下，该子线程是收不到通知的，因为它还没挂起。等下一次调度子线程时，子线程接着执行2将自己挂起。但现在主线程中的notify早已经调用过了，不会再调第二次了，所以该子线程永远也无法唤醒了。

为了解决上面的情况，就要使用某种同步手段来给线程加锁。而c++11的condition_variable选择了用unique_lock<Mutex>来配合完成这个功能。并且我们只需要加锁，条件变量在挂起线程时，会调用原子操作来解锁。

c++11还为我们提供了一个更方便的接口，连同条件判断，一起放在条件变量里。上面的线程函数可做如下修改：

[cpp] 
   view plain
    copy 
    
   
 void thread_Func()  
 {  
 unique_lock<mutex> loc(mtx);  
 cv.wait(loc, []() -> bool { return isTrue;} );  
   
 doSomething();  
 }  