C++并发与多线程(5)-互斥锁

最新推荐文章于 2024-05-04 10:55:17 发布
最新推荐文章于 2024-05-04 10:55:17 发布
阅读量425 收藏 2
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44314245/article/details/111662564
版权

文章目录

互斥量概念、用法、死锁演示及解决详解

1、互斥量(mutex)的基本概念

概念：

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

注意：互斥量使用要小心，保护数据不能多也不能少，少了，没达到保护效果，多了，影响效率。

2、互斥量用法

步骤：

先lock()加锁，再操作共享数据，最后别忘记unlock()解锁

lock()和unlock()要成对使用，有一次lock()必然要有一次unlock()；
不允许也不应该对lock()和unlock()进行非对称数量的调用，否者导致程序不稳定甚至崩溃。

互斥锁的创建：

std::mutex my_mutex;

案例：

#include <iostream>
#include<thread>
#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();
			// 假设这个数字i就是我收到的命令，我直接弄到消息队列中来；
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		my_mutex.lock();
		// 消息不为空
		if (!msgRecvQueue.empty())
		{
			// 返回第一个元素，但不检查元素是否存在；
			int command = msgRecvQueue.front();
			// 移除第一个元素，但不返回；
			msgRecvQueue.pop_front();
			// if (true)对应一个解锁
			my_mutex.unlock(); 
			return true;
		}
		// if(false)对应一个解锁
		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()执行，取出一个元素" << command << endl;
				//可以考虑数据的处理了……
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}

private:
	std::list<int>msgRecvQueue;//共享数据 容器（消息队列），专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex;//创建了一个互斥量

};
int main(int argc, char* argv[])
{

	A myobja;
	thread myOutMsgObj(&A::outMsgRecvQueue, ref(myobja));//第二个参数是引用，才能保证线程里用的是用一个对象
	thread myInMsgObj(&A::inMsgRecvQueue, ref(myobja));

	myOutMsgObj.join();
	myInMsgObj.join();

	return 0;
}

注意：如果在使用lock()时，程序中存在 if…else、异常处理等情况，必须在每个分支出口处，使用unlock()解锁。

3、std::lock_guard()类模板

上述情况在，可能偶尔忘记unlock()，这就引入了lock_guard()的类模板。也就是说即使忘记使用unlock()，系统也直接调用unlock()。

lock_guard()可以直接取代lock()、unlock()，用了lock_guard()之后，就不能再调用lock()、unlock()，其封装原理：

1、lock_guard()构造函数里执行了mutex::lock()函数；
2、析构函数里执行了mutex::unlock()函数。

#include <iostream>
#include<thread>
#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();
			// 假设这个数字i就是我收到的命令，我直接弄到消息队列中来；
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		// 模板
		std::lock_guard<std::mutex> mutexGuard(my_mutex); 
		// 消息不为空
		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()执行，取出一个元素" << command << endl;
				//可以考虑数据的处理了……
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}

private:
	std::list<int>msgRecvQueue;//容器（消息队列），专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex;//创建了一个互斥量

};
int main(int argc, char* argv[])
{

	A myobja;
	thread myOutMsgObj(&A::outMsgRecvQueue, ref(myobja));//第二个参数是引用，才能保证线程里用的是用一个对象
	thread myInMsgObj(&A::inMsgRecvQueue, ref(myobja));

	myOutMsgObj.join();
	myInMsgObj.join();

	return 0;
}

但是，使用lock_guard()只在某个函数结束也就是return时才执行析构，但是这个函数中还有其它代码，也锁住吗？显然这样做不够灵活，所以这里提出一个小技巧，在要进行添加互斥量的代码上使用大括号 {…} 进行作用域限制：

        for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
			{
				std::lock_guard<std::mutex> mutexGuard1(my_mutex);
				//my_mutex.lock();
				// 假设这个数字i就是我收到的命令，我直接弄到消息队列中来；
				msgRecvQueue.push_back(i);
				//my_mutex.unlock();
			}
			// 。。。
			// 其他代码
			
		}

这样，互斥量只作用于{…}中的代码，也就是msgRecvQueue这块内存了。

4、死锁

4.1、死锁现象

死锁现象：C++中，假设有两把锁（死锁产生的前提条件是有至少两把锁头，即两个互斥量）金锁（JinLock）、银锁（YinLock）假设有两个线程A,B。

