17.6 unique_lock详解

已于 2022-06-12 12:50:54 修改
阅读量759 收藏 1
点赞数
分类专栏： c++学习 文章标签： c++
于 2022-06-12 10:44:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzyzxb/article/details/125241868
版权

一、unique_lock取代lock_guard

unique_lock 是个类模板，工作中，一般 lock_guard(推荐使用)，lock_guard取代了 mutex 的 lock() 和 unlock()。
unique_lock 比 lock_guard 灵活很多，效率上差一点，内存占用多一点。

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::unique_lock<std::mutex> sbguard1(my_mutex_1);
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex_1);
		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 = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

二、unique_lock的第二个参数

lock_guard 可以带第二个参数；

<1>std::adopt_lock
表示这个互斥量已经被 lock 了(你必须要把互斥量提前 lock 了，否则会报异常)
std::adopt_lock 标记的效果就是"假设调用方线程已经拥有了互斥的所有权" (已经lock()成功了)；
通知 lock_guard 不需要在构造函数中 lock() 这个互斥量了；
unique_lock 也可以代 std::adopt_lock 标记，含义相同，就是不希望在unique_lock的构造函数函数中lock()这个mutex。
用这个adopt_lock的前提是，你需要自己先把mutex先lock()上。

<2>std::try_to_lock
我们会尝试用 mutex 的 lock 去锁定这个 mutex，但如果没有锁成功，我们也会返回，不会阻塞在那里。
用这个try_to_lock的前提是你自己不能先去lock。

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::unique_lock<std::mutex> guard_1(my_mutex_1, std::try_to_lock);
				if (guard_1.owns_lock())
				{
					//拿到了锁
					msgRecvQueue.push_back(i);  // 假设这个数字i就是我收到的命令，直接弄到消息队列中
					//......
					//其他处理代码
				}
				else
				{
					//没拿到锁
					cout << "inMsgRecvQueue()执行，但没有拿到锁，只能干点别的事情 " << i << endl;
				}
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex_1);
		std::chrono::milliseconds dura(200);  //1秒 = 1000毫秒
		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 = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

<3>std::defer_lock
用这个defer_lock的前提，你不能自己先lock()，否则会报异常。
defer_lock的意思就是并没有给mutex加锁，初始化了一个没有加锁的mutex。
我们借着 defer_lock 的话题，来介绍一些 unique_lock 的重要成员函数。

三、unique_lock的成员函数

<1>lock() 加锁

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::unique_lock<std::mutex> guard_1(my_mutex_1, std::defer_lock);  //没有加锁的my_mutex_1
				guard_1.lock();  //我们不用自己unlock
				//拿到了锁
				msgRecvQueue.push_back(i);  // 假设这个数字i就是我收到的命令，直接弄到消息队列中
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex_1);
		//std::chrono::milliseconds dura(200);  //1秒 = 1000毫秒
		//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 = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

<2>unlock()解锁

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::unique_lock<std::mutex> guard_1(my_mutex_1, std::defer_lock);  //没有加锁的my_mutex_1
				guard_1.lock();  //我们不用自己unlock
				//因为有一些非共享代码要处理
				guard_1.unlock();
				//处理一些非共享代码
				guard_1.lock();
				//拿到了锁
				msgRecvQueue.push_back(i);  // 假设这个数字i就是我收到的命令，直接弄到消息队列中
				guard_1.unlock();  //画蛇添足，但也可以
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex_1);
		//std::chrono::milliseconds dura(200);  //1秒 = 1000毫秒
		//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 = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

<3>try_lock()
尝试给互斥量加锁，如果拿不到锁，则返回false，如果拿到了锁，返回true，这个函数不阻塞的；

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::unique_lock<std::mutex> guard_1(my_mutex_1, std::defer_lock);  //没有加锁的my_mutex_1
				if (guard_1.try_lock())
				{
					//拿到了锁
					msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
					//其他处理代码；
				}
				else
				{
					//没拿到锁
					cout << "inMsgRecvQueue()执行，但没有拿到锁，只能干点别的事情" << endl;
				}
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex_1);
		//std::chrono::milliseconds dura(200);  //1秒 = 1000毫秒
		//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 = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

