c++ 多线程编程 共享数据的保护即互斥量的用法

最新推荐文章于 2022-08-04 15:52:45 发布
最新推荐文章于 2022-08-04 15:52:45 发布
阅读量248 收藏
点赞数
分类专栏： c++多线程编程 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songjinxaing/article/details/103285177
版权

1.互斥量（mutex）的基本概念
保护共享数据，操作时，某个线程用代码把共享数据锁住、然后操作数据、最后解锁；其它想操作共享数据的线程必须等待解锁；

互斥量是个类对象，理解成一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁成功（成功的标志是lock()函数返回）；如果没锁成功，那么这个流程卡在lock(),不断的尝试去锁这把锁头；

互斥量使用要小心，保护数据不多也不能少，少了，没有达到保护的效果，多了，影响效率；

2.互斥量的用法
2.1 lock()、unlock()
步骤：先lock(),操作共享数据，unlock()

lock()与unlock()要成对使用，有lock()必然要有unlock(),每调用一次lock(),必然应该调用一次unlock();不应该也不允许调用一次lock(),却调用了2次unlock()，这些非对称数量的调用都会导致代码不稳定甚至崩溃。实例代码如下：

#include<iostream>
#include<thread>
#include<string>
#include<vector>
#include<list>
#include<mutex>
 
using namespace std;
 
//准备用成员函数作为线程函数的方法写线程
class A
{
public:
	//把收到的消息入到一个队列的线程
	void inMsgRecvQueue() 
	{
		for (int i = 0; i < 10000;i++)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素"<< i<<endl;
			my_mutex.lock();
			msgRecvQueue.push_back(i); //假设这个数字i就是收到的命令，直接弄到消息队列里边来；
			my_mutex.unlock();
		}
	}
 
	bool outMsgLULProc(int &command)
	{
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			int command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素。但不返回；
			my_mutex.unlock();  //所有分支都必须有unlock()
			return true;
		}
		my_mutex.unlock();
		return false;
	}
	//把数据从消息队列取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 10000; i++)
		{
			bool result = outMsgLULProc(command);
 
			if (result  == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素"<< endl;
				//处理数据
			}
			else
			{
				//消息队列为空
				cout << "inMsgRecvQueue()执行，但目前消息队列中为空！" << i << endl;
			}
		}
		cout <<"end!" << endl;
	}
 
private:
	std::list<int> msgRecvQueue;//容器（消息队列），代表玩家发送过来的命令。
	std::mutex my_mutex;
};
 
int main()
{
	A myobja;
 
	std::thread myOutMsgObj(&A::outMsgRecvQueue, &myobja);//第二个参数，引用，才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
 
	myOutMsgObj.join();
	myInMsgObj.join();
 
	cout << "主线程执行！" << endl;
 
	return 0;
}

注：有lock(),忘记unlock()的问题很难排查；

为了防止大家忘记unlock(),引入了一个叫std::lock_guard的类模板：忘记unlock(),替你unlock()。如同智能指针(unique_ptr<>)，你忘记释放内存不要紧，我替你释放。

2.2 std::lock_guard类模板
直接取代lock()与unlock();也就是说，你用了lock_guard之后，再不能使用lock()和unlock()。std::lock_guard类模板的原理很简单，lock_guard构造函数里执行了mutex::lock()；ock_guard析构函数里执行了mutex::unlock()。实例代码如下：

#include<iostream>
#include<thread>
#include<string>
#include<vector>
#include<list>
#include<mutex>
 
using namespace std;
 
//准备用成员函数作为线程函数的方法写线程
class A
{
public:
	//把收到的消息入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
			{  //大括号提前结束lock_guard生命周期
				std::lock_guard<std::mutex> sbguard(my_mutex); 
				//my_mutex.lock();
				msgRecvQueue.push_back(i); //假设这个数字i就是收到的命令，直接弄到消息队列里边来；
				//my_mutex.unlock();
			}
		}
	}
 
	bool outMsgLULProc(int &command)
	{
		std::lock_guard<std::mutex> sbguard(my_mutex);//sbguard时对象名
		//lock_guard构造函数里执行了mutex::lock()
		//lock_guard析构函数里执行了mutex::unlock()
		//my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			int command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素。但不返回；
			//my_mutex.unlock();  //所有分支都必须有unlock()
			return true;
		}
		//my_mutex.unlock();
		return false;
	}
	//把数据从消息队列取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 10000; i++)
		{
			bool result = outMsgLULProc(command);
 
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//处理数据
			}
			else
			{
				//消息队列为空
				cout << "inMsgRecvQueue()执行，但目前消息队列中为空！" << i << endl;
			}
		}
		cout << "end!" << endl;
	}
 
