0
点赞
收藏
分享

微信扫一扫

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

河南妞 2022-02-02 阅读 79
c++开发语言后端

六、unique_lock（类模板）详解

在这里插入图片描述

1.unique_lock取代lock_guard

  • unique_lock比lock_guard灵活很多（多出来很多用法），效率差一点,内存占用多一点。
    unique_lock<mutex> myUniLock(myMutex);
#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()了
			std::unique_lock<std::mutex> my_lock_guard1(my_mutex1, std::adopt_lock);
			std::unique_lock<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;
}

2.unique_lock的第二个参数

2.1 std::adopt_lock：

  • 表示这个互斥量已经被lock()，即不需要在构造函数中lock这个互斥量了。
  • 前提：必须提前lock
  • lock_guard中也可以用这个参数
#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);//必须先加锁，才能使用unique_lock的std::adopt_lock
			//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()了
			std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::adopt_lock);
			std::unique_lock<std::mutex> my_unique_lock2(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;
}

2.2 std::try_to_lock：

  • 尝试用mutex的lock()去锁定这个mutex，但如果没有锁定成功，会立即返回，不会阻塞在那里；
  • 使用try_to_lock的原因是防止其他的线程锁定mutex太长时间，导致本线程一直阻塞在lock这个地方
  • 前提：不能提前lock();
  • owns_locks()方法判断是否拿到锁，如拿到返回true
#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::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::try_to_lock);
			std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::try_to_lock);//加上这两行就不用unlock()了
			if (my_unique_lock1.owns_lock() && my_unique_lock2.owns_lock())
			{
				//拿到锁了
				list_msg.push_back(i);
				//其他处理。。。。
			}
			else
			{
				//没拿到锁
				std::cout << "inMesgRecvQueue()执行，但是没拿到锁，继续干其他事情" << std::endl;
			}
		}
	}

	//把消息队列从容器中取出来的线程
	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);
				std::chrono::milliseconds dura(20000);
				std::this_thread::sleep_for(dura);//卡20秒
				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;
}

2.3 std::defer_lock

  • 如果没有第二个参数就对mutex进行加锁，加上defer_lock是初始化了一个没有加锁的mutex
  • 不给它加锁的目的是以后可以调用unique_lock的一些方法
  • 前提：不能提前lock

3.unique_lock的成员函数（前三个与std::defer_lock联合使用）

3.1 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;
			//其他处理...
			std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::defer_lock);//没有加锁的my_mutex1
			my_unique_lock1.lock();//不用自己unlock();
			std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::defer_lock);//没有加锁的my_mutex2
			my_unique_lock2.lock();
			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(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.2 unlock()：解锁。

因为一些非共享代码要处理，可以暂时先unlock()，用其他线程把它们处理了，处理完后再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;
			//其他处理...
			std::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::defer_lock);//没有加锁的my_mutex1
			my_unique_lock1.lock();
			std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::defer_lock);//没有加锁的my_mutex2
			my_unique_lock2.lock();
			//处理共享代码。。。
			my_unique_lock1.unlock();//因为有一些非共享代码要处理，所以才手动unlock
			my_unique_lock2.unlock();
			//处理一些非共享代码。。。

			my_unique_lock1.lock();//再次加锁，保护共享数据，处理共享代码。。。不需要手动unclock
			my_unique_lock2.lock();
			list_msg.push_back(i);
			my_unique_lock1.unlock();//这里加不加unclock都可以,生命周期结束，不加的话，my_unique_lock1调用my_mutex1的析构函数unlock
			my_unique_lock2.unlock();//加的话，my_unique_lock1不调用my_mutex1的析构函数unlock
			//其他处理。。。。
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();	
				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.3 try_lock()：尝试给互斥量加锁

如果拿不到锁，返回false，否则返回true。

#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::unique_lock<std::mutex> my_unique_lock1(my_mutex1, std::defer_lock);//没有加锁的my_mutex1
			std::unique_lock<std::mutex> my_unique_lock2(my_mutex2, std::defer_lock);//没有加锁的my_mutex2
			if (my_unique_lock1.try_lock() == true && my_unique_lock2.try_lock() == true)
			{
				list_msg.push_back(i);
			}
			else
			{
				//其他处理。。。。
			}			
		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();	
				std::lock(my_mutex1, my_mutex2);//std::lock(my_mutex2, my_mutex2);
				std::chrono::milliseconds dura(2000);
				std::this_thread::sleep_for(dura);
				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 release()：

返回它管理的mutex对象指针，并释放所有权，也就是说unique_lock不再与mutex有联系

  • unique_lock
  • my_unique_lock1(my_mutex1);相当于把my_mutex1和my_unique_lock1绑定在了一起，release()就是解除绑定，返回它所管理的mutex对象的指针，并释放所有权
  • mutex* ptx = my_unique_lock1.release();所有权由ptx接管，如果原来mutex对象处理加锁状态，就需要ptx在以后进行解锁了。
  • lock的代码段越少，执行越快，整个程序的运行效率越高。
  • a.锁住的代码少，叫做粒度细，执行效率高；
  • b.锁住的代码多，叫做粒度粗，执行效率低；
