《c++新经典》C++11并发与多线程笔记（5）

最新推荐文章于 2024-04-24 15:15:48 发布
最新推荐文章于 2024-04-24 15:15:48 发布
阅读量607 收藏 4
点赞数 1
分类专栏： # C++并发与多线程 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39303983/article/details/122770099
版权

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

在这里插入图片描述

1.互斥量（mutex）的基本概念

  • 互斥量就是个类对象，可以理解为一把锁，多个线程尝试用lock()成员函数来加锁，只有一个线程能锁定成功，成功的标志是lock()函数返回。
  • 如果没有锁成功，那么流程将卡在lock()这里不断尝试去锁定。
  • 互斥量使用要小心，保护数据不多也不少，少了达不到效果，多了影响效率。

2.互斥量的用法

包含#include <mutex>头文件

2.1 lock()，unlock()

步骤：

  • 1.lock()，
  • 2.操作共享数据，
  • 3.unlock()。
  • lock()和unlock()要成对使用
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;
			my_mutex.lock();
			list_msg.push_back(i);//假设这个数字i就是我收到的命令，我直接弄到消息队列里面来
			my_mutex.unlock();
		}
	}
	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				my_mutex.lock();
				list_msg.pop_front();
				my_mutex.unlock();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex;//创建了一个互斥量
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}

2.2 lock_guard类模板

  • lock_guard<mutex> sbguard(myMutex);取代lock()和unlock()
  • lock_guard构造函数执行了mutex::lock();在作用域结束时，调用析构函数，执行mutex::unlock()
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;			
			{
				//lock_guard创建类对象my_lock_guard时调用了mutex::lock的构造函数
				std::lock_guard<std::mutex> my_lock_guard(my_mutex);//局部对象
				//my_mutex.lock();
				list_msg.push_back(i);//假设这个数字i就是我收到的命令，我直接弄到消息队列里面来
				//my_mutex.unlock();				
			}//局部对象my_lock_guard的生命周期结束，调用mutex::unlock的析构函数
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				my_mutex.lock();
				list_msg.pop_front();
				my_mutex.unlock();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex;//创建了一个互斥量,一个互斥量就是一把锁
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}

3.死锁

3.1 死锁演示

死锁至少有两个互斥量mutex1，mutex2。
两个线程A、B

  • a.线程A执行时，这个线程先锁mutex1，并且锁成功了，然后去锁mutex2的时候，出现了上下文切换(线程A正在锁mutex2还没成功，切换到了线程B)。
  • b.线程B执行，这个线程先锁mutex2，因为mutex2没有被锁，即mutex2可以被锁成功，然后线程B要去锁mutex1.
  • c.此时，死锁产生了，A锁着mutex1，需要锁mutex2，B锁着mutex2，需要锁mutex1，两个线程没办法继续运行下去。。。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;			
			my_mutex1.lock();
			//其他处理...
			my_mutex2.lock();
			list_msg.push_back(i);
			my_mutex2.unlock();
			my_mutex1.unlock();
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				my_mutex2.lock();
				my_mutex1.lock();
				list_msg.pop_front();
				my_mutex1.unlock();
				my_mutex2.unlock();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了一个互斥量
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;		
			std::lock_guard<std::mutex> my_lock_guard1(my_mutex1);
			std::lock_guard<std::mutex> my_lock_guard2(my_mutex2);
			//其他处理...
			list_msg.push_back(i);
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				std::lock_guard<std::mutex> my_lock_guard2(my_mutex2);
				std::lock_guard<std::mutex> my_lock_guard1(my_mutex1);
				list_msg.pop_front();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了一个互斥量
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}

3.2 死锁的一般解决方案：

只要保证多个互斥量上锁的顺序一样就不会造成死锁。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;			
			my_mutex1.lock();
			//其他处理...
			my_mutex2.lock();
			list_msg.push_back(i);
			my_mutex2.unlock();
			my_mutex1.unlock();
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				my_mutex1.lock();
				my_mutex2.lock();
				list_msg.pop_front();
				my_mutex1.unlock();
				my_mutex2.unlock();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了一个互斥量
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;		
			std::lock_guard<std::mutex> my_lock_guard1(my_mutex1);
			std::lock_guard<std::mutex> my_lock_guard2(my_mutex2);
			//其他处理...
			list_msg.push_back(i);
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				std::lock_guard<std::mutex> my_lock_guard2(my_mutex2);
				std::lock_guard<std::mutex> my_lock_guard1(my_mutex1);
				list_msg.pop_front();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了一个互斥量
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}

3.3 std::lock()函数模板

