互斥锁和条件变量的性能

介绍

本文以最简单生产者消费者模型，通过运行程序，观察该进程的cpu使用率，来对比使用互斥锁 和 互斥锁+条件变量的性能比较。

本例子的生产者消费者模型，1个生产者，5个消费者。
生产者线程往队列里放入数据，5个消费者线程从队列取数据，取数据前需要判断一下队列中是否有数据，这个队列是全局队列，是线程间共享的数据，所以需要使用互斥锁进行保护。即生产者在往队列里放入数据时，其余消费者不能取，反之亦然。

互斥锁实现的代码

#include <iostream> // std::cout
#include <deque>    // std::deque
#include <thread>   // std::thread
#include <chrono>   // std::chrono
#include <mutex>    // std::mutex// 全局队列
std::deque<int> g_deque;// 全局锁
std::mutex g_mutex;// 生产者运行标记
bool producer_is_running = true;// 生产者线程函数
void Producer()
{// 库存个数int count = 8;do{// 智能锁，初始化后即加锁，保护的范围是代码花括号内，花括号退出即会自动解锁// 可以手动解锁，从而控制互斥锁的细粒度std::unique_lock<std::mutex> locker( g_mutex );// 入队一个数据g_deque.push_front( count );// 提前解锁，缩小互斥锁的细粒度，只针对共享的队列数据进行同步保护locker.unlock(); std::cout << "生产者    ：我现在库存有 :" << count << std::endl;// 放慢生产者生产速度，睡1秒std::this_thread::sleep_for( std::chrono::seconds( 1 ) );// 库存自减少count--;} while( count > 0 );// 标记生产者打样了producer_is_running = false;std::cout << "生产者    ： 我的库存没有了，我要打样了！"  << std::endl;
}// 消费者线程函数
void Consumer(int id)
{int data = 0;do{std::unique_lock<std::mutex> locker( g_mutex );if( !g_deque.empty() ){data = g_deque.back();g_deque.pop_back();locker.unlock();std::cout << "消费者[" << id << "] : 我抢到货的编号是 :" << data << std::endl;}else{locker.unlock();}} while( producer_is_running );std::cout << "消费者[" << id << "] ：卖家没有货打样了，真可惜，下次再来抢！"  << std::endl;
}int main(void)
{std::cout << "1 producer start ..." << std::endl;std::thread producer( Producer );std::cout << "5 consumer start ..." << std::endl;std::thread consumer[ 5 ];for(int i = 0; i < 5; i++){consumer[i] = std::thread(Consumer, i + 1);}producer.join();for(int i = 0; i < 5; i++){consumer[i].join();}std::cout << "All threads joined." << std::endl;return 0;
}

互斥锁实现运行结果：

结果输出

[root@lincoding condition]# g++ -std=c++0x -pthread -D_GLIBCXX_USE_NANOSLEEP main.cpp -o  main
[root@lincoding condition]# ./main
1 producer start ...
5 consumer start ...
生产者    ：我现在库存有 :8
消费者[1] : 我抢到货的编号是 :8
消费者[1] : 我抢到货的编号是 :7
生产者    ：我现在库存有 :7
生产者    ：我现在库存有 :6
消费者[3] : 我抢到货的编号是 :6
生产者    ：我现在库存有 :5
消费者[1] : 我抢到货的编号是 :5
生产者    ：我现在库存有 :4
消费者[2] : 我抢到货的编号是 :4
生产者    ：我现在库存有 :3
消费者[5] : 我抢到货的编号是 :3
生产者    ：我现在库存有 :2
消费者[2] : 我抢到货的编号是 :2
生产者    ：我现在库存有 :1
消费者[1] : 我抢到货的编号是 :1
生产者    ： 我的库存没有了，我要打样了！消费者[
5] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[2] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[3] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[4] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[1] ：卖家没有货打样了，真可惜，下次再来抢！
All threads joined.

可以看到，互斥锁其实可以完成这个任务，但是却存在着性能问题。

Producer是生产者线程，在生产者数据过程中，会休息1秒，所以这个生产过程是很慢的；
Consumer是消费者线程，存在着一个while循环，只有判断到生产者不运行了，才会退出while循环，那么每次在循环体内，都是会先加锁，判断队列不空，然后从列队取出一个数据，最后解锁。所以说，在生产者休息1秒的时候，消费者线程实际上会做很多无用功，导致CPU使用率非常高！

运行的环境是4核cpu

[root@lincoding ~]# grep 'model name' /proc/cpuinfo | wc -l
4

top命令查看cpu使用情况，可见使用纯互斥锁cpu的开销是很大的，main进程的cpu使用率达到了357.5%CPU，系统开销的cpu为54.5%sy，用户开销的cpu为18.2%us

