C++11并发之std::mutex

知识链接:

C++11并发之std::thread

 

本文概要:

1、 头文件。

2、std::mutex。

3、std::recursive_mutex。

4、std::time_mutex。

5、std::lock_guard 与 std::unique_lock。

Mutex 又称互斥量,C++ 11中与 Mutex 相关的类(包括锁类型)和函数都声明在 #include 头文件中,所以如果你需要使用 std::mutex,就必须包含 #include 头文件。

1、 头文件。

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 可以保证多个线程对该函数只调用一次。

2、std::mutex。

下面以 std::mutex 为例介绍 C++11 中的互斥量用法。

std::mutex 是C++11 中最基本的互斥量,std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁,而 std::recursive_lock 则可以递归地对互斥量对象上锁。

std::mutex 的成员函数

(1)构造函数,std::mutex不允许拷贝构造,也不允许 move 拷贝,最初产生的 mutex 对象是处于 unlocked 状态的。

(2)lock(),调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况:

a)如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用 unlock之前,该线程一直拥有该锁。

b)如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住。

c)如果当前互斥量被当前调用线程锁住,则会产生死锁 (deadlock) 。

(3)unlock(),解锁,释放对互斥量的所有权。

(4)try_lock(),尝试锁住互斥量,如果互斥量被其他线程占有,则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况:

a)如果当前互斥量没有被其他线程占有,则该线程锁住互斥量,直到该线程调用 unlock 释放互斥量。

b)如果当前互斥量被其他线程锁住,则当前调用线程返回 false,而并不会被阻塞掉。

c)如果当前互斥量被当前调用线程锁住,则会产生死锁 (deadlock) 。

std::mutex的例子如下:


  1. #include //std::cout
  2. #include //std::thread
  3. #include //std::mutex
  4. #include //std::atomic
  5. using namespace std;
  6. atomic_int counter{ 0 }; //原子变量
  7. mutex g_mtx; //互斥量
  8. void fun()
  9. {
  10. for (int i = 0; i <</span> 1000000; ++i)
  11. {
  12. if (g_mtx.try_lock()) //尝试是否可以加锁
  13. {
  14. ++counter;
  15. g_mtx.unlock(); //解锁
  16. }
  17. }
  18. }
  19. int main()
  20. {
  21. thread threads[10];
  22. for (int i = 0; i <</span> 10; ++i)
  23. {
  24. threads[i] = thread(fun);
  25. }
  26. for (auto & th : threads)
  27. {
  28. th.join();
  29. }
  30. cout << "counter=" << counter << endl;
  31. system("pause");
  32. return 0;
  33. }
  34. 运行结果:
  35. counter=1342244

从例子可知,10个线程不会产生死锁,由于 try_lock() ,尝试锁住互斥量,如果互斥量被其他线程占有,则当前线程也不会被阻塞。但是这样会导致结果不正确,这也就是线程安全的问题,前面在 C++11并发之std::thread T7 中详细介绍了这个问题。

3、std::recursive_mutex。

如果一个线程中可能在执行中需要再次获得锁的情况,按常规的做法会出现死锁。

例如:


  1. #include //std::cout
  2. #include //std::thread
  3. #include //std::mutex
  4. using namespace std;
  5. mutex g_mutex;
  6. void threadfun1()
  7. {
  8. cout << "enter threadfun1" << endl;
  9. lock_guard lock(g_mutex);
  10. cout << "execute threadfun1" << endl;
  11. }
  12. void threadfun2()
  13. {
  14. cout << "enter threadfun2" << endl;
  15. lock_guard lock(g_mutex);
  16. threadfun1();
  17. cout << "execute threadfun2" << endl;
  18. }
  19. int main()
  20. {
  21. threadfun2(); //死锁
  22. //Unhandled exception at 0x758BC42D in Project2.exe: Microsoft C++ exception: std::system_error at memory location 0x0015F140.
  23. return 0;
  24. }
  25. 运行结果:
  26. enter threadfun2
  27. enter threadfun1
  28. //就会产生死锁

此时就需要使用递归式互斥量 recursive_mutex 来避免这个问题。recursive_mutex不会产生上述的死锁问题,只是是增加锁的计数,但必须确保你unlock和lock的次数相同,其他线程才可能锁这个mutex。

例如:


  1. #include //std::cout
  2. #include //std::thread
  3. #include //std::mutex
  4. using namespace std;
  5. recursive_mutex g_rec_mutex;
  6. void threadfun1()
  7. {
  8. cout << "enter threadfun1" << endl;
  9. lock_guard lock(g_rec_mutex);
  10. cout << "execute threadfun1" << endl;
  11. }
  12. void threadfun2()
  13. {
  14. cout << "enter threadfun2" << endl;
  15. lock_guard lock(g_rec_mutex);
  16. threadfun1();
  17. cout << "execute threadfun2" << endl;
  18. }
  19. int main()
  20. {
  21. threadfun2(); //利用递归式互斥量来避免这个问题
  22. return 0;
  23. }
  24. 运行结果:
  25. enter threadfun2
  26. enter threadfun1
  27. execute threadfun1
  28. execute threadfun2