<4>release()
返回它所管理的 mutex 对象指针，并释放所有权；也就是说，这个 unique_lock 和 mutex 不再有联系。
严格区分 unlock() 和 release() 的区别，不要混淆。
如果原来 mutex 对象处于加锁状态，你有责任接管过来并负责解锁。( release 返回的是原始的 mutex指针)。

class MA
{
public:
	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				std::unique_lock<std::mutex> guard_1(my_mutex_1);
				std::mutex* ptx = guard_1.release();  //现在你有责任自己解锁这个my_mutex_1；
				//拿到了锁
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
				//其他处理代码；
				ptx->unlock();  //自己负责mutex的unlock了
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex_1);
		//std::chrono::milliseconds dura(200);  //1秒 = 1000毫秒
		//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 = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}

为什么有时候需要 unlock()：因为你 lock 锁住的代码段越少，执行越快，整个程序运行效率越高。

有人也把锁头锁住的代码多少称为锁的粒度，粒度一般用粗细来描述
1>锁住的代码少，粒度细，执行效率高；
2>锁住的代码多，粒度粗，执行效率低；
要学会尽量选择适合粒度的代码进行保护，粒度太细，可能漏掉共享数据的保护，粒度太粗，影响效率。
选择合适的粒度，是高级程序员能力和实力的体现。

四、unique_lock所有权的传递mutex

std::unique_lock guard_1(my_mutex_1); 所有权概念
guard_1 拥有 my_mutex_1 的所有权。
guard_1 可以把自己对 mutex(my_mutex_1) 的所有权转移给其他的 unique_lock 对象;
所以，unique_lock 对象这个 mutex 的所有权是属于可以转移，但是不能复制。16章6、7节智能指针unique_ptr。

复制所有权是非法的。

std::unique_lock<std::mutex> guard_1(my_mutex_1);
std::unique_lock<std::mutex> guard_2(guard_1);  //复制所有权

所有权转移方式：
1>std::move
2>reutrn std::unique_lockstd::mutex

class MA
{
public:
	std::unique_lock<std::mutex> rtn_unique_gurad()
	{
		std::unique_lock <std::mutex> tmpgurad(my_mutex_1);
		return tmpgurad;  //从函数返回一个局部的unique_lock对象是可以的，十四章十四节讲解过移动构造函数。
		//返回这种局部对象tmpgurad会导致系统生成临时unique_lock对象，并调用unique_lock的移动构造函数
	}

	//把收到的消息(玩家命令)放入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;
			{
				//std::unique_lock<std::mutex> guard_1(my_mutex_1);
				//std::unique_lock<std::mutex> guard_2(std::move(guard_1));  //移动语义，现在相当于guard_2和my_mutex_1绑定到一起了。
				//现在guard_1指向空，guard_2指向了my_mutex_1。
				
				std::unique_lock<std::mutex> guard_2 = rtn_unique_gurad();
				
				std::mutex* ptx = guard_2.release();  //现在你有责任自己解锁这个my_mutex_1；

				//拿到了锁
				msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
				//其他处理代码；
				ptx->unlock();  //自己负责mutex的unlock了
			}
		}
	}

	bool outMsgLUProc(int& command)
	{
		std::unique_lock<std::mutex> sbguard1(my_mutex_1);
		//std::chrono::milliseconds dura(200);  //1秒 = 1000毫秒
		//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 = outMsgLUProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << endl;
				//这里就考虑处理数据...
				//...
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空 " << i << endl;
			}
		}
		cout << "end" << endl;
	}
private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	mutex my_mutex_1;  //创建了一个互斥量  (一把锁头)
	//mutex my_mutex_2;  //创建了一个互斥量  (一把锁头)
};