std::lock(mutex1,mutex2……);

  • 一次锁定多个互斥量（至少两个，一般这种情况很少），用于处理多个互斥量。
  • 如果互斥量中一个没锁住，它就等着，等所有互斥量都锁住，才能继续执行。如果有一个没锁住，就会把已经锁住的释放掉（要么互斥量都锁住，要么都没锁住，防止死锁）
  • 使用std::lock(mutex1,mutex2……)，后面也得手动unlock()
  • std::lock(mutex1,mutex2,……) std::lock(mutex2,mutex1,……)里面顺序无所谓
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;			
			//my_mutex1.lock();
			//其他处理...
			//my_mutex2.lock();
			std::lock(my_mutex1, my_mutex2);
			list_msg.push_back(i);
			my_mutex2.unlock();
			my_mutex1.unlock();
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				//my_mutex1.lock();
				//my_mutex2.lock();				
				std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
				list_msg.pop_front();
				my_mutex1.unlock();
				my_mutex2.unlock();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了一个互斥量
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}

3.4 std::lock_guard的std::adopt_lock参数

std::lock_guardstd::mutex my_guard(my_mutex,std::adopt_lock);

  • 加入adopt_lock后，在调用lock_guard的构造函数时，不再进行lock();
  • adopt_guard为结构体对象，起一个标记作用，表示这个互斥量已经lock()，不需要再lock()。
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <list>
#include <thread>
#include <mutex>
using namespace std;


class A
{
public:
	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;			
			//my_mutex1.lock();
			//其他处理...
			//my_mutex2.lock();
			std::lock(my_mutex1, my_mutex2);
			std::lock_guard<std::mutex> my_lock_guard1(my_mutex1, std::adopt_lock);
			std::lock_guard<std::mutex> my_lock_guard2(my_mutex2, std::adopt_lock);//加上这两行就不用unlock()了
			list_msg.push_back(i);
			//my_mutex2.unlock();
			//my_mutex1.unlock();
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();
				//my_mutex1.lock();
				//my_mutex2.lock();				
				std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
				list_msg.pop_front();
				my_mutex1.unlock();
				my_mutex2.unlock();
			}
			else
			{
				cout << "消息队列为空" << endl;
			}
		}
		cout << "outMesgRecvQueue end" << endl;
	}
protected:
private:
	std::list<int> list_msg;//专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex1;//创建了一个互斥量
	std::mutex my_mutex2;//创建了一个互斥量
};


