unique_lock详解

最新推荐文章于 2024-05-24 09:44:12 发布
最新推荐文章于 2024-05-24 09:44:12 发布
阅读量4.8k 收藏 9
点赞数
分类专栏： 多线程与高并发 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37947660/article/details/120501119
版权

        unique_lock可以取代lock_guard。

#include<thread>
#include<iostream>
#include<list>
#include<mutex>

using namespace std;

class A
{
public:
	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
			std::unique_lock<std::mutex> sbguard1(my_mutex);
			msgRecvQueue.push_back(i); //假设这个数字就是收到的命令，直接放到消息队列里来
			//.....
			//其他处理代码
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex);
		if (!msgRecvQueue.empty())
		{
			//消息不为空			
			command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回；
			return true;
		}
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100; ++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()
{
	{
		A  myobja;
		std::thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);  //注意这里第二个参数必须是引用（用std::ref也可以），才能保证线程里用的是同一个对象
		std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
		myInMsgObj.join();
		myOutnMsgObj.join();
		cout << "main主函数执行结束!" << endl;
	}

	return 0;
}

 

unique_lock的第二个参数

1、std::adopt_lock

使用std::adopt_lock的前提是开发者需要先把互斥量lock上。

#include<thread>
#include<iostream>
#include<list>
#include<mutex>

using namespace std;

class A
{
public:
	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
            my_mutex.lock();
			std::unique_lock<std::mutex> sbguard1(my_mutex, std::adopt_lock);
			msgRecvQueue.push_back(i); //假设这个数字就是收到的命令，直接放到消息队列里来
			//.....
			//其他处理代码
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		my_mutex.lock();
	    std::unique_lock<std::mutex> sbguard1(my_mutex, std::adopt_lock);
		if (!msgRecvQueue.empty())
		{
			//消息不为空			
			command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回；
			return true;
		}
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100; ++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()
{
	{
		A  myobja;
		std::thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);  //注意这里第二个参数必须是引用（用std::ref也可以），才能保证线程里用的是同一个对象
		std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
		myInMsgObj.join();
		myOutnMsgObj.join();
		cout << "main主函数执行结束!" << endl;
	}

	return 0;
}

2、std::try_to_lock

使用std::try_to_lock的前提是开发者不可以自己把互斥量lock上。

#include<thread>
#include<iostream>
#include<list>
#include<mutex>

using namespace std;

class A
{
public:
	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;

			//std::unique_lock<std::mutex> sbguard1(my_mutex, std::adopt_lock);
			//std::unique_lock<std::mutex> sbguard1(my_mutex);
			std::unique_lock<std::mutex> sbguard1(my_mutex, std::try_to_lock);
			if (sbguard1.owns_lock()) //条件成立表示拿到了锁头
			{
				//拿到了锁头，离开sbguard1作用域锁头会自动释放
				msgRecvQueue.push_back(i); //假设这个数字就是收到的命令，直接放到消息队列里来
			//.....
			//其他处理代码
			}
			else
			{
				//没拿到锁
				cout << "inMsgRecvQueue()执行，但没拿到锁，只能干点别的事" << i << endl;
			}
		}
	}

	bool outMsgLULProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex);
		std::chrono::milliseconds dura(20000);  //定义一个时间相关对象，初值2万，单位毫秒, 卡在这里20秒
		std::this_thread::sleep_for(dura);

		if (!msgRecvQueue.empty())
		{
			//消息不为空			
			command = msgRecvQueue.front(); //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回；
			return true;
		}
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0; i < 100000; ++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; //创建互斥量
	std::mutex my_mutex2; //创建互斥量
};

int main()
{
	{
		A  myobja;
		std::thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);  //注意这里第二个参数必须是引用（用std::ref也可以），才能保证线程里用的是同一个对象
		std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
		myInMsgObj.join();
		myOutnMsgObj.join();
		cout << "main主函数执行结束!" << endl;
	}

	return 0;
}

3、std::defer_lock

使用defer_lock的前提是开发者不能自己吧互斥量lock上，否则会报异常

unique_lock的成员函数

1、lock

给互斥量加锁，如果无法拿到锁，会阻塞一直等待拿到锁。

	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
            std::unique_lock<std::mutex> sbguard1(my_mutex, std::defer_lock);
			sbguard1.lock(); //反正unique_lock能自动解锁，不用自己解，所以这里只管加锁
			msgRecvQueue.push_back(i);
        }
    }

