浅谈c++11线程的互斥量
更新时间：2021年06月08日 15:22:52 作者：lsgxeva
互斥量是个类对象，理解成一把锁（保护共享数据，其他想操作共享数据的线程必须等待解锁），互斥量使用要小心，保护数据不多也不少，少了则没达到保护效果，多了则影响效率。本文将介绍c++11线程的互斥量，感兴趣的同学，可以参考下。
为什么需要互斥量
在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
// 打印机
void printer(const char *str)
{
while(*str != '\0')
{
std::cout << *str;
str++;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
std::cout << std::endl;
}
// 线程一
void func1()
{
const char *str = "hello";
printer(str);
}
// 线程二
void func2()
{
const char *str = "world";
printer(str);
}
void mytest()
{
std::thread t1(func1);
std::thread t2(func2);
t1.join();
t2.join();
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
独占互斥量std::mutex
互斥量的基本接口很相似，一般用法是通过lock()方法来阻塞线程，直到获得互斥量的所有权为止。在线程获得互斥量并完成任务之后，就必须使用unlock()来解除对互斥量的占用，lock()和unlock()必须成对出现。try_lock()尝试锁定互斥量，如果成功则返回true, 如果失败则返回false，它是非阻塞的。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <mutex>
std::mutex g_lock; //全局互斥锁对象，#include <mutex>
// 打印机
void printer(const char *str)
{
g_lock.lock(); //上锁
while(*str != '\0')
{
std::cout << *str;
str++;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
std::cout << std::endl;
g_lock.unlock(); // 解锁
}
// 线程一
void func1()
{
const char *str = "hello";
printer(str);
}
// 线程二
void func2()
{
const char *str = "world";
printer(str);
}
void mytest()
{
std::thread t1(func1);
std::thread t2(func2);
t1.join();
t2.join();
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
使用std::lock_guard可以简化lock/unlock的写法，同时也更安全，因为lock_guard在构造时会自动锁定互斥量，而在退出作用域后进行析构时就会自动解锁，从而避免忘了unlock操作。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <mutex>
std::mutex g_lock; //全局互斥锁对象，#include <mutex>
// 打印机
void printer(const char *str)
{
std::lock_guard<std::mutex> locker(g_lock); // lock_guard 上锁
while(*str != '\0')
{
std::cout << *str;
str++;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
std::cout << std::endl;
// 即将推出作用域 lock_guard 会自动解锁
}
// 线程一
void func1()
{
const char *str = "hello";
printer(str);
}
// 线程二
void func2()
{
const char *str = "world";
printer(str);
}
void mytest()
{
std::thread t1(func1);
std::thread t2(func2);
t1.join();
t2.join();
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
原子操作
所谓的原子操作，取的就是“原子是最小的、不可分割的最小个体”的意义，它表示在多个线程访问同一个全局资源的时候，能够确保所有其他的线程都不在同一时间内访问相同的资源。也就是他确保了在同一时刻只有唯一的线程对这个资源进行访问。这有点类似互斥对象对共享资源的访问的保护，但是原子操作更加接近底层，因而效率更高。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
//全局的结果数据
long total = 0;
//点击函数
void func()
{
for(int i = 0; i < 1000000; ++i)
{
// 对全局数据进行无锁访问
total += 1;
}
}
void mytest()
{
clock_t start = clock(); // 计时开始
//线程
std::thread t1(func);
std::thread t2(func);
t1.join();
t2.join();
clock_t end = clock(); // 计时结束
std::cout << "total = " << total << std::endl;
std::cout << "time = " << end-start << " ms" << std::endl;
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
由于线程间对数据的竞争而导致每次运行的结果都不一样。因此，为了防止数据竞争问题，我们需要对total进行原子操作。
通过互斥锁进行原子操作：
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <mutex>
std::mutex g_lock;
//全局的结果数据
long total = 0;
//点击函数
void func()
{
for(int i = 0; i < 1000000; ++i)
{
g_lock.lock(); // 加锁
total += 1;
g_lock.unlock(); // 加锁
}
}
void mytest()
{
clock_t start = clock(); // 计时开始
//线程
std::thread t1(func);
std::thread t2(func);
t1.join();
t2.join();
clock_t end = clock(); // 计时结束
std::cout << "total = " << total << std::endl;
std::cout << "time = " << end-start << " ms" << std::endl;
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
每次运行的结果都一样，只是耗时长点。
在新标准C++11，引入了原子操作的概念。
如果我们在多个线程中对这些类型的共享资源进行操作，编译器将保证这些操作都是原子性的，也就是说，确保任意时刻只有一个线程对这个资源进行访问，编译器将保证多个线程访问这个共享资源的正确性。从而避免了锁的使用，提高了效率。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <atomic>
//原子数据类型
std::atomic<long> total(0); //需要头文件 #include <atomic>
//点击函数
void func()
{
for(int i = 0; i < 1000000; ++i)
{
//
total += 1;
}
}
void mytest()
{
clock_t start = clock(); // 计时开始
//线程
std::thread t1(func);
std::thread t2(func);
t1.join();
t2.join();
clock_t end = clock(); // 计时结束
std::cout << "total = " << total << std::endl;
std::cout << "time = " << end-start << " ms" << std::endl;
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
原子操作的实现跟普通数据类型类似，但是它能够在保证结果正确的前提下，提供比mutex等锁机制更好的性能。
以上就是浅谈c++11线程的互斥量的详细内容，更多关于c++11线程的互斥量的资料请关注脚本之家其它相关文章！
您可能感兴趣的文章:
相关文章
这篇文章主要为大家详细介绍了C语言实现学生消费管理系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-08-08
下面小编就为大家带来一篇C++ 简单的任务队列详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧2016-12-12
本文主要介绍了通过C++解决合并两个排序的链表并使新链表中的节点仍然是递增排序的。文中代码讲解详细，有需要的朋友可以参考一下2021-12-12
这篇文章主要介绍了使用Clion刷LeetCode的方法,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2021-02-02
很多的问题其实可以用编程来解决作答，本篇文章带你用C语言解决最少硬币问题、计算已经过去了多久、学生成绩自动打分来做基础的训练2022-02-02
这篇文章主要介绍了关于vector的常见用法详解,vector本身可以作为数组使用，而且在一些元素个数不确定的场合可以很好地节省空间，本文给大家介绍的非常详细，需要的朋友可以参考下2023-02-02
一般情况下，由键盘输入的字符并没有直接送入程序，而是被存储在一个缓冲区当中。下面这篇文章主要给大家介绍了关于C语言中输入输出流与缓冲区的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下2018-09-09
这篇文章主要介绍了c++ 让程序开机自动启动的方法,需要的朋友可以参考下2017-09-09
所谓高斯噪声是指它的概率密度函数服从高斯分布(即正态分布)的一类噪声,这篇文章主要给大家介绍了关于C++实现点云添加高斯噪声功能的相关资料,需要的朋友可以参考下2021-07-07
下面小编就为大家带来一篇c++ 快速排序算法【过程图解】。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-05-05
最新评论