并发与多线程笔记6

最新推荐文章于 2024-07-25 23:22:43 发布
最新推荐文章于 2024-07-25 23:22:43 发布
阅读量93 收藏
点赞数
分类专栏： 周边工具学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Walking_roll/article/details/119907950
版权

目录

1 unique_lock()取代lock_guard()

上节我们知道了lock_guard()的妙用，它可以帮我们填掉我们容易忘记unlock()的坑。另一方面，这虽然很省我们的力气，但是并不灵活。unique_lock()比lock_guard()，更灵活，但效率差点，内存占用多点。unique_lock()的灵活性体现在unique_lock()的第二个参数：

1.1 unique_lock()的第二个参数

std::unique_lock<std::mutex> sbunique(my_mutex,第二个参数)

第二个参数1：std::adopt_lock:表示这个互斥量已经被lock了；就是通知unique_lock不需要在构造函数中再lock了。
前提是在之前已经拿到锁。
示例：

// project5.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

#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++)
		{
			std::unique_lock<std::mutex> sbguard(my_mutex);//将unique_lock和mutex绑定，并lock()
			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
			msgRecvQueue.push_back(i);// 把收到的消息，放进消息队列中。
		}
	}

	bool outMsgState(int &command)
	{
		//感觉下面两句加起来就是std::lock_guard<std::mutex> sbguard(my_mutex);
		my_mutex.lock();//先拿到锁。
		std::unique_lock<std::mutex> sbguard(my_mutex,std::adopt_lock);//表示这个互斥量my_mutex已经被lock了；就是通知unique_lock不需要在构造函数中再lock了（前提是在之前已经拿到锁。）并且不用担心unlock()问题
		if (!msgRecvQueue.empty())
		{
			cout << "outMsgRecvQueue()执行，取出一个元素 " << endl;
			command = msgRecvQueue.front();//返回第一个元素，在前面取，但不检查元素是否存在。
			msgRecvQueue.pop_front();//移除第一个元素，不返回。

			//处理数据。
			//……
			return true;
		}
		return false;
	}

	// 把数据从消息队列中取出的线程。
	void outMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			int command;
			bool result = outMsgState(command);
			if (result)
			{
				cout << "outMsgState is true, and command is " << command << endl;
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但是目前消息队列为空 " << i << endl;
			}
		}
		cout << "end......." << endl;
	}

private:
	std::list<int> msgRecvQueue;// 容器，专门用于代表晚间给咱们发送过来的指令。
	std::mutex my_mutex;// 创建一个互斥量（一把锁）
};

int main()
{
	vector<thread> mythreads;
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);//注意，第二个对象要用引用，保证子线程中用的就是主线程提供的对象。
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsgObj.join();
	myInMsgObj.join();

	cout << "主线程结束！" << endl;

}

第二个参数2：std::try_to_lock：表示尝试用mutex的lock去锁定mutex，但如果没有锁定成功，也会立即返回，并不会阻塞在那。
注意：用它的前提是，你自己不能先去lock。
示例：

// project5.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

#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++)
		{	
			//std::unique_lock<std::mutex> sbguard(my_mutex);//到这也会等待4秒
			// 如果继续用上述方法拿锁，插入线程就会一直卡到这，当程序复杂时此线程有可能除了插入数据还要进行其他与取出线程不冲突的任务，所以我们不希望此线程一直卡在这。
			std::unique_lock<std::mutex> sbguard(my_mutex,std::try_to_lock);// 可以这样解决,就不会卡到这了，但是要判断是否拿到锁
			if (sbguard.owns_lock())// 因为没拿到锁就不应该插入数据
			{
				//拿到锁了就干活
				cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
				msgRecvQueue.push_back(i);// 把收到的消息，放进消息队列中。
			}
			else
			{
				//没拿到锁
				cout << "我没拿到锁，但我可以去干点别的和取出任务不冲突的事。。" << endl;
			}
		}
	}

	bool outMsgState(int &command)
	{
		std::lock_guard<std::mutex> sbguard(my_mutex);//拿锁，且不用担心unlock()问题
		// 注意：因为取出线程拿到锁了，这里要等待一段时间，也就是插入线程拿不到锁，而通过互斥量的概念知道拿不到锁就会一直等待。
		std::chrono::milliseconds dura(4000);//4秒
		std::this_thread::sleep_for(dura);//休眠一定时间,因为此线程已经拿到锁了，这会让插入元素时也是等待的。

		if (!msgRecvQueue.empty())
		{
			cout << "outMsgRecvQueue()执行，取出一个元素 " << endl;
			command = msgRecvQueue.front();//返回第一个元素，在前面取，但不检查元素是否存在。
			msgRecvQueue.pop_front();//移除第一个元素，不返回。

			//处理数据。
			//……
			return true;
		}
		return false;
	}

	// 把数据从消息队列中取出的线程。
	void outMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			int command;
			bool result = outMsgState(command);
			if (result)
			{
				cout << "outMsgState is true, and command is " << command << endl;
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但是目前消息队列为空 " << i << endl;
			}
		}
		cout << "end......." << endl;
	}

