C++11并发学习之三:线程同步

1.<mutex> 头文件介绍

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

(1)Mutex系列类(四种)
std::mutex,最基本的 Mutex 类。
std::recursive_mutex,递归 Mutex 类。
std::time_mutex,定时 Mutex 类。

std::recursive_timed_mutex,定时递归 Mutex 类。

(2)Lock系列类(两种)
std::lock_guard,与 Mutex RAII 相关,方便线程对互斥量上锁。
std::unique_lock,与 Mutex RAII 相关,方便线程对互斥量上锁,但提供了更好的上锁和解锁控制。

(3)其他类型(结构体)

std::adopt_lock_t——它的常量对象定义为constexpr adopt_lock_t adopt_lock {};// constexpr 是 C++11 中的新关键字)
std::defer_lock_t——它的常量对象定义为constexpr defer_lock_t defer_lock {};// constexpr 是 C++11 中的新关键字)

std::try_to_lock_t——它的常量对象定义为constexpr try_to_lock_t try_to_lock {};// constexpr 是 C++11 中的新关键字)

(4)函数
std::try_lock,尝试同时对多个互斥量上锁。
std::lock,可以同时对多个互斥量上锁。

std::call_once,如果多个线程需要同时调用某个函数,call_once 可以保证多个线程对该函数只调用一次。

2.常用类型举例

(1)std::mutex类

☆构造函数,std::mutex不允许拷贝构造,也不允许 move 拷贝,最初产生的 mutex 对象是处于 unlocked 状态的。
☆lock(),调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况:①如果该互斥量当前没有被锁住,则调用线程将该互斥量锁住,直到调用 unlock之前,该线程一直拥有该锁。②如果当前互斥量被其他线程锁住,则当前的调用线程被阻塞住。③如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。
☆unlock(), 解锁,释放对互斥量的所有权。
☆try_lock(),尝试锁住互斥量,如果互斥量被其他线程占有,则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况:① 如果该互斥量当前没有被锁住,则该线程锁住互斥量,直到该线程调用 unlock 释放互斥量。②如果当前互斥量被其他线程锁住,则当前调用线程返回 false,而并不会被阻塞掉。③如果当前互斥量被当前调用线程锁住,则会产生死锁(deadlock)。

不论是lock()还是try_lock()都需要和unlock()配套使用,下面举例说明lock()和try_lock()的区别。

  1. #include <thread>
  2. #include <iostream>
  3. #include <string>
  4. #include <chrono>
  5. #include <assert.h>
  6. #include <mutex>
  7. int counter=0;
  8. std::mutex mtx;
  9. void func()
  10. {
  11. for (int i=0; i<10000; ++i)
  12. {
  13. mtx.lock();
  14. ++counter;
  15. mtx.unlock();
  16. }
  17. }
  18. int main()
  19. {
  20. std::thread workerThreads[10];
  21. for (int i=0; i<10; ++i)
  22. {
  23. workerThreads[i] = std::thread(func);
  24. }
  25. for (auto& workerThread : workerThreads)
  26. {
  27. workerThread.join();
  28. }
  29. std::cout << counter << " successful increases of the counter"<<std::endl;
  30. return 0;
  31. }


由于lock()的阻塞特性,所以每个线程都统计了10000次,一共是10*10000=100000次。

  1. #include <thread>
  2. #include <iostream>
  3. #include <string>
  4. #include <chrono>
  5. #include <assert.h>
  6. #include <mutex>
  7. int counter=0;
  8. std::mutex mtx;
  9. void func()
  10. {
  11. for (int i=0; i<10000; ++i)
  12. {
  13. if (mtx.try_lock())
  14. {
  15. ++counter;
  16. mtx.unlock();
  17. }
  18. }
  19. }
  20. int main()
  21. {
  22. std::thread workerThreads[10];
  23. for (int i=0; i<10; ++i)
  24. {
  25. workerThreads[i] = std::thread(func);
  26. }
  27. for (auto& workerThread : workerThreads)
  28. {
  29. workerThread.join();
  30. }
  31. std::cout << counter << " successful increases of the counter"<<std::endl;
  32. return 0;
  33. }


由于try_lock()的非阻塞特性,如果当前互斥量被其他线程锁住,则当前try_lock()返回 false,此时counter并不会增加1。所以这十个线程的统计结果具有随机性,下次运行程序时,统计值不一定是16191。