[root@lincoding ~]# top
top - 19:13:41 up 36 min,  3 users,  load average: 0.06, 0.05, 0.01
Tasks: 179 total,   1 running, 178 sleeping,   0 stopped,   0 zombie
Cpu(s): 18.2%us, 54.5%sy,  0.0%ni, 27.3%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:   1004412k total,   313492k used,   690920k free,    41424k buffers
Swap:  2031608k total,        0k used,  2031608k free,    79968k cached

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
35346 root 20 0 137m 3288 1024 S 357.5 0.3 0:05.92 main
1 root 20 0 19232 1492 1224 S 0.0 0.1 0:02.16 init
2 root 20 0 0 0 0 S 0.0 0.0 0:00.01 kthreadd
3 root RT 0 0 0 0 S 0.0 0.0 0:00.68 migration/0

解决的办法之一就是给消费者也加一个小延时，当消费者没取到数据时，就休息一下500毫秒，这样可以减少互斥锁给cpu带来的开销。

// 消费者线程函数
void Consumer(int id)
{int data = 0;do{std::unique_lock<std::mutex> locker( g_mutex );if( !g_deque.empty() ){data = g_deque.back();g_deque.pop_back();locker.unlock();std::cout << "消费者[" << id << "] : 我抢到货的编号是 :" << data << std::endl;}else{locker.unlock();// 当消费者没取到数据时，就休息一下500毫秒std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) );}} while( producer_is_running );std::cout << "消费者[" << id << "] ：卖家没有货打样了，真可惜，下次再来抢！"  << std::endl;
}

从运行结果可知，cpu使用率大大降低了

[root@lincoding ~]# ps aux | grep -v grep  |grep main
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      61296  0.0  0.1 141068  1244 pts/1    Sl+  19:40   0:00

条件变量+互斥锁实现的代码
那么问题来了，如何确定消费者延时（休息）多久呢？

如果生产者生产的非常快，消费者却延时了500毫秒，也不是很好
如果生产者生产的更慢，那么消费延时500毫秒，也会有无用功，占用了CPU
这就需要引入条件变量std::condition_variable，应用于消费者生产模型中，就是生产者生产完一个数据后，通过notify_one()唤醒正在wait()消费者线程，使得消费者从队列取出一个数据。

#include <iostream> // std::cout
#include <deque>    // std::deque
#include <thread>   // std::thread
#include <chrono>   // std::chrono
#include <mutex>    // std::mutex#include <condition_variable> // std::condition_variable// 全局队列
std::deque<int> g_deque;// 全局锁
std::mutex g_mutex;// 全局条件变量
std::condition_variable g_cond;// 生产者运行标记
bool producer_is_running = true;// 生产者线程函数
void Producer()
{// 库存个数int count = 8;do{// 智能锁，初始化后即加锁，保护的范围是代码花括号内，花括号退出即会自动解锁// 可以手动解锁，从而控制互斥锁的细粒度std::unique_lock<std::mutex> locker( g_mutex );// 入队一个数据g_deque.push_front( count );// 提前解锁，缩小互斥锁的细粒度，只针对共享的队列数据进行同步保护locker.unlock(); std::cout << "生产者    ：我现在库存有 :" << count << std::endl;// 唤醒一个线程g_cond.notify_one();// 睡1秒std::this_thread::sleep_for( std::chrono::seconds( 1 ) );// 库存自减少count--;} while( count > 0 );// 标记生产者打样了producer_is_running = false;// 唤醒所有消费线程g_cond.notify_all();std::cout << "生产者    ： 我的库存没有了，我要打样了！"  << std::endl;
}// 消费者线程函数
void Consumer(int id)
{// 购买的货品编号int data = 0;do{// 智能锁，初始化后即加锁，保护的范围是代码花括号内，花括号退出即会自动解锁// 可以手动解锁，从而控制互斥锁的细粒度std::unique_lock<std::mutex> locker( g_mutex );// wait()函数会先调用互斥锁的unlock()函数，然后再将自己睡眠，在被唤醒后，又会继续持有锁，保护后面的队列操作// 必须使用unique_lock，不能使用lock_guard，因为lock_guard没有lock和unlock接口，而unique_lock则都提供了g_cond.wait(locker); // 队列不为空if( !g_deque.empty() ){// 取出队列里最后一个数据data = g_deque.back();// 删除队列里最后一个数据g_deque.pop_back();// 提前解锁，缩小互斥锁的细粒度，只针对共享的队列数据进行同步保护locker.unlock(); std::cout << "消费者[" << id << "] : 我抢到货的编号是 :" << data << std::endl;}// 队列为空else{locker.unlock();}} while( producer_is_running );std::cout << "消费者[" << id << "] ：卖家没有货打样了，真可惜，下次再来抢！"  << std::endl;
}int main(void)
{std::cout << "1 producer start ..." << std::endl;std::thread producer( Producer );std::cout << "5 consumer start ..." << std::endl;std::thread consumer[ 5 ];for(int i = 0; i < 5; i++){consumer[i] = std::thread(Consumer, i + 1);}producer.join();for(int i = 0; i < 5; i++){consumer[i].join();}std::cout << "All threads joined." << std::endl;return 0;
}

条件变量+互斥锁运行结果

[root@lincoding condition]# g++ -std=c++0x -pthread -D_GLIBCXX_USE_NANOSLEEP main.cpp -o  main
[root@lincoding condition]# 
[root@lincoding condition]# ./main 
1 producer start ...
5 consumer start ...
生产者    ：我现在库存有 :8
消费者[4] : 我抢到货的编号是 :8
生产者    ：我现在库存有 :7
消费者[2] : 我抢到货的编号是 :7
生产者    ：我现在库存有 :6
消费者[3] : 我抢到货的编号是 :6
生产者    ：我现在库存有 :5
消费者[5] : 我抢到货的编号是 :5
生产者    ：我现在库存有 :4
消费者[1] : 我抢到货的编号是 :4
生产者    ：我现在库存有 :3
消费者[4] : 我抢到货的编号是 :3
生产者    ：我现在库存有 :2
消费者[2] : 我抢到货的编号是 :2
生产者    ：我现在库存有 :1
消费者[3] : 我抢到货的编号是 :1
生产者    ： 我的库存没有了，我要打样了！
消费者[5] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[1] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[4] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[2] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[3] ：卖家没有货打样了，真可惜，下次再来抢！
All threads joined.

CPU开销非常的小

[root@lincoding ~]# ps aux | grep -v grep  |grep main
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      73838  0.0  0.1 141068  1256 pts/1    Sl+  19:54   0:00 ./main

总结

在不确定生产者的生产速度是快还是慢的场景里，不能只使用互斥锁保护共享的数据，这样会对CPU的性能开销非常大，可以使用互斥锁+条件变量的方式，当生产者线程生产了一个数据，就唤醒消费者线程进行消费，避免一些无用功的性能开销。

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

ERROR in static/js/0.6355f688e1657030acc6.js from UglifyJs Unexpected token: punc (() [./~/time-form
ERROR in static/js/0.6355f688e1657030acc6.js from UglifyJs Unexpected token: punc (() [./~/time-formater/lib/timeformater.js:21,0][static/js/0.6355f688e1657030acc6.js:41766,10]解决办法：...
2024/4/7 20:33:03
238、商城业务-购物车-VO编写
/*** 整个购物车* 需要计算的属性，必须重写他的get方法，保证每次获取属性都会进行计算*/ public class Cart {List<CartItem> items;private Integer countNum;//商品数量private Integer countType;//商品类型数量private BigDecimal totalAmount…...
2024/4/7 20:26:02
如何批量保存米拍摄影上的热门标签相册里的图片
大家都知道米拍，是一个当前各界摄影爱好者相互交流相当热门的平台，这里聚集着各界名流摄影大师和爱好者，他们在此相互学习和展示自己大量的精彩作品。那么那些热门标签页相册里的图片该怎样批量把它保存到自己的电脑上呢？下面一起…...
2024/4/7 6:45:28
什么样的对象能当根节点 GC roots？
Java通过可达性分析来判断对象是否存活。基本思想是通过一系列称为“GC roots”的对象作为起始点，可以作为根节点的是： 1、虚拟机栈（栈帧中的本地变量表）中引用的对象 2、本地方法栈中JNI（即一般说的Native方法&…...
2024/4/7 16:29:31
springBoot-tk.mybatis.mapper.MapperException: java.lang.StringIndexOutOfBoundsException: String inde
springBoot-tk.mybatis.mapper.MapperException: java.lang.StringIndexOutOfBoundsException: String index out of range:-1 在启动springBoot项目时报：java.lang.StringIndexOutOfBoundsException: String index out of range:-1 上网查了一下相关文章&#xff…...
2024/4/7 17:24:51
ToLuaFrame-架构图
...
2024/4/7 6:52:26
＜noscript＞元素
浏览器显示<noscript>中的内容的两种情况： （1）在浏览器不支持脚本 （2）浏览器支持脚本，但被脚本禁用的时候符合其中任何一个条件，，浏览器都会显示<noscript>中的内容。…...
2024/4/7 11:33:39
基于大幅遥感图像的目标检测预测过程（划框）
前言在遥感影像场景中，我们所面对的数据的尺寸大多都是成千上万像素的，这大大超出了目前显卡所能承受的范围。因此这篇博文将简单介绍下如何在大幅遥感影像中进行目标检测。划框预测简单描述下预测的过程： 设置划框的大小a&#xff0…...
2024/4/7 14:44:41
报错：No module named ‘torch_scatter.scatter_cuda‘ 适用gpu版的pytorch环境的torch_geometric安装
2020/9/16 安装安装目的：跑CGC-Net(FATURE_EXTRACT) 报错：No module named torch_scatter.scatter_cuda 参考：https://www.cnblogs.com/yqpy/p/13498200.html 参考：https://zhuanlan.zhihu.com/p/138826540 参考：h…...
2024/4/16 4:37:21
剑指offer66题python实现 25-31
目录A. 知识点：------- 二叉树25.重建二叉树26.树的子结构27.二叉树的镜像28.从上往下打印二叉树29.二叉搜索树的后序遍历序列30.二叉树中和为某一值的路径31.二叉搜索树与双向链表A. 知识点：------- 二叉树什么叫做树？树状图是一种数据结构…...
2024/4/8 0:28:10
mysql自定义变量，自定义变量显示行号、简化查询、赋值
前言有时我们需要导出成绩单，并按分数由高到底进行排序，并展示排名，这里就需要自定义变量，如图所示： 有时我们在数据库中通过好几张表查找数据时，每张表的信息都要展示出来，这样就需要一个共有…...
2024/4/7 23:29:38
记录一下NW-ZX1折腾过程
问题背景解决方法总结阅读之前注意： 本文阅读建议用时：10min 本文阅读结构如下表： 项目下属项目测试用例数量问题背景无0解决方法无0总结无0 问题背景需求非常简单，一款挺早的音乐播放器——索尼NW-ZX1，其自带的音…...
2024/4/10 16:07:29
(JavaScript学习记录)：作用域
写在前面：参考哔哩哔哩黑马程序员pink老师教程地址：https://www.bilibili.com/video/BV1Sy4y1C7ha?t41&p4目录作用域作用域概述全局作用域局部作用域 （函数作用域） JS 没有块级作用域变量的作用域变量作用域的分类全…...
2024/4/7 22:23:13
Python编程：从入门到实践第六章练习6.3
Python编程：从入门到实践第六章练习6.3 #coding:gbk#6-4词汇表2 #参照6.3练习.py#6-5河流 rivers {nile: egypt,yellow river: china,amazon river: brazil,} for river,country in rivers.items():print("The " river.title() " runs through &q…...
2024/4/1 16:01:33
hdu-------2028
Lowest Common Multiple Plus Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 101684 Accepted Submission(s): 42166 Problem Description 求n个数的最小公倍数。 Input 输入包含多个测试实例，每个测试…...
2024/4/17 14:14:40
Java基础之循环控制语句
for 与 foreach for 语句是一种在程序执行前就要先判断条件表达式是否为真的循环语句。 public static void main(String[] args) {/*建议在循环外先定义变量，尤其是变量为比较复杂的对象，在一定程度上可以节约资源、提高效率*/int i ; for (i 0; i …...
2024/4/9 23:29:13
解决：‘webpack-dev-server‘ 不是内部或外部命令，也不是可运行的程序或批处理文件。
最近在做项目的时候，使用webpack-dev-server时遇到一些问题（如下图所示），输入npm run dev之后，会出现以下错误我在学习vue框架的时候因为要使用到webpack工具，但这个工具又是基于node，而我对…...
2024/4/9 5:54:08
Python|使用腾讯云函数功能解决每日打卡、答题等问题
1、登陆腾讯云地址：https://cloud.tencent.com 新用户需要注册，并实名认证 2、进入腾讯云控制台，搜索云函数，进入云函数功能模块 3、进入函数服务，新建函数，此处新建一个python3.6环境的空白helloword函…...
2024/4/12 23:56:03
ansible--描述角色结构
描述角色结构 1.利用角色构造ansible playbook 角色(roles)是指某一段写好的通用的playbook代码。通用简单角色：所有的角色，不管在哪里做都是一样的，不会发生改变。不通用的用户数据、项目数据、业务数据，是针对不同用户&…...
2024/4/9 20:15:42
缓存中间件-redis的RDB持久化细节
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。 RDB持久化可以通过调用两个方法实现：save和bgsave； 调用save方法生成rdb文件时，使用的是主进程，所以在rdb文件生成…...
2024/4/9 17:57:33

互斥锁和条件变量的性能

介绍

互斥锁实现的代码

互斥锁实现运行结果：

条件变量+互斥锁运行结果

总结

相关文章

最新文章