private:
	std::list<int> msgRecvQueue;// 容器，专门用于代表晚间给咱们发送过来的指令。
	std::mutex my_mutex;// 创建一个互斥量（一把锁）
};

int main()
{
	vector<thread> mythreads;
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);//注意，第二个对象要用引用，保证子线程中用的就是主线程提供的对象。
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsgObj.join();
	myInMsgObj.join();

	cout << "主线程结束！" << endl;

}

第二个参数3：std::defer_lock:初始化了一个没有加锁的mutex。目的是为了使用unique_lock()的成员函数方便(成员函数看1.2).
注意：前提是不能先去lock。
示例：

// project5.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

#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++)
		{
			std::unique_lock<std::mutex> sbguard(my_mutex,std::defer_lock);//初始化一个没有加锁的mutex；这个就很灵活了。这样我们可以在他的作用域内随意选取共享代码范围了。而且最后一个也不用担心unlock()问题。但是中间得注意。
			// 然后就可以再unique_lock的作用域中随意的拿锁和解锁了
			sbguard.lock();
			// 处理共享代码
			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
			msgRecvQueue.push_back(i);// 把收到的消息，放进消息队列中。

			sbguard.unlock();
			//处理非共享代码

			sbguard.lock();
			// 继续处理其他共享代码
		}
	}

	bool outMsgState(int &command)
	{
		std::lock_guard<std::mutex> sbguard(my_mutex);
		if (!msgRecvQueue.empty())
		{
			cout << "outMsgRecvQueue()执行，取出一个元素 " << endl;
			command = msgRecvQueue.front();//返回第一个元素，在前面取，但不检查元素是否存在。
			msgRecvQueue.pop_front();//移除第一个元素，不返回。

			//处理数据。
			//……
			//my_mutex.unlock();
			return true;
		}
		//my_mutex.unlock();
		return false;
	}

	// 把数据从消息队列中取出的线程。
	void outMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			int command;
			bool result = outMsgState(command);
			if (result)
			{
				cout << "outMsgState is true, and command is " << command << endl;
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但是目前消息队列为空 " << i << endl;
			}
		}
		cout << "end......." << endl;
	}

private:
	std::list<int> msgRecvQueue;// 容器，专门用于代表晚间给咱们发送过来的指令。
	std::mutex my_mutex;// 创建一个互斥量（一把锁）
};

int main()
{
	vector<thread> mythreads;
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);//注意，第二个对象要用引用，保证子线程中用的就是主线程提供的对象。
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsgObj.join();
	myInMsgObj.join();
	
	cout << "主线程结束！" << endl;
}

1.2 unique_lock()的成员函数

对于1.1的第三种情况，可以看出，使用std::defer_lock可以更灵活的控制其作用域内的互斥问题。可能上面的用法还不足以体现其灵活性，下面介绍几unique_lock()的成员函数，进一步体现：
① lock() 加锁和unlock() 解锁。为了处理一些非共享代码，就先解锁，等想继续处理共享代码了可以再锁上。1.1已经用到了。
② try_lock(): 尝试给互斥量加锁，如果没有拿到锁就返回false，否则true
③ release()：返回他所管理的mutex对象指针，并释放所有权，也就是说，这个unique_lock和mutex不再有联系。
严格区分unlock()和release()的区别
如果原来mutex对象处于加锁状态，你有责任接管过来并负责解锁。（release返回的就是原始的mutex指针）
示例：