1、线程A执行的时候，这个线程先锁金锁，把金锁Lock()成功了，然后他去尝试lock银锁；
2、此时，却去进行另外一个线程（切线程）；
3、线程B执行了，这个线程先锁银锁，因为银锁还没有被锁，所以银锁会被lock成功，然后线程B要去lock金锁；
4、这时死锁现象产生了：线程A由于拿不到银锁，流程走不下去（虽然后边代码有解锁金锁的但是流程走不下去，所以金锁解不开）；线程B由于拿不到金锁，流程走不下去（虽然后边代码有解锁银锁的但是流程走不下去，所以银锁解不开）。

#include <iostream>
#include<thread>
#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_mutex1.lock();//实际工程中这两个锁头代码不一定挨着，可能她们需要保护不同的数据共享块
			my_mutex2.lock();

			msgRecvQueue.push_back(i);//假设这个数字i就是我收到的命令，我直接弄到消息队列中来；
			
			my_mutex2.unlock();
			my_mutex1.unlock();

		}
		return;
	}
	
	bool outMsgLULProc(int &command)
	{	
		//std::lock_guard<std::mutex>sbguard(my_mutex1);//sbguard时随便起的对象名
		my_mutex2.lock();
		my_mutex1.lock();
		if (!msgRecvQueue.empty())
		{
			int command = msgRecvQueue.front();//返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();//移除第一个元素，但不返回；
			my_mutex1.unlock();
			my_mutex2.unlock();

			return true;
		}
		my_mutex1.unlock();
		my_mutex2.unlock();

		return false;
	}
	//把数据从消息队列中取出的线程：
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 10000; ++i)
		{
			bool result = outMsgLULProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
			//可以考虑数据的处理了……
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	std::list<int>msgRecvQueue;//容器（消息队列），专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了另外一个互斥量

};
int main(int argc, char* argv[])
{

	A myobja;
	thread myOutMsgObj(&A::outMsgRecvQueue, ref(myobja));
	thread myInMsgObj(&A::inMsgRecvQueue, ref(myobja));

	myOutMsgObj.join();
	myInMsgObj.join();
	
	return 0;
}

4.2、死锁的解决方案

只要保证这两个互斥量上锁的顺序一致就不会造成死锁。
在这里插入图片描述

5、std::lock()函数模板

一次同时锁住两个或者是两个以上的互斥量（至少两个，多了不限），它不存在这种因为在多个线程中因为上锁顺序问题导致的死锁风险的问题。主要是处理多个互斥量。
实现原理：

1、如果互斥量中有一个没锁住，它就在那等着，等所有互斥量都锁住，他才能往下走；
2、要么两个互斥量同时锁住，要么两个互斥量都没锁住。一旦有一个没锁住，std::lock()将立即把已经锁住的互斥量释放（解锁），等待两个同时可以锁住的时机。

	void inMsgRecvQueue()
	{
		for (int i = 0; i < 10000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
            // 相当于每个互斥量都调用了lock()
			std::lock(my_mutex1, my_mutex2);
			msgRecvQueue.push_back(i);

			my_mutex2.unlock();
			my_mutex1.unlock();

		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		// 相当于每个互斥量都调用了lock()
		std::lock(my_mutex1, my_mutex2);
		if (!msgRecvQueue.empty())
		{
			int command = msgRecvQueue.front();
			msgRecvQueue.pop_front();
			my_mutex2.unlock();
			my_mutex1.unlock();
			return true;
		}
		my_mutex2.unlock();
		my_mutex1.unlock();
		return false;
	}

有点遗憾的地方在于还需要使用ublock()解锁。

6、std::lock_guard引入std:adopt_lock参数

使用std::lock_guard解决std::lock()还需要unlock()问题：

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);//sbguard1时随便起的对象名
			std::lock_guard<std::mutex>sbguard2(my_mutex2,std::adopt_lock);//sbguard2时随便起的对象名

			msgRecvQueue.push_back(i);//假设这个数字i就是我收到的命令，我直接弄到消息队列中来；
		}
		return;

在使用std::lock(my_mutex1, my_mutex2)时已经对锁my_mutex1, my_mutex2已经进行了lock()，那么lock_guard时就不需要再lock()了，怎么办呢？引入std:adopt_lock即可。std:adopt_lock是个结构体对象，起一个标记作用，即标记这个互斥量已经lock()了。