#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::unique_lock<std::mutex> my_unique_lock1(my_mutex1);
			std::unique_lock<std::mutex> my_unique_lock2(my_mutex2);
			std::mutex *ptx1 = my_unique_lock1.release();
			std::mutex *ptx2 = my_unique_lock2.release();
			list_msg.push_back(i);
			//其他处理。。。。

			ptx1->unlock();//自己负责my_mutex1的unlock
			ptx2->unlock();//自己负责my_mutex2的unlock

		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();	
				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;
}

4.unique_lock所有权的传递

  • std::unique_lockstd::mutex my_unique_lock1(my_mutex1);//所有权概念
  • 把my_unique_lock1和my_mutex1绑定在了一起，也就是my_unique_lock1拥有my_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;
			//其他处理...
			std::unique_lock<std::mutex> my_unique_lock1(my_mutex1);//所有权概念
			std::unique_lock<std::mutex> my_unique_lock2(my_mutex2);

			//std::unique_lock<std::mutex> my_unique_lock12(my_unique_lock1);//复制是非法的

			//移动语义，现在相当于my_unique_lock12和my_mutex1绑到一起了
			//现在my_unique_lock1指向空，my_unique_lock12指向了my_mutex1
			std::unique_lock<std::mutex> my_unique_lock12(std::move(my_unique_lock1));

			//移动语义，现在相当于my_unique_lock22和my_mutex2绑到一起了
			//现在my_unique_lock2指向空，my_unique_lock22指向了my_mutex1
			std::unique_lock<std::mutex> my_unique_lock22(std::move(my_unique_lock2));


			//std::mutex *ptx1 = my_unique_lock1.release();
			//std::mutex *ptx2 = my_unique_lock2.release();
			list_msg.push_back(i);
			//其他处理。。。

			//ptx1->unlock();//自己负责my_mutex1的unlock
			//ptx2->unlock();//自己负责my_mutex2的unlock

		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();	
				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;
}

4.1. 方法一：使用move转移

  • my_unique_lock1拥有my_mutex1的所有权，my_unique_lock1可以把自己对my_mutex1的所有权转移，但是不能复制。
  • unique_lock my_unique_lock12(std::move(my_unique_lock1));
    现在my_unique_lock12拥有my_mutex1的所有权。

4.2.方法二： 在函数中return一个临时变量，即可以实现转移

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


class A
{
public:
	std::unique_lock<std::mutex> ReturnUniqueLock()
	{
		std::unique_lock<std::mutex> temp_unique_lock(my_mutex1);
		//从函数返回一个临时的unique_lock是可以的（移动构造函数）
		//返回这种局部对象temp_unique_lock会导致系统生成临时的unique_lock对象
		//并调用unique_lock的移动构造函数
		return temp_unique_lock;
	}

	//把收到的消息（玩家命令）插入到一个队列的线程
	void inMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMesgRecvQueue执行，插入一个元素" << i << endl;
			//其他处理...
			//std::unique_lock<std::mutex> my_unique_lock1(my_mutex1);//所有权概念
			std::unique_lock<std::mutex> my_unique_lock2(my_mutex2);

			//std::unique_lock<std::mutex> my_unique_lock12(my_unique_lock1);//复制是非法的

			//移动语义，现在相当于my_unique_lock12和my_mutex1绑到一起了
			//现在my_unique_lock1指向空，my_unique_lock12指向了my_mutex1
			//std::unique_lock<std::mutex> my_unique_lock12(std::move(my_unique_lock1));
			std::unique_lock<std::mutex> my_unique_lock13 = ReturnUniqueLock();

			//移动语义，现在相当于my_unique_lock22和my_mutex2绑到一起了
			//现在my_unique_lock2指向空，my_unique_lock22指向了my_mutex1
			std::unique_lock<std::mutex> my_unique_lock22(std::move(my_unique_lock2));


			//std::mutex *ptx1 = my_unique_lock1.release();
			//std::mutex *ptx2 = my_unique_lock2.release();
			list_msg.push_back(i);
			//其他处理。。。

			//ptx1->unlock();//自己负责my_mutex1的unlock
			//ptx2->unlock();//自己负责my_mutex2的unlock

		}
	}

	//把消息队列从容器中取出来的线程
	void outMesgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			if (!list_msg.empty())
			{
				int command = list_msg.front();	
				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;
}
举报

相关推荐

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

c++开发语言后端

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

c++visual studio开发语言

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

c++开发语言后端

【C++11】多线程

leetcode哈希

多线程（C++11）

selenium测试工具

Linux与C++11多线程编程(学习笔记)

c++操作系统#include2dWindowsJavaScript前端开发

C++11多线程编程-初识多线程

c++

C++新经典 | C语言

macos

c++11多线程与POSIX多线程性能比较

#includei++ios系统/运维

【C++11】多线程常用知识

java开发语言设计模式
0 条评论