// project5.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

#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++)
		{
			std::unique_lock<std::mutex> sbguard(my_mutex,std::defer_lock);//初始化一个没有加锁的mutex
			if (sbguard.try_lock() == true)// 可以用unique_lock的成员函数try_lock()直接判断是否拿到锁，和上面那个std::unique_lock<std::mutex> sbguard(my_mutex,std::try_to_lock)一样啊
			{
				//拿到锁了就干活
				cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
				msgRecvQueue.push_back(i);// 把收到的消息，放进消息队列中。
			}
			else
			{
				//没拿到锁
				cout << "我没拿到锁，但我可以去干点别的事。" << endl;
			}
		}
	}

	bool outMsgState(int &command)
	{
		my_mutex.lock();
		std::unique_lock<std::mutex> sbguard(my_mutex,std::adopt_lock);
		std::chrono::milliseconds dura(4000);//毫秒
		std::this_thread::sleep_for(dura);//休眠一定时间,因为此线程已经拿到锁了，这会让插入元素时也是等待的。这里用unique_lock的成员函数try_lock()解决。

		if (!msgRecvQueue.empty())
		{
			cout << "outMsgRecvQueue()执行，取出一个元素 " << endl;
			command = msgRecvQueue.front();//返回第一个元素，在前面取，但不检查元素是否存在。
			msgRecvQueue.pop_front();//移除第一个元素，不返回。

			//处理数据。
			//……
			return true;
		}
		return false;
	}

	// 把数据从消息队列中取出的线程。
	void outMsgRecvQueue()
	{
		for (int i = 0; i < 10000; i++)
		{
			int command;
			bool result = outMsgState(command);
			if (result)
			{
				cout << "outMsgState is true, and command is " << command << endl;
			}
			else
			{
				cout << "outMsgRecvQueue()执行，但是目前消息队列为空 " << i << endl;
			}
		}
		cout << "end......." << endl;
	}

private:
	std::list<int> msgRecvQueue;// 容器，专门用于代表晚间给咱们发送过来的指令。
	std::mutex my_mutex;// 创建一个互斥量（一把锁）
};

int main()
{
	vector<thread> mythreads;
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);//注意，第二个对象要用引用，保证子线程中用的就是主线程提供的对象。
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	myOutnMsgObj.join();
	myInMsgObj.join();

	cout << "主线程结束！" << endl;

}

关于release()的用法如下：

	//作用域
	{
		std::unique_lock<std::mutex> sbguard(my_mutex);//将unique_lock和mutex绑定，并lock()
		std::mutex *ptx = sbguard.release();//sbguard1和my_mutex解绑了
		cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
		msgRecvQueue.push_back(i);// 把收到的消息，放进消息队列中。
	
		ptx->unlock();//解绑以后得自己负责他的unlock了。
	}

1.3 unique_lock()所有权的传递

所有权概念：

std::unique_lock<std::mutex> sbguard(my_mutex);

表示：sbguard拥有my_mutex的所有权，sbguard可以把自己对my_mutex的所有权转移给其他的unique_lock对象。但是，不能复制。
示例：

	{
			std::unique_lock<std::mutex> sbguard(my_mutex);//将unique_lock和mutex绑定，并lock()
			//std::unique_lock<std::mutex> sbguard1(sbguard);// 复制所有权是非法的。
			std::unique_lock<std::mutex> sbguard1(std::move(sbguard));// 转移所有权是可以的。
																		// 所有权转移了，所以此时sbguard解除了和my_mutex的关系
																		// 现在是sbguard1和my_mutex绑定一起了
			std::mutex *ptx = sbguard1.release();//sbguard1和my_mutex解绑了

			cout << "inMsgRecvQueue()执行，插入一个元素 " << i << endl;
			msgRecvQueue.push_back(i);// 把收到的消息，放进消息队列中。

			ptx->unlock();//解绑以后得自己负责他的unlock了。
	}