(2).std::lock_guard和std::unique_lock类

std::lock_guard使用起来比较简单,除了构造函数外没有其他成员函数。
std::unique_lock除了lock_guard的功能外,提供了更多的成员函数,相对来说更灵活一些。这些成员函数包括lock,try_lock,try_lock_for,try_lock_until、unlock等。

std::unique_lock::lock——用它所管理的Mutex对象的 lock 函数。

std::unique_lock::try_lock——用它所管理的Mutex对象的 try_lock函数。

std::unique_lock::unlock——用它所管理的Mutex对象的 unlock函数。

这两个类相比使用std::mutex的优势在于不用配对使用,无需担心忘记调用unlock而导致的程序死锁。

  1. #include <thread>
  2. #include <iostream>
  3. #include <string>
  4. #include <chrono>
  5. #include <assert.h>
  6. #include <mutex>
  7. int counter=0;
  8. std::mutex mtx;
  9. void func()
  10. {
  11. for (int i=0; i<10000; ++i)
  12. {
  13. //将std::lock_guard替换成std::unique_lock,效果是一样的
  14. std::lock_guard<std::mutex> lck (mtx);
  15. ++counter;
  16. }
  17. }
  18. int main()
  19. {
  20. std::thread workerThreads[10];
  21. for (int i=0; i<10; ++i)
  22. {
  23. workerThreads[i] = std::thread(func);
  24. }
  25. for (auto& workerThread : workerThreads)
  26. {
  27. workerThread.join();
  28. }
  29. std::cout << counter << " successful increases of the counter"<<std::endl;
  30. return 0;
  31. }

std::uniqure_lock构造函数的第二个参数可以是std::defer_lock,std::try_to_lock或std::adopt_lock

  1. #include <thread>
  2. #include <iostream>
  3. #include <string>
  4. #include <chrono>
  5. #include <assert.h>
  6. #include <mutex>
  7. int counter=0;
  8. std::mutex mtx;
  9. void func()
  10. {
  11. for (int i=0; i<10000; ++i)
  12. {
  13. mtx.lock();
  14. //注意此时Tag参数为std::adopt_lock表明当前线程已经获得了锁,
  15. //此后mtx对象的解锁操作交由unique_lock对象lck来管理,在lck的生命周期结束之后,
  16. //mtx对象会自动解锁。
  17. std::unique_lock<std::mutex> lck(mtx,std::adopt_lock);
  18. ++counter;
  19. }
  20. }
  21. int main()
  22. {
  23. std::thread workerThreads[10];
  24. for (int i=0; i<10; ++i)
  25. {
  26. workerThreads[i] = std::thread(func);
  27. }
  28. for (auto& workerThread : workerThreads)
  29. {
  30. workerThread.join();
  31. }
  32. std::cout << counter << " successful increases of the counter"<<std::endl;
  33. return 0;
  34. }

  1. #include <chrono>
  2. #include <assert.h>
  3. #include <mutex>
  4. int counter=0;
  5. std::mutex mtx;
  6. void func()
  7. {
  8. for (int i=0; i<10000; ++i)
  9. {
  10. //注意此时Tag参数为std::defer_lock表明当前线程没有获得了锁,
  11. //需要通过lck的lock和unlock来加锁和解锁,
  12. std::unique_lock<std::mutex> lck(mtx,std::defer_lock);
  13. lck.lock();
  14. ++counter;
  15. lck.unlock();
  16. }
  17. }
  18. int main()
  19. {
  20. std::thread workerThreads[10];
  21. for (int i=0; i<10; ++i)
  22. {
  23. workerThreads[i] = std::thread(func);
  24. }
  25. for (auto& workerThread : workerThreads)
  26. {
  27. workerThread.join();
  28. }
  29. std::cout << counter << " successful increases of the counter"<<std::endl;
  30. return 0;
  31. }

参考链接:http://www.cnblogs.com/haippy/p/3346477.html