private:
	std::list<int> msgRecvQueue;//容器（消息队列），代表玩家发送过来的命令。
	std::mutex my_mutex;//创建一个互斥量（一把锁）
};
 
int main()
{
	A myobja;
 
	std::thread myOutMsgObj(&A::outMsgRecvQueue, &myobja);//第二个参数，引用，才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
 
	myOutMsgObj.join();
	myInMsgObj.join();
 
	cout << "主线程执行！" << endl;
 
	return 0;
}

2.3 std::lock()函数模板
用来处理多个互斥量的时候才出场

能力：一次锁住两个或者两个以上的互斥量（至少两个，多了不限）；它不存在这种因为多个线程中因为锁的顺序问题导致死锁的风险问题；

std::lock()：如果互斥量中有一个没有锁住，它就在那等着，等所有互斥量都锁住，它才能往下走（返回）；要么两个互斥量都锁柱，要么两个互斥量都没锁住，如果只锁了一个，另外一个没有锁成功，则它立即把已经锁住的解锁。实例代码如下：

#include<iostream>
#include<thread>
#include<string>
#include<vector>
#include<list>
#include<mutex>
 
using namespace std;
 
//准备用成员函数作为线程函数的方法写线程
class A
{
public:
	//把收到的消息入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
 
			std::lock(my_mutex1, my_mutex2);//相当于每个互斥量都调用了.lock()
 
			msgRecvQueue.push_back(i); //假设这个数字i就是收到的命令，直接弄到消息队列里边来；
			my_mutex2.unlock();
			my_mutex1.unlock();
		}
	}
 
	bool outMsgLULProc(int &command)
	{
		std::lock(my_mutex1, my_mutex2);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			int command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素。但不返回；
			my_mutex2.unlock();
			my_mutex1.unlock(); //所有分支都必须有unlock()
			return true;
		}
		my_mutex2.unlock();
		my_mutex1.unlock();
		return false;
	}
	//把数据从消息队列取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 10000; i++)
		{
			bool result = outMsgLULProc(command);
 
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//处理数据
			}
			else
			{
				//消息队列为空
				cout << "inMsgRecvQueue()执行，但目前消息队列中为空！" << i << endl;
			}
		}
		cout << "end!" << endl;
	}
 
private:
	std::list<int> msgRecvQueue;//容器（消息队列），代表玩家发送过来的命令。
	std::mutex my_mutex1;//创建一个互斥量（一把锁）
	std::mutex my_mutex2;//创建一个互斥量
};
 
int main()
{
	A myobja;
 
	std::thread myOutMsgObj(&A::outMsgRecvQueue, &myobja);//第二个参数，引用，才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
 
	myOutMsgObj.join();
	myInMsgObj.join();
 
	cout << "主线程执行！" << endl;
 
	return 0;
}

2.4 std::lock_guard()的std::adopt_lock参数
std::adopt_lock是个结构体对象，起一个标志作用：就是表示这个互斥量已经lock(),不需要在std::lock_guardstd::mutex构造函数里再对mutex对象进行再次lock()了。实例代码如下：

#include<iostream>
#include<thread>
#include<string>
#include<vector>
#include<list>
#include<mutex>
 
using namespace std;
 
//准备用成员函数作为线程函数的方法写线程
class A
{
public:
	//把收到的消息入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
 
			std::lock(my_mutex1, my_mutex2);//相当于每个互斥量都调用了.lock()
 
			std::lock_guard<std::mutex> sbguard1(my_mutex1, std::adopt_lock);
			std::lock_guard<std::mutex> sbguard2(my_mutex2, std::adopt_lock);
 