std::lock_guard<std::mutex>sbguard1(my_mutex1,std::adopt_lock);

那么，后续就可以利用std::lock_guard对互斥量进行自动析构了。

总结：std::lock()一次锁多个互斥量；谨慎使用（建议一个一个的锁）。

__铭天
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++多线程（5）之unique_lock的使用
请叫我少爷的博客
09-24 1163
unique_lock是一个类模板，下面简单介绍它的使用方式。 如果只用一个参数，unique_lock与lock_gard的使用方法一样： 可以参考我的这篇博客：https://blog.csdn.net/shaochuang1/article/details/100991407 代码： #include <iostream> #include <thread>...
C++并发与多线程(10) | 死锁
deep_love1314的博客
10-30 180
只有两个互斥量才会产生死锁问题。举个例子：两个锁——金锁，银锁和两个线程A，B（1）A执行时，这个线程先锁金锁，把金锁Lock()成功了，然后它去lock银锁。出现了上下文切换（2）B执行了，这个线程先锁银锁，因为银锁还没有被锁，所以银锁lock()成功了，B然后就去lock金锁。这个A因为拿不到银锁头，流程走不下去,是不是意思是因为银锁被B锁定了，所以这个A里面去lock银锁的代码运行不下去，被卡着不动！在这个情况下，线程 A 因为无法获得银锁而被阻塞，因为银锁已经被线程 B 锁定了。
C++多线程：互斥锁
热门推荐
HerofH_的博客
03-10 3万+
目录 1.前言 2.互斥锁 2.1 互斥锁的特点 2.2 互斥锁的使用 2.2 std::lock_guard 3.死锁 3.1 死锁的含义 3.2 死锁的例子 3.3 死锁的解决方法 1.前言 比如说我们现在以一个list容器来模仿一个消息队列，当消息来临时插入list的尾部，当读取消息时就把头部的消息读出来并且删除这条消息。在代码中就以两个线程分别实现消息写...
【C++】互斥锁（mutex）
最新发布
Hi, Boy
05-04 541
通过学习和掌握 C++ 中的互斥锁（mutex），可以更好地保护共享资源，确保多线程程序的正确性和稳定性。
C++多线程--互斥锁
qq_34552942的博客
08-30 6216
创建线程 创建两个线程 thread一旦被创建出来就开始运行，它的执行动作就是我们调用的函数、对象等所编写的代码。
【C++入门到精通】互斥锁 (Mutex) C++11 [ C++入门 ]
Yawesh的博客
12-22 7427
本文介绍了四种C++中常用的互斥锁类型，这些互斥锁类型用于控制多线程对共享资源的访问，避免数据竞争和不确定行为的发生。其中，std::mutex是最基本的互斥锁类型，std::recursive_mutex是可递归的互斥锁类型，std::timed_mutex是限时等待互斥锁类型，std::recursive_timed_mutex是限时等待递归互斥锁类型。使用互斥锁时需注意正确的加锁和解锁操作，选择合适的互斥锁类型应根据具体需求和场景来进行。通过合理使用互斥锁，可以提高多线程程序的性能和并发能力。
C++ 线程同步之互斥锁
喜欢打篮球的普通人
06-19 5936
进行多线程编程，如果多个线程需要对同一块内存进行操作，比如：同时读、同时写、同时读写，对于后两种情况来说，如果不做任何的人为干涉就会出现各种各样的错误数据。解决多线程数据混乱的方案就是进行线程同步，最常用的就是互斥锁，在 C++11 中一共提供了四种互斥锁：不论是在 C 还是 C++ 中，进行线程同步的处理流程基本上是一致的，C++ 的 mutex 类提供了相关的 API 函数：成员函数 独占互斥锁对象有两种状态：锁定和未锁定。 除了使用 lock() 还可以使用 try_lock() 获取互斥锁
C++ 并发多线程日志处理
02-28
在C++编程中，多线程日志处理是一项重要的任务，尤其在高并发环境中，能够有效地记录、管理和分析系统运行时的信息。C++11引入了标准库中的`<thread>`，使得多线程编程变得更加方便，同时也为日志处理带来了新的挑战...
yolov5目标检测多线程C++部署
08-12
** yolov5目标检测多线程C++部署详解** 在计算机视觉领域，目标检测是一项关键技术，用于识别图像或视频帧中的特定对象。YOLO（You Only Look Once）是一种高效的目标检测算法，以其实时性能和相对较高的准确性而...
C++11 并发指南之多线程初探
12-20
C++11是C++语言的一个重要里程碑，它引入了许多新特性，特别是在并发编程领域，大大提升了C++作为多线程编程语言的能力。本篇文章将深入探讨C++11中的多线程支持。 在C++11之前，开发人员通常依赖于如POSIX的...
Linux c++多线程串口编程demo
01-26
3. **互斥锁（Mutex）**：在多线程环境中，互斥锁用于保护共享资源，确保同一时间只有一个线程可以访问。`std::mutex`类提供了互斥锁的功能，可以防止数据竞争，确保数据的一致性和完整性。在这个demo中，可能使用...
C++11新特性——互斥锁、条件变量、原子类型
m0_67168421的博客
12-13 2181
C++
C++多线程之互斥锁
forget_1111的博客
05-05 1714
C++多线程之互斥锁介绍
C++ 互斥锁原理以及实际使用介绍
Bobowen的博客
04-22 3002
今天带来实际开发中都需要使用的互斥锁的内容，主要聊一聊如何使用互斥锁以及都有哪几种方式实现互斥锁。实现互斥，可以有以下几种方式：互斥量（Mutex）、递归互斥量（Recursive Mutex）、读写锁（Read-Write Lock）、条件变量（Condition Variable）。 互斥锁保证了计算机资源访问的安全，互斥锁的不当使用同时也加大了程序阻塞的风险。提前祝大家五一前工作生活学习一切顺利。
C++多线程编程(一)：互斥锁
追寻梦想的青春
01-15 1726
在现代程序开发中，会大量使用多线程机制，很多语言都内置了对多线程的支持，而C++直到C++11才提供了对多线程的支持，既然支持多线程，那么一定也提供了锁的支持。为什么多线程就一定用锁呢？因为当程序以多线程运行时，如果有对共享资源的使用，例如，两个线程同时对共享变量进行修改，由于这些操作不是原子操作，就会导致出现异常情况，修改的两个线程都认为操作成功了，但是实际上只有一个成功了。这时就需要锁去保证两个操作都分别执行完成。因此，使用锁就需要搞清楚要保护的共享资源。
C++11 互斥锁
kakaka666的博客
11-18 5358
C++11 互斥锁
Linux多线程编程三（互斥锁）
weixin_33882443的博客
04-16 148
2019独角兽企业重金招聘Python工程师标准>>> ...
互斥锁的含义及其使用
qq_40115163的博客
05-24 2945
一 互斥锁的含义 互斥锁其实就相当于一个初值为1的二元信号量，互斥锁只有两种状态，要么解锁，要么上锁。互斥锁一般用于保护关键代码，从而实现互斥访问。 二 互斥锁的使用 互斥锁相关函数在pthread.h头文件中声明。 2.1 互斥锁的创建 int pthread_mutex_init(pthread_mutex_t*mutex,const pthread_mutexattr_t*mutexattr); 函数功能：用于初始化一个互斥锁。 函数参数：mutexattr指针用于设置互斥锁的属性，不
c++ tcp并发多线程客户端
12-13
c tcp并发多线程客户端是一种采用C语言编写的客户端程序，利用了多线程技术在同一时间内与多个服务器建立并发连接。通过使用多线程，该客户端可以同时处理多个服务器的请求，提高了程序的效率和并发性能。 在实现过程中，首先需要使用socket函数创建套接字，然后通过调用connect函数与服务器建立连接。之后，可以创建多个线程，每个线程都可以负责与一个服务器进行通信。在每个线程内部，可以使用send和recv函数来发送和接收数据。 为了保证多线程间数据的同步和互斥访问，可以采用互斥锁技术，比如使用pthread_mutex_init函数初始化互斥锁，并在关键代码段使用pthread_mutex_lock和pthread_mutex_unlock函数进行加锁和解锁操作。 此外，还需要使用pthread_create函数来创建多个线程，并通过传递参数指定不同的服务器地址和端口号等信息。每个线程内部都可以使用独立的套接字进行通信操作。 通过使用多线程实现并发，可以在同一时间内与多个服务器进行通信，大大提高了客户端的效率和并发处理能力。但同时也需要注意处理线程间的同步和互斥问题，以避免数据竞争和不一致的情况发生。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值