宛如新生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多线程高并发笔记.md
02-20
多线程高并发马士兵老师的课堂笔记
多线程与高并发编程笔记、源码等
09-05
标题“多线程与高并发编程笔记、源码等”表明了资源的核心内容，涵盖了多线程和高并发编程的理论与实践。多线程允许一个应用程序同时执行多个任务，而高并发则指系统能够处理大量并发请求的能力。这两个概念在现代...
多线程与高并发笔记
牧小农
09-13 3926
1. 创建线程的三种方式 实现Runnable 重写run方法 继承Thread 重写run方法 线程池创建 Executors.newCachedThreadPool() 2. Thread线程操作方法 Thread.sleep([mills]) 当前线程睡眠指定mills毫秒 Thread.yield() 当前线程优雅让出执行权 join 例如Thread t1, t2 在t2的run方法中调用t1.join(),线程t2将等待t1完成后执行 3. Thread状态
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
【学习笔记】C++并发与多线程笔记三：数据共享
Rain_Mic的博客
04-02 1227
本文接上文【学习笔记】C++并发与多线程笔记二的内容，主要包含创建多个线程、数据共享问题分析和案例代码。
狂神说多线程笔记整理
doris的博客
02-16 1万+
狂神说多线程笔记整理
多线程与高并发整理总结【超全面】
认知 行动 坚持
11-22 2559
我们先说一下为什么要讲多线程和高并发？ 原因是，你想拿到一个更高的薪水，在面试的时候呈现出了两个方向的现象： 第一个上天 项目经验 高并发、缓存、大流量、大数据量的架构设计 第二个入地 各种基础算法，各种基础的数据结构 JVM OS线程、IO等内容 多线程和高并发，就是入地里面的内容。 一、基本概念 我们先从线程的基本概念开始，给大家复习一下。如果基础不太好，说什么是线程都不知道的，则需要花时间去补初级内容的课。 1. 什么是进程？什么是线程？ Program app，比如QQ.exe
马士兵多线程笔记.zip
02-21
以下是对马士兵多线程笔记的详细解析。 1. **多线程基础**：多线程是指一个应用程序中同时执行多个线程（即任务）的能力。这种并发执行可以提高系统资源的利用率，提升程序的响应速度和执行效率，特别是在多核...
黑马程序员–Java多线程讲解笔记
12-22
在实际开发中，合理地运用多线程和同步机制可以极大地提升程序的并发性能，但也需要注意避免过度使用同步，以免造成线程阻塞，影响程序的整体性能。因此，理解和掌握Java的多线程技术对于任何Java程序员来说都是至关...
马士兵多线程训练营笔记
02-21
通过马士兵的多线程训练营笔记，开发者不仅可以学习到多线程的基本概念，还能掌握高级并发编程技巧，这对于开发高并发、高性能的应用至关重要。在阅读和学习这些笔记时，结合实际的编程练习将有助于更好地理解和巩固...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1243
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 704
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 292
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1153
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
Windows图形界面(GUI)-MFC-C/C++ - Dialog
最新发布
0xCC说逆向
07-25 1035
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
【C++初阶】string类
2301_78022459的博客
07-24 894
【C++初阶】string类
学懂C语言（二十一）：深入理解C语言中的函数指针和回调函数
martian665的专栏
07-23 597
学懂C语言：C语言中的函数指针和回调函数详解
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
Edward2022的博客
07-25 798
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
如何在C\#中创建HTML表格
程序员-张师傅
07-24 369
在C#中创建HTML表格通常不是直接由C#语言本身完成的，因为C#是一种面向对象的编程语言，主要用于后端逻辑处理。然而，在Web开发中，你可能会在C#代码（如在ASP.NET MVC、ASP.NET Core MVC或Razor Pages应用程序中）中生成HTML表格的字符串，或者更常见的是，使用Razor视图引擎来动态生成HTML表格。
Java多线程与并发库高级技术解析
"张孝祥的Java多线程与并发库高级应用笔记涵盖了从传统线程技术到Java 5引入的并发库的广泛内容，旨在帮助已有基础的开发者提升Java线程技术。教程通过深入讲解各种线程同步和通信机制，如线程互斥、同步通信、共享...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宛如新生

转发即鼓励，打赏价更高！哈哈。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值