			msgRecvQueue.push_back(i); //假设这个数字i就是收到的命令，直接弄到消息队列里边来；
 
		}
	}
 
	bool outMsgLULProc(int &command)
	{
		std::lock(my_mutex1, my_mutex2);
 
		std::lock_guard<std::mutex> sbguard1(my_mutex1, std::adopt_lock);
		std::lock_guard<std::mutex> sbguard2(my_mutex2, std::adopt_lock);
 
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			int command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();//移除第一个元素。但不返回；
 
			return true;
		}
 
		return false;
	}
	//把数据从消息队列取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 10000; i++)
		{
			bool result = outMsgLULProc(command);
 
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//处理数据
			}
			else
			{
				//消息队列为空
				cout << "inMsgRecvQueue()执行，但目前消息队列中为空！" << i << endl;
			}
		}
		cout << "end!" << endl;
	}
 
private:
	std::list<int> msgRecvQueue;//容器（消息队列），代表玩家发送过来的命令。
	std::mutex my_mutex1;//创建一个互斥量（一把锁）
	std::mutex my_mutex2;//创建一个互斥量
};
 
int main()
{
	A myobja;
 
	std::thread myOutMsgObj(&A::outMsgRecvQueue, &myobja);//第二个参数，引用，才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
 
	myOutMsgObj.join();
	myInMsgObj.join();
 
	cout << "主线程执行！" << endl;
 
	return 0;
}
倔强的石头。
关注
专栏目录
C++多线程同步之Mutex(互斥量)
~探路者~的博客
11-16 7344
一、互斥量Mutex同步多线程1、Win32平台相关函数和头文件#include <windows.h> HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针 BOOLbInitialOwner, // 初始化互斥对象的所有者 LPCTSTRlpName // 指向互斥对象名的指针 );DWORD WINAP
C++ 多线程的数据保护机制
caimagic的专栏
02-18 3326
C++ 多线程的数据保护机制 　　同许多线程API一样，C++0x用互斥来保护共享数据。有四种互斥类型：Non-recursive (std::mutex) Recursive (std::recursive_mutex) 允许锁超时的non-recursive　(std::timed_mutex) 允许锁超时的recursive (std::recursive_timed_mutex)　　如果你
C++ 互斥量使用
温暖不了你的心的博客
08-04 542
在实际开发中，使用互斥量不当，导致程序出现“device or resource busy: device or resource busy”异常错误。使用mutex进行加锁、解锁时，必须保证lock、unlock成对出现，且每次加锁之后，正常解锁。
C++并发与多线程编程--互斥量用法
locahuang的博客
07-23 194
1、互斥量概念 互斥量是个类对象。 理解成一把锁，多个线程尝试使用lock()成员函数来加锁，只有一个线程能锁定成功。 如果没有锁定成功，那么流程卡在lock()这里不断的尝试去锁住这把锁头。 互斥量使用要小心，保护数据不多也不少，少了，没达到保护的效果，多了，影响效率。 2、互斥量用法 （1）lock()，unlock() lock() 和unlock()要成对使用，有lock()，必然有unlock()。 不应该也不允许调用了一次lock()，却调用多次unlock()。 std::mutex ..
C++——互斥量
yi_chengyu的博客
12-24 2405
文章目录一、基本知识二、独占互斥量mutex1.mutex的介绍2.mutex的成员函数3.实例演示三、lock_guard和unique_lock的使用和区别四、递归互斥量recursive_mutex1.基本知识2.演示示例五、带超时的互斥量std::timed_mutex和std::recursive_timed_mutex 一、基本知识 C++11提供如下4种语义的互斥量（mutex） std::mutex，独占的互斥量，不能递归使用。 std::time_mutex，带超时的独占互斥量，不能递.
C++多线程编程时的数据保护
09-03
总结来说，C++11提供了多种工具来解决多线程编程中的数据保护问题。通过正确使用这些同步原语，我们可以确保数据的一致性和正确性，防止竞争条件和其他并发问题的发生。在编写多线程程序时，理解这些概念以及如何在...
c++多线程编程的十个例子
08-21
以下是对“C++多线程编程的十个例子”的详细讲解，这些例子将帮助你在Windows环境下深入理解和应用多线程。 1. **创建线程** C++11引入了`std::thread`库来创建和管理线程。例如，你可以通过传递函数或成员函数...
C_C++ 多线程编程精髓_专栏.pdf.zip
07-06
《C/C++ 多线程编程精髓》是深入探讨操作系统层面多线程技术的重要资源，主要涵盖以下几个核心知识点： 1. **线程基础**：线程是操作系统分配CPU执行时间的基本单位，它允许一个进程中同时执行多个独立的代码段。在...
C++11多线程编程：数据保护与同步问题
"C++多线程编程中的数据保护与同步机制" 在C++11引入了多线程支持后，开发者可以充分利用多核处理器的计算能力，但同时也引入了一个新的挑战——如何在多线程环境下正确地管理和保护共享数据。在多线程编程中，当多...
C++多线程编程
12-22
C++多线程编程是现代软件开发中不可或缺的一部分，它允许程序同时执行多个任务，从而提高了效率和响应性。在单线程环境中，程序的执行流由main()函数控制，但在多线程环境下，我们可以创建额外的线程，每个线程都有...
vs2013创建多线程教程
10-17
基于vs2013平台，创建多线程的教程，基于vs2013平台，创建多线程的教程，基于vs2013平台，创建多线程的教程
简单进程保护实例两线程相互看护实现
08-15
一个简单的进程保护实例，两线程相互看护实现，程序启动会运行两个线程，当一个线程发现另一个线程不存在时就启动这个进程
互斥量（对数据结构保护）
weixin_38044916的博客
09-01 455
#include<stdio.h> #include<stdlib.h> #include<pthread.h> /* * 当一个以上的线程需要访问动态分配的内存时，可以引入计数变量 */ struct foo { int f_count; pthread_mutex_t f_lock; int f_id; };struct foo* foo_alloc(int id)/
C++11 并发与多线程（五、互斥量概念，用法）
芒种、的博客
06-12 322
一、互斥量的基本概念
在线程间共享数据（保护共享数据）
diyanqu7183的博客
01-12 166
献上一句名言！ If all shared data is read-only, there is no problem, because the data read by one thread is unaffected by whether or not another thread is reading the same data.　　-C++ Concurrency IN AC...
C++11并发与多线程笔记（5）互斥量概念、用法、死锁演示及解决详解
qq_38231713的博客
05-13 6716
第五节 互斥量概念、用法、死锁演示及解决详解 一、互斥量（mutex）的基本概念 互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功，如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。 互斥量使用要小心，保护数据不多也不少，少了达不到效果，多了影响效率。 二、互斥量的用法 包含#include 头文件 2.1 lock()，unlock() 步骤：1.lock()，2.操作共享数据，3.unlock()。 lock()和unlock()
2.1 线程间数据共享与互斥量
CSDN_dzh的博客
03-16 672
文章目录线程间的数据共享互斥量的概念互斥量应用std::lock_guard互斥量的设计准则互斥量的缺点 线程间的数据共享 当在线程间存在数据共享，分为两种情况： 如果共享数据是只读的，一般不会出现什么问题，所有的线程都将获得同样的数据 如果共享数据可写，那么如果某个或多个线程要对该共享数据进行修改，那么通常会出现数据不一致的问题。 这就是在写多线程程序时经常发生的条件竞争现象，简直阔怕...
C++多线程3-共享数据操作保护
m0_37582216的博客
09-24 596
目录： 1.多线程操作共享数据引出的问题 2.解决多线程操作共享数据的方法：锁 3.互斥量mutex的概念和用法 4.lock普通锁的用法 5.lock_guard类模板的用法 6.死锁的概念和解决 7.unique_lock的用法 1.多线程操作共享数据引出的问题 //我们用Test::set函数中作为多线程的回调函数，在这个回调函数中打印vector的size，发现它会出现段错误。 #incl...
在并发例程中保护共享数据
SDNHELIXIN的专栏
09-30 563
 一次一个！在并发例程中保护共享数据       聪明的驱动程序编写人员知道 Windows 可以在任何时候抢占线程，而很有可能驱动程序正要在其中运行高优先级线程。并且在多处理器系统（包括带有超线程 CPU 的系统）上，驱动程序可以同时在多个处理器上并发运行。在任何一种情况下，驱动程序都必须同步对共享的可写数据的访问。但是您确切地知道哪些内核模式驱动程序例程可以被并发调用吗？从而确切地知道
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值