2、unlock

针对加锁的互斥量，给该互斥量解锁，不可以针对没加锁的互斥量使用，否则会报异常。

 3、try_lock

尝试给互斥量加锁，如果拿不到锁，则返回false；如果拿到了锁，则返回true。这个成员函数不阻塞。

	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
			std::unique_lock<std::mutex> sbguard1(my_mutex, std::defer_lock);
			if (sbguard1.try_lock() == true) //返回true表示拿到了锁，自己不用管unlock问题
			{
				msgRecvQueue.push_back(i);
			}
			else
			{
			    cout << "抱歉，没拿到锁，做点别的事情吧！" << endl;
			}
        }
    }

4、release

	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;
			std::unique_lock<std::mutex> sbguard1(my_mutex);	//mutex锁定
			std::mutex* p_mtx = sbguard1.release();    //现在关联关系解除，程序员有责任自己解锁了，其实这个就是my_mutex，现在sbguard1已经不和my_mutex关联了(可以设置断点并观察)
			msgRecvQueue.push_back(i);
			p_mtx->unlock();//因为前面已经加锁，所以这里要自己解锁了	
        }
        return;
    }

奇诺比奥大聪明
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多线程：unique_lock源码分析与使用详解（六）
weixin_43808717的博客
03-30 1112
unique_lock取代lock_guard，unique_lock更像lock_guard的升级版，也是mutex的管家！unique_lock是个类模板，工作中一般使用lock_guard（推荐使用）lock_guard取代了mutex的lock()和unlock()unique_lock比lock_guard灵活很多，效率差一点，内存占用多一点lock_guard额外参数只能传入std::adopt_lock。
unique_lock 详解
weixin_42136255的博客
05-14 1万+
(1) unique_lock 取代lock_guard (2)unique_lock的第二个参数 2.1.std::adopt_lock 2.2 std::try_to_lock 2.3 std::defer_lock (3) unique_lock的成员函数 3.1 lock 3.2 unlock() 3.3 try_lock() 3.4 release() (4) unique_lock 所有权的传递 unique_lock 取代lock_guard unique_lock
C++ std::lock_guard
最新发布
wangyifan123456zz的博客
05-24 1001
/ 构造时自动加锁// 构造时自动加锁 std :: lock_guard < std :: mutex >(kMutex);// 离开局部作用域，析构函数自动完成解锁功能 }// 构造时自动加锁 std :: lock_guard < std :: mutex >(kMutex);// 离开局部作用域，析构函数自动完成解锁功能 }// 构造时自动加锁 std :: lock_guard < std :: mutex >(kMutex);
17.6 C++并发与多线程-unique_lock详解
migu123的专栏
02-02 2806
unique_lock是一个类模板，它的功能与lock_guard类似，但是比lock_guard更灵活。在日常的开发工作中，一般情况下，lock_guard就够用了（推荐优先考虑使用lock_guard），但是，读者以后可能参与的实际项目千奇百怪，说不准就需要用unique_lock里面的功能，而且如果阅读别人的代码，也可能会遇到unique_lock，所以这里讲一讲unique_lock。
std::unique_lock 介绍
小米的修行之路
07-22 1万+
lock_guard 最大的缺点是简单，没有给程序员提供足够的灵活度，因此，C++11 标准中定义了另外一个与 Mutex RAII 相关类 unique_lock，该类与 lock_guard 类相似，也很方便线程对互斥量上锁，但它提供了更好的上锁和解锁控制。 顾名思义，unique_lock 对象以独占所有权的方式（ unique owership）管理 mutex 对象的上锁和解锁操作，...
C++11之多线程： unique_lock详解
随意的风的专栏
11-11 6090
目录 1.unique_lock取代lock_guard 2. unique_lock的第二个参数 2.1 std::adopt_lock 2.2 std::try_to_lock 2.3 std::defer_lock 3. unique_lock的成员函数 3.1 lock()，加锁 3.2 unlock(),解锁 3.3 try_lock() 3.4 release() 4. unique_lock所有权的传递 1.unique_lock取代lock_guard uni.
C++11中std::unique_lock的使用
热门推荐
网络资源是无限的
11-26 7万+
C++11中std::unique_lock的使用
C++ unique_lock详解
qq_44800780的博客
03-14 2998
头文件<mutex> 相比于lock_guard,更灵活，但效率上差一点，内存也占用更多. 可以看到unique_lock也含有第二个参数的构造函数.
C++11 并发指南之Lock 详解
08-25
C++11 并发指南之Lock 详解 C++11 标准中提供了两种基本的锁类型：std::lock_guard 和 std::unique_lock。std::lock_guard 是 C++11 中定义的模板类，用于管理某个锁（Lock）对象，因此与 Mutex RAII 相关，方便...
C++11 并发指南五(stdcondition_variable 详解).docx
02-20
C++11 并发指南五(std::condition_variable 详解) std::condition_variable 是 C++11 标准中 <condition_variable> 头文件里的一个类，用于实现条件变量的功能。条件变量是一种同步机制，允许线程在某个条件下等待...
Lotus_Notes公式详解
01-07
4. **@DocLock**：锁定文档，防止他人同时编辑，例如`@DocLock([Lock])`。 5. **时间限制条件**：使用时间变量`h`和`m`，配合逻辑运算符判断特定时间范围，限制功能的使用。 6. **@Prompt**：显示提示对话框，例如...
C++11 并发指南之std::mutex详解
12-20
- **std::adopt_lock_t, std::defer_lock_t, std::try_to_lock_t**：这些是标记类型，用于在`std::unique_lock`构造时指示锁的状态（已锁定、未锁定或尝试锁定）。 - **std::try_lock**：尝试同时对多个互斥量进行...
C++11并发与多线程笔记（6） unique_lock（类模板）详解
qq_38231713的博客
05-13 5936
第六节 unique_lock（类模板）详解 1.unique_lock取代lock_guard unique_lock比lock_guard灵活很多（多出来很多用法），效率差一点。 unique_lock myUniLock(myMutex); 2.unique_lock的第二个参数 2.1 std::adopt_lock： 表示这个互斥量已经被lock()，即不需要在构造函数中lock这个互斥量了。 前提：必须提前lock lock_guard中也可以用这个参数 2.2 std::try_to_l
C++多线程学习（七、unique_lock）
多方通行8的博客
07-06 1092
1、正确的锁定顺序：在使用多个unique_lock对象对多个互斥量进行锁定时，应保持相同的锁定顺序，以避免死锁。在选择锁定策略时，需要考虑是否希望避免阻塞线程，或者需要在特定条件下重新尝试锁定。时，应尽可能缩小锁定的粒度，以避免不必要的性能开销。在使用时，应避免无谓的锁定和解锁操作，以提高性能。使用defer_lock，是给你安装了一个没有上锁的锁，需要自己去手动上锁。提供了异常安全性，即在异常发生时，会自动释放互斥量。时，需要根据具体需求选择适当的互斥量类型。6、选择适当的互斥量：在选择使用。
C++-std::unique_lock介绍和简单使用
mrbone11的博客
11-29 2万+
unique_lock std::unique_lock比std::lock_guard更灵活，这种灵活性主要体现在以下几点： lock_guard在构造时或者构造前（std::adopt_lock）就已经获取互斥锁，并且在作用域内保持获取锁的状态，直到作用域结束；而unique_lock在构造时或者构造后（std::defer_lock）获取锁，在作用域范围内可以手动获取锁和释放锁，作用域结束时如果已经获取锁则自动释放锁。 lock_guard锁的持有只能在lock_guard对象的作用域范围内，作用域
C++(11)：unique_lock
风静如云的博客
05-04 3210
unique_lock是lock_guard的加强版，它具有 lock_guard 的所有功能，同时具有如下特点： 创建时可以不锁定（通过指定第二个参数为std::defer_lock） 可以随时加锁解锁（通过lock，try_lock, unlock） 允许延迟锁定（通过try_lock_for），限时锁定（通过 try_lock_until） 不可复制，可移动（通过移动构造函数或移动赋值函数转移所有权） 可以主动释放所有权（通过release） 作用域规则同 lock_grard，析构时自动
std::unique_lock
07-29
- *2* [C++多线程unique_lock详解](https://blog.csdn.net/Charles_Zaqdt/article/details/104180967)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值