C++11并发学习之三:线程同步(转载)的更多相关文章

  1. AspectJ基础学习之三HelloWorld(转载)

    AspectJ基础学习之三HelloWorld(转载) 一.创建项目 我们将project命名为:aspectjDemo.然后我们新建2个package:com.aspectj.demo.aspect ...

  2. Python并发编程-进程 线程 同步锁 线程死锁和递归锁

    进程是最小的资源单位,线程是最小的执行单位 一.进程 进程:就是一个程序在一个数据集上的一次动态执行过程. 进程由三部分组成: 1.程序:我们编写的程序用来描述进程要完成哪些功能以及如何完成 2.数据 ...

  3. java SE学习之线程同步(详细介绍)

           java程序中可以允许存在多个线程,但在处理多线程问题时,必须注意这样一个问题:               当两个或多个线程同时访问同一个变量,并且一些线程需要修改这个变量时,那么这个 ...

  4. Java提高班(三)并发中的线程同步与锁

    乐观锁.悲观锁.公平锁.自旋锁.偏向锁.轻量级锁.重量级锁.锁膨胀...难理解?不存的!来,话不多说,带你飙车. 上一篇介绍了线程池的使用,在享受线程池带给我们的性能优势之外,似乎也带来了另一个问题: ...

  5. C++并发编成 03 线程同步

    这一节主要讲讲线程同步的方式,C++ 11中提供了丰富的线程同步元语,如condition_variable,futrue,std::packaged_task<>,std::promis ...

  6. java并发编程:线程同步和锁

    一.锁的原理 java中每个对象都有一个内置锁.当程序运行到非静态的synchronized同步方法上时,自动获得与正在执行代码类的当前实例(this)有关的锁.获得一个对象的锁也称为获取锁,当程序运 ...

  7. Java多线程学习总结--线程同步(2)

    线程同步是为了让多个线程在共享数据时,保持数据的一致性.举个例子,有两个人同时取钱,假设用户账户余额是1000,第一个用户取钱800,在第一个用户取钱的同时,第二个用户取钱600.银行规定,用户不允许 ...

  8. java并发编程基础——线程同步

    线程同步 一.线程安全问题 如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码.如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安 ...

  9. APUE学习笔记——11 线程同步、互斥锁、自旋锁、条件变量

    线程同步     同属于一个进程的不同线程是共享内存的,因而在执行过程中需要考虑数据的一致性.     假设:进程有一变量i=0,线程A执行i++,线程B执行i++,那么最终i的取值是多少呢?似乎一定 ...

随机推荐

  1. 树链剖分【p2590】[ZJOI2008]树的统计

    Description 一棵树上有n个节点,编号分别为1到n,每个节点都有一个权值w. 我们将以下面的形式来要求你对这棵树完成一些操作: I. CHANGE u t : 把结点u的权值改为t II. ...

  2. Binary Tree Iterative Traversal

    Preorder class Solution { public: vector<int> preorderTraversal(TreeNode* root) { vector<in ...

  3. WPF中的DesignMode判断

    WPF中提供你一个类似WinForm的DesignMode属性的方法来判断当前是否处于设计器模式: bool IsInDesignMode    {        get { return Desig ...

  4. 彻底理解Javascript 中的 Promise(-------------------------------***---------------------------------)

    ES6原生提供了 Promise 对象. 到底是何方妖怪呢?打出来看看: 所谓 Promise,就是一个对象,用来传递异步操作的消息.它代表了某个未来才会知道结果的事件(通常是一个异步操作),并且这个 ...

  5. ubi and ubifs应用手记

    转:http://blog.sina.com.cn/s/blog_5de7d9f80100dpa4.html 1.配置ubi and ubifsin .config  CONFIG_MTD_UBI=y ...

  6. JAVA常见算法题(三)

    package com.xiaowu.demo; //打印出所有的"水仙花数",所谓"水仙花数"是指一个三位数,其各位数字立方和等于该数本身. //例如:153 ...

  7. ubuntu14.04安装 chrome

    安装谷歌浏览器,只需要三行代码: 打开终端,输入 cd /tmp 对于谷歌Chrome32位版本,使用如下链接: wget https://dl.google.com/linux/direct/goo ...

  8. Linux下的权限问题

    刚刚经理给我讲了有关权限的问题,后自己也在网上收集整理了下,特记于此. ---------------------------------------------------------------- ...

  9. ElasticSearch 监控单个节点详解

    1.介绍 集群健康 就像是光谱的一端——对集群的所有信息进行高度概述. 而 节点统计值 API 则是在另一端.它提供一个让人眼花缭乱的统计数据的数组,包含集群的每一个节点统计值. 节点统计值 提供的统 ...

  10. hive删除表报错

    metastore.RetryingHMSHandler: HMSHandler Fatal error: javax.jdo.JDODataStoreException: You have an e ...