C++11 多线程同步

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


1、临界区

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



2、互斥量

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

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

曾有人对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
  1. #include <vector>  
  2. #include <iostream>  
  3. #include <thread>  
  4. #include <mutex>  
  5. #include <chrono>  
  6. using namespace  std;  
  7.   
  8. bool isTrue = false;  
  9.   
  10. void doSomething()  
  11. {  
  12.     cout << "this is : " << this_thread::get_id() << endl;  
  13. }  
  14.   
  15. void thread_Func()  
  16. {  
  17.     while (!isTrue)  
  18.         this_thread::yield();  
  19.   
  20.     doSomething();  
  21. }  
  22.   
  23. int main()  
  24. {  
  25.     vector<thread> v;  
  26.     v.reserve(10);  
  27.       
  28.     for (int i = 0; i < 10; i++)  
  29.     {  
  30.         v.emplace_back(thread_Func);  
  31.     }  
  32.   
  33.     this_thread::sleep_for(chrono::seconds(2));  
  34.   
  35.     isTrue = true;  
  36.   
  37.     for (auto& t : v)  
  38.     {  
  39.         t.join();  
  40.     }  
  41.     return 1;  
  42. }  
这段代码虽然能满足需求,但有一个大缺点,就是当条件为假时,子线程会不停的测试条件,这样会消耗系统资源。我们的思想是,当条件为假时,子线程挂起,直到条件为真时,才唤醒子线程。
nice,条件变量就是干这事的!

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

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

[cpp] view plain copy
  1. #include <iostream>  
  2. #include <vector>  
  3. #include <thread>  
  4. #include <mutex>  
  5. #include <chrono>  
  6. #include <condition_variable>  
  7.   
  8. using namespace  std;  
  9.   
  10. bool isTrue = false;  
  11. std::mutex mtx;  
  12. std::condition_variable cv;  
  13.   
  14. void doSomething()  
  15. {  
  16.     cout << "this is : " << this_thread::get_id() << endl;  
  17. }  
  18.   
  19. void thread_Func()  
  20. {  
  21.     unique_lock<mutex> loc(mtx);  
  22.     while (!isTrue)  
  23.         cv.wait(loc);  
  24.   
  25.     doSomething();  
  26. }  
  27.   
  28.   
  29.   
  30. int main()  
  31. {  
  32.     vector<thread> v;  
  33.     v.reserve(10);  
  34.   
  35.     for (int i = 0; i < 10; i++)  
  36.     {  
  37.         v.emplace_back(thread_Func);  
  38.     }  
  39.   
  40.     this_thread::sleep_for(chrono::seconds(2));  
  41.   
  42.     {  
  43.         unique_lock<mutex> loc(mtx);  
  44.         isTrue = true;  
  45.         cv.notify_all();  
  46.     }  
  47.   
  48.     for (auto& t : v)  
  49.     {  
  50.         t.join();  
  51.     }  
  52.     return 1;  
  53. }  
我们发现,在条件变量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
  1. void thread_Func()  
  2. {  
  3. unique_lock<mutex> loc(mtx);  
  4. cv.wait(loc, []() -> bool { return isTrue;} );  
  5.   
  6. doSomething();  
  7. }  

没有更多推荐了,返回首页