int main(int argc, char* argv[])
{
	A myobja;
	//第2个参数是引用，才能保证线程里面用的是同一个对象
	std::thread myOutMsgobj(&A::outMesgRecvQueue, &myobja);
	std::thread myInMsgobj(&A::inMesgRecvQueue, &myobja);
	myOutMsgobj.join();
	myInMsgobj.join();
	system("pause");
	return 0;
}
中国彭于晏杭州分晏
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11的多线程并发编程（一）
01-20
C++11的多线程并发编程（一） 在疫情期间以及未来毕业后即将工作的憧憬中，给自己立个学习flag，学习并第一次通过CSDN记录下C++11的多线程并发编程。初学者的我写的不好，还望大家多多指正与批评， 学习多线程并发...
《c++新经典》C++11并发与多线程笔记（10）
weixin_39303983的博客
02-04 775
一、std::future的其他成员函数
《c++新经典》C++11并发与多线程笔记（7）
weixin_39303983的博客
02-02 798
七、单例设计模式共享数据分析、解决，call_once 1.设计模式 程序灵活，维护起来可能方便，用设计模式理念写出来的代码很晦涩，但是别人接管、阅读代码都会很痛苦 老外应付特别大的项目时，把项目的开发经验、模块划分经验，总结整理成设计模式 中国零几年设计模式刚开始火时，总喜欢拿一个设计模式往上套，导致一个小小的项目总要加几个设计模式，本末倒置 设计模式有其独特的优点，要活学活用，不要深陷其中，生搬硬套 2.单例设计模式： 整个项目中，有某个或者某些特殊的类，只能创建一个属于该类的对象。 单例类：只能生成
《c++新经典》C++11并发与多线程笔记（1）
weixin_39303983的博客
01-24 287
一 并发基本概念及实现，进程、线程基本概念 1、并发、进程、线程的基本概念和综述 并发，线程，进程要求必须掌握 1.1 并发 两个或者更多的任务（独立的活动）同时发生（进行）：一个程序同时执行多个独立的任务； 以往计算机，单核cpu（中央处理器）：某一个时刻只能执行一个任务，由操作系统调度，每秒钟进行多次所谓的“任务切换”。并发的假象（不是真正的并发），切换（上下文切换）时要保存变量的状态、执行进度等，存在时间开销； 随着硬件发展，出现了多处理器计算机：用于服务器和高性能计算领域。台式机：在一块芯片上有
c++11并发与多线程
fb_941219的博客
05-07 1297
c++11并发与多线程0.引言一.基本概念和实现1.1.并发、进程、线程的基本概念1.1.1 并发1.1.2 可执行程序1.1.3 进程1.1.4 线程1.1.5 学习心得1.2.并发的实现方法1.2.1 多进程并发1.2.2 多线程并发1.2.3.总结1.3.C++11新标准线程库二.线程启动、结束，创建线程多法、join，detach2.1.范例演示线程运行的开始2.2.其他创建线程的方法三.线程传参详解，detach()大坑，成员函数做线程函数3.1.传递临时对象作为线程参数3.2.临时对象作为线程.
《c++新经典》C++11并发与多线程笔记（2）
weixin_39303983的博客
02-02 1087
二 线程启动、结束，创建线程多法、join，detach 1、范例演示线程运行的开始 程序运行起来，生成一个进程，该进程所属的主线程开始自动运行；当主线程从main（）函数返回，则整个进程执行完毕 主线程从main（）开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数），一旦这个函数运行完毕，线程也结束运行 整个进程是否执行完毕的标志是：主线程是否执行完，如果主线程执行完毕了，就代表整个进程执行完毕了，此时，一般情况下：如果其他子线程还没有执行完，也会被强行终止【此条有例外，以后会解释
C++11 并发指南之多线程初探
12-20
Linux 程序员都用过 Pthread, 但有了 C++11 的 std::thread 以后，你可以在语言层面编写多线程程序了，直接的好处就是多线程程序的可移植性得到了很大的提高，所以作为一名 C++ 程序员，熟悉 C++11 的多线程编程方式...
C++ 并发多线程日志处理
02-28
多线程日志处理 C++实现 参考用例
c++11新特性多线程操作实战
12-16
c++11多线程操作 线程 thread int main() { thread t1(Test1); t1.join(); thread t2(Test2); t2.join(); thread t3 = t1; thread t4(t1); thread t5 = std::move(t1); thread t6(std::move(t1)); ...
【C】 初识C语言
努力学习C/C++
04-21 766
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
数据结构与算法学习笔记七--二叉树(C++)
我叫柱子哥
04-23 611
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
C++ WebServer的细节理解
我的博客
04-22 600
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
笨蛋学C++【C++基础第六弹】
最新发布
YSL_Monet的博客
04-24 791
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
C++——初识模板
qq_74245477的博客
04-22 896
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
【C++风云录】精益求精：探索C++开发中的性能优化艺术
记录我的学习历程
04-21 1092
本文将介绍几个在C++开发中常用的性能分析工具和性能优化工具集，包括PerfTools、gperftools、Valgrind、Intel VTune、PAPI以及Boost.Profile。通过深入了解这些工具的功能和用途，读者可以更好地理解如何利用它们来提高代码的执行效率和资源利用率。
c++ GetStdHandle(STD_OUTPUT_HANDLE)
m0_74811974的博客
04-20 307
114514
C语言：贪吃蛇游戏（万字解读超详细）
2301_80655639的博客
04-20 1060
贪吃蛇这个游戏应该我们小时候都玩过吧我相信能够点进这个博客的应该都很熟悉这个游戏了如果对这个游戏不熟悉的可以网上查查怎么玩，这样才能对这个游戏有个清晰的认知该篇博客需要拥有C语言基础（对指针熟悉、会链表的使用）下面我们需要先学习一些C语言之外的东西认真坚持看完，我相信你一定能完成这个接近500行的C语言贪吃蛇项目该类型内部封装了两个成员，一个x，一个y，代表坐标我们可以将我们的控制台理解为一个平面坐标图横向正方向是x轴正方向，竖向负方向是y轴正方向。
C++中的抽象类
hh121386的博客
04-23 193
C++中的抽象类
CSAPP | Lab2-Bomb Lab详细解析
wangs29的博客
04-24 1253
邪恶的邪恶博士在我们班的机器上安放了大量的“二元炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上键入一个特定的字符串。如果你键入了正确的字符串，那么这个阶段就会被拆除，炸弹就会进入下一个阶段。否则，炸弹会通过打印“ BOOM 然后终止。当每个阶段都被拆除时，炸弹就会被拆除。我们要处理的炸弹太多了，所以我们给每个学生一个炸弹去拆除。你们的任务，你们别无选择，只能接受，就是在due date前拆除炸弹。祝你好运，欢迎加入拆弹小组！
c++ tcp并发多线程客户端
12-13
c tcp并发多线程客户端是一种采用C语言编写的客户端程序，利用了多线程技术在同一时间内与多个服务器建立并发连接。通过使用多线程，该客户端可以同时处理多个服务器的请求，提高了程序的效率和并发性能。 在实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值