结论:

std::recursive_mutex 与 std::mutex 一样,也是一种可以被上锁的对象,但是和 std::mutex 不同的是,std::recursive_mutex 允许同一个线程对互斥量多次上锁(即递归上锁),来获得对互斥量对象的多层所有权,std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock(),可理解为 lock() 次数和 unlock() 次数相同,除此之外,std::recursive_mutex 的特性和 std::mutex 大致相同。

4、std::time_mutex。

std::time_mutex 比 std::mutex 多了两个成员函数,try_lock_for(),try_lock_until()。

try_lock_for 函数接受一个时间范围,表示在这一段时间范围之内线程如果没有获得锁则被阻塞住(与 std::mutex 的 try_lock() 不同,try_lock 如果被调用时没有获得锁则直接返回 false),如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。

例如:


  1. #include //std::cout
  2. #include //std::thread
  3. #include //std::mutex
  4. using namespace std;
  5. std::timed_mutex g_t_mtx;
  6. void fun()
  7. {
  8. while (!g_t_mtx.try_lock_for(std::chrono::milliseconds(200)))
  9. {
  10. cout << "-";
  11. }
  12. this_thread::sleep_for(std::chrono::milliseconds(1000));
  13. cout << "*" << endl;
  14. g_t_mtx.unlock();
  15. }
  16. int main()
  17. {
  18. std::thread threads[10];
  19. for (int i = 0; i <</span> 10; i++)
  20. {
  21. threads[i] = std::thread(fun);
  22. }
  23. for (auto & th : threads)
  24. {
  25. th.join();
  26. }
  27. return 0;
  28. }
  29. 运行结果:
  30. ------------------------------------*
  31. ----------------------------------------*
  32. -----------------------------------*
  33. ------------------------------*
  34. -------------------------*
  35. --------------------*
  36. ---------------*
  37. ----------*
  38. -----*
  39. *

try_lock_until 函数则接受一个时间点作为参数,在指定时间点未到来之前线程如果没有获得锁则被阻塞住,如果在此期间其他线程释放了锁,则该线程可以获得对互斥量的锁,如果超时(即在指定时间内还是没有获得锁),则返回 false。

5、std::lock_guard 与 std::unique_lock。

上面介绍的方法对 mutex 的加解锁都是手动的,接下来介绍 std::lock_guard 与 std::unique_lock 对 mutex 进行自动加解锁。

例如:


  1. #include //std::cout
  2. #include //std::thread
  3. #include //std::mutex
  4. #include //std::atomic
  5. using namespace std;
  6. mutex g_mtx1;
  7. atomic_int num1{ 0 };
  8. void fun1()
  9. {
  10. for (int i = 0; i <</span> 10000000; i++)
  11. {
  12. unique_lock ulk(g_mtx1);
  13. num1++;
  14. }
  15. }
  16. mutex g_mtx2;
  17. atomic_int num2{ 0 };
  18. void fun2()
  19. {
  20. for (int i = 0; i <</span> 10000000; i++)
  21. {
  22. lock_guard lckg(g_mtx2);
  23. num2++;
  24. }
  25. }
  26. int main()
  27. {
  28. thread th1(fun1);
  29. thread th2(fun1);
  30. th1.join();
  31. th2.join();
  32. cout << "num1=" << num1 << endl;
  33. thread th3(fun2);
  34. thread th4(fun2);
  35. th3.join();
  36. th4.join();
  37. cout << "num2=" << num2 << endl;
  38. return 0;
  39. }
  40. 运行结果:
  41. num1=20000000
  42. num2=20000000

接下来,分析一下这两者的区别:

(1)unique_lock。

unique_lock ulk(g_mtx1);

线程没有 g_mtx1 的所有权,根据块语句的循环实现自动加解锁。

线程根据 g_mtx1 属性,来判断是否可以加锁、解锁。

(2)lock_guard。

lock_guard lckg(g_mtx2);

线程拥有 g_mtx2 的所有权,实现自动加解锁。

线程读取 g_mtx2 失败时,则一直等待,直到读取成功。

线程会把  g_mtx2 一直占有,直到当前线程完成才释放,其它线程才能访问。

时间: 2024-10-12 18:51:53

C++11并发之std::mutex的相关文章

[转] c++11并发之std::thread