int main()
{
	MA myobj;
	std::thread myOutMsgObj(&MA::outMsgRecvQueue, &myobj);  //第二个参数是引用,才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&MA::inMsgRecvQueue, &myobj);
	myOutMsgObj.join();
	myInMsgObj.join();
	cout << "main主函数执行结束" << endl;  //最后执行这句，整个进程退出
	return 0;
}
zzyzxb
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TRichView_17.6_Cracked_DCU_Only_Delphi_10.3_Rio.rar
12-21
TRichView是一套本地的Delphi / C ++ Builder VCL和Lazarus（免费Pascal）LCL组件，用于显示，编辑和打印复杂的RTF文档。 TRichView可用于开发高级文本编辑器，Web /帮助/书籍编写应用程序，聊天和信使，组织者和...
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
17.6 C++并发与多线程-unique_lock详解
migu123的专栏
02-02 2758
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 5984
目录 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的使用
TRichView_Trial_v17.6_Cracked_DCU_Only_Delphi_10.3_Rio_Downloadly.ir.rar
05-21
TRichView_Trial_v17.6_Cracked_DCU_Only_Delphi_10.3_Rio_Downloadly.ir.rar
TRichView_17.6 and ScaleRichView_8.2 Full Source
11-10
TRichView_17.6版本可能包含以下特性： 1. 支持Unicode，兼容多种语言。 2. 改进的性能优化，提高在大型文档处理时的效率。 3. 更新的RTF格式支持，确保与现代应用程序的兼容性。 4. 提供更丰富的API函数，增加更多...
TCP_IP详解卷1
12-29
《TCP/IP详解，卷1：协议》是一本完整而详细的TCP/IP协议指南。描述了属于每一层的各个协议以及它们如何在不同操作系统中运行。作者用Lawrence Berkeley实验室的tcpdump程序来捕获不同操作系统和TCP/IP实现之间传输...
Aspose.Cells_17.6 官方安装包
07-08
Aspose.Cells_17.6 官方安装包，最新版本的安装包。包装2.0 和 4.0 的dll 和 API 帮助文档。支持对Excel 进行各项操作。
C++11并发与多线程笔记（6） unique_lock（类模板）详解
qq_38231713的博客
05-13 5902
第六节 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 1074
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 3194
unique_lock是lock_guard的加强版，它具有 lock_guard 的所有功能，同时具有如下特点： 创建时可以不锁定（通过指定第二个参数为std::defer_lock） 可以随时加锁解锁（通过lock，try_lock, unlock） 允许延迟锁定（通过try_lock_for），限时锁定（通过 try_lock_until） 不可复制，可移动（通过移动构造函数或移动赋值函数转移所有权） 可以主动释放所有权（通过release） 作用域规则同 lock_grard，析构时自动
unique_lock详解
HITXJ的博客
09-13 1007
一、unique_lock取代lock_guard unique_lock是个类模板，工作中，一般lock_guard（推荐使用）； lock_guard取代了mutex的lock()和unlock()。 unique_lock比lock_guard灵活很多灵活很多；效率上差一点，内存占用多一点。 std::lock_guard<std::mutex> sbguard(my_mutex);直接换成std::unique_lock<std::mutex> sbguard(my_mute
C++多线程（七）：unique_lock详解
milkhoko的博客
07-04 8079
目录unique_lock取代lock_guardunique_lock的第二个参数std::adopt_lockstd::try_to_lockstd::defer_lockunique_lock的成员函数成员函数lock()成员函数unlock()成员函数try_lock()成员函数release()unique_lock所有权的传递（转移） unique_lock取代lock_guard unique_lock是一个类模板，比lock_guard更加灵活，效率上低一点，内存占用大一点 首先是uniqu
C++多线程：unique_lock源码分析与使用详解（六）
最新发布
weixin_43808717的博客
03-30 1040
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。
C++使用unique_lock实现多重锁机制
jiexijihe945的博客
06-02 1507
现代的计算机性能很强大，可以实现多线程并发。随之而来引入了另一个问题：“数据竞争”，这个问题是并发编程必须面对的。还有一种情形，当我们需要同时满足获取多个锁才能进行下一步操作该怎么办呢？最简单的方法是定义3个mutex，依次lock()，当全部满足的时候再进行下一步。看起来似乎可行，但是对于场景比较复杂的情况可能引来一个非常危险的后果“死锁”：想想那样一种场景，你所需要的锁也同样被其他很多线程需要，随着锁的数量增加，“死锁”的概率随之增大，无形之中增加了风险。
17.6.0wuzhibo v17.6.0youzhibo
06-26
17.6.0是一款名为“无止播”的直播平台的旧版，而17.6.0又是一款名为“有直播”的直播平台推出的新版。这两款直播平台都是面向广大用户开发的，为用户提供在线直播的服务。 不同的是，“无止播”拥有丰富的直播内容...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值