[转自 https://blog.csdn.net/liuker888/article/details/46848905#] 知识链接: C++11 并发之std::mutex C++11 并发之std::atomic 本文概要: 1.成员类型和成员函数. 2.std::thread 构造函数. 3.异步. 4.多线程传递参数. 5.join.detach. 6.获取CPU核心个数. 7.CPP原子变量与线程安全. 8.lambda与多线程. 9.时间等待相关问题. 10.线程功能拓展. 11.

C++11 并发指南三(std::mutex 详解)

C++11 并发指南三(std::mutex 详解) 上一篇<C++11 并发指南二(std::thread 详解)>中主要讲到了 std::thread 的一些用法,并给出了两个小例子,本文将介绍 std::mutex 的用法. Mutex 又称互斥量,C++ 11中与 Mutex 相关的类(包括锁类型)和函数都声明在 <mutex> 头文件中,所以如果你需要使用 std::mutex,就必须包含 <mutex> 头文件. <mutex> 头文件介绍 Mu

[C++11 并发编程] 08 - Mutex std::unique_lock

相对于std::lock_guard来说,std::unique_lock更加灵活,std::unique_lock不拥有与其关联的mutex.构造函数的第二个参数可以指定为std::defer_lock,这样表示在构造unique_lock时,传入的mutex保持unlock状态.然后通过调用std::unique_lock对象的lock()方法或者将将std::unique_lock对象传入std::lock()方法来锁定mutex. #include <mutex> class some

C++11 并发指南------std::thread 详解

参考: https://github.com/forhappy/Cplusplus-Concurrency-In-Practice/blob/master/zh/chapter3-Thread/Introduction-to-Thread.md#stdthread-%E8%AF%A6%E8%A7%A3 本节将详细介绍 std::thread 的用法. std::thread 在 <thread> 头文件中声明,因此使用 std::thread 需包含 <thread> 头文件. &

[C++11 并发编程] 06 - Mutex 死锁

假设有两个线程,在执行某些操作时,都需要锁定一对mutex,线程A锁定了mutex A,而线程B锁定了额mutex B,它们都在等待对方释放另一个mutex,这就会导致这两个线程都无法继续执行.这种情况就是死锁. 避免死锁最简单的方法是总是以相同的顺序对两个mutex进行锁定,比如总是在锁定mutex B之前锁定mutex A,就永远都不会死锁. 假设有一个操作要交换同一个类的两个实例的内容,为了交换操作不被并发修改影响,我们需要锁定这两个实例内部的mutex.但是,如果选定一个固定的顺序来锁定

基于std::mutex std::lock_guard std::condition_variable 和std::async实现的简单同步队列

C++多线程编程中通常会对共享的数据进行写保护,以防止多线程在对共享数据成员进行读写时造成资源争抢导致程序出现未定义的行为.通常的做法是在修改共享数据成员的时候进行加锁--mutex.在使用锁的时候通常是在对共享数据进行修改之前进行lock操作,在写完之后再进行unlock操作,进场会出现由于疏忽导致由于lock之后在离开共享成员操作区域时忘记unlock,导致死锁. 针对以上的问题,C++11中引入了std::unique_lock与std::lock_guard两种数据结构.通过对lock和

使用std::mutex取代QMutex

为了保证对某个资源的操作是原子性的(对资源读写时,只有当前的操作结束,才允许另外线程对其操作,这里有个理解误区,资源操作原子性不是说,当前某个线程获得了某个资源使用权,然后线程执行时间完毕,要切换线程了,因为资源操作是原子性的,所以它就阻止线程切换,这是不可能的,要是某个程序里获得资源不放,那么操作系统上其他程序都不能跑咯.当然不是,原子操作的意思是,某个线程获得了某个资源的使用权,其他资源也想获得该资源的使用权时只能等待--等待会导致线程切换(节约CPU时间),只有当获得资源使用权的线程释放了

[C++11 并发编程] 06 Mutex race condition

上一节中介绍了mutex的基本使用方法,使用mutex来保护共享数据并不能解决race condition带来的问题,假如我们有一个堆栈数据结构类似于std::stack它提供了5个基本操作push(),pop(),top(),empty(),和size().这里的top()操作返回栈顶元素的拷贝,这样我们就可以使用一个mutex来保护栈内部的数据.但是race codition情况下,虽然使用mutex在stack的每个接口内都对共享数据进行了保护,仍然有问题存在. #include <deq

C++11 学习笔记 std::function和bind绑定器

一.std::function C++中的可调用对象虽然具有比较统一操作形式(除了类成员指针之外,都是后面加括号进行调用),但定义方法五花八门.为了统一泛化函数对象,函数指针,引用函数,成员函数的指针的各种操作,让我们可以按更统一的方式写出更加泛化的代码,C++11推出了std::function. std::function是可调用对象的包装器.它是一个类模板,可以容纳除了类成员(函数)指针之外的所有可调用对象.通过指定它的模板参数,它可以用统一的方式处理函数,函数对象,函数指针,并允许保存和