17.12 windows临界区、其他各种mutex互斥量

zzyzxb

已于 2022-06-26 08:25:58 修改

阅读量289

点赞数

分类专栏： c++学习文章标签： c++

于 2022-06-24 23:01:39 首次发布

本文链接：https://blog.csdn.net/zzyzxb/article/details/125453135

版权

c++学习专栏收录该内容

58 篇文章 6 订阅

订阅专栏

初始代码如下

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

	bool outMsgLUProc(int& command)
	{
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
	}
		my_mutex.unlock();
		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;  //容器(消息队列)，专门用于代表玩家发送的命令
	std::mutex my_mutex;  //创建了一个互斥量
};

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;
}

一：windows临界区

#include <list>
#include <future>
#include <iostream>
#include <windows.h>

using namespace std;

#define __WINDOWSJQ_  //定义一个开关，WINDOWS开关

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

#ifdef __WINDOWSJQ_ 
			EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
#else
			my_mutex.lock();
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			my_mutex.unlock();
#endif
		}
	}

	bool outMsgLUProc(int& command)
	{
#ifdef __WINDOWSJQ_ 
		EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			return true;
		}
		LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
#else
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
		}
		my_mutex.unlock();
#endif
		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;
	}

	MA()
	{
#ifdef __WINDOWSJQ_ 
		InitializeCriticalSection(&my_winsec);  //用临界区之前要先初始化
#endif
	}

private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	std::mutex my_mutex;  //创建了一个互斥量
#ifdef __WINDOWSJQ_  //解开开关
	CRITICAL_SECTION my_winsec;  //windwos中的临界区，非常类似于c++11中的mutex
#endif
};

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;
}

二：多次进入临界区试验

在同一线程中(不同线程就会卡住等待)中，windows中的“相同临界区变量”代表的临界区的进入EnterCriticalSection()可以被多次调用。但是调用几次EnterCriticalSection()，就得调用几次LeaveCriticalSection()。

#define __WINDOWSJQ_  //定义一个开关，WINDOWS开关

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

#ifdef __WINDOWSJQ_ 
			EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
			EnterCriticalSection(&my_winsec);  //两次进入临界区(加锁)
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			LeaveCriticalSection(&my_winsec);  //两次进入必须两次离开
#else
			my_mutex.lock();
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			my_mutex.unlock();
#endif
		}
	}

	bool outMsgLUProc(int& command)
	{
#ifdef __WINDOWSJQ_ 
		EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			return true;
		}
		LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
#else
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
		}
		my_mutex.unlock();
#endif
		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;
	}

	MA()
	{
#ifdef __WINDOWSJQ_ 
		InitializeCriticalSection(&my_winsec);  //用临界区之前要先初始化
#endif
	}

private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	std::mutex my_mutex;  //创建了一个互斥量
#ifdef __WINDOWSJQ_  //解开开关
	CRITICAL_SECTION my_winsec;  //windwos中的临界区，非常类似于c++11中的mutex
#endif
};

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;
}

在c++11中加两次锁就会报错，不允许同一个线程中lock同一个互斥量多次，否则报异常。

my_mutex.lock();
my_mutex.lock();  //报异常，和windows有区别
msgRecvQueue.push_back(i);     
my_mutex.unlock();
my_mutex.unlock();

三：自动析构技术

std::lock_guardstd::mutex
std::lock_guardstd::mutex sbguard(my_mutex);
std::lock_guardstd::mutex sbguard1(my_mutex);
lock_guard也不能调用两次

using namespace std;

//#define __WINDOWSJQ_  //定义一个开关，WINDOWS开关

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

#ifdef __WINDOWSJQ_ 
			EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
			EnterCriticalSection(&my_winsec);  //两次进入临界区(加锁)
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			LeaveCriticalSection(&my_winsec);  //两次进入必须两次离开
#else
			std::lock_guard<std::mutex> sbguard(my_mutex);
			std::lock_guard<std::mutex> sbguard1(my_mutex);
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#endif
		}
	}

	bool outMsgLUProc(int& command)
	{
#ifdef __WINDOWSJQ_ 
		EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			return true;
		}
		LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
#else
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
		}
		my_mutex.unlock();
#endif
		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;
	}

	MA()
	{
#ifdef __WINDOWSJQ_ 
		InitializeCriticalSection(&my_winsec);  //用临界区之前要先初始化
#endif
	}

private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	std::mutex my_mutex;  //创建了一个互斥量
#ifdef __WINDOWSJQ_  //解开开关
	CRITICAL_SECTION my_winsec;  //windwos中的临界区，非常类似于c++11中的mutex
#endif
};

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;
}

自动释放windows下的临界区，防止忘记LeaveCriticalSection()导致死锁情况的发生，类似于c++11中的std::lock_guardstd::mutex功能。

#define __WINDOWSJQ_  //定义一个开关，WINDOWS开关

//本类用于自动释放windows下的临界区，防止忘记LeaveCriticalSection()导致死锁情况的发生，类似于c++11中的std::lock_guard<std::mutex>功能
class CWinLock  //叫RAII类（Resourse Acquisition is initialization）中文“资源获取及初始化”。容器、智能指针这种类，都属于RAII类
{     
public:
	CWinLock(CRITICAL_SECTION* pCripem)  //构造函数
	{   
		m_pCritical = pCripem;
		EnterCriticalSection(m_pCritical);
	}
	~CWinLock()  //析构函数
	{   
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION* m_pCritical;
};

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

#ifdef __WINDOWSJQ_ 
			CWinLock wlock(&my_winsec);  //wlock，wlock2都属于RAII类
			CWinLock wlock2(&my_winsec);  //wlock，wlock2都属于RAII类
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#else
			std::lock_guard<std::mutex> sbguard(my_mutex);
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#endif
		}
	}

	bool outMsgLUProc(int& command)
	{
#ifdef __WINDOWSJQ_ 
		EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			return true;
		}
		LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
#else
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
		}
		my_mutex.unlock();
#endif
		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;
	}

	MA()
	{
#ifdef __WINDOWSJQ_ 
		InitializeCriticalSection(&my_winsec);  //用临界区之前要先初始化
#endif
	}

private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	std::mutex my_mutex;  //创建了一个互斥量
#ifdef __WINDOWSJQ_  //解开开关
	CRITICAL_SECTION my_winsec;  //windwos中的临界区，非常类似于c++11中的mutex
#endif
};

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;
}

四：recursive_mutex递归的独占互斥量

std::mutex：独占互斥量，自己lock时，别人就lock不了。
recursive_mutex：递归的独占互斥量。允许同一个线程，同一个互斥量多次被lock()。效率上比mutex要差一些。

std::lock_guardstd::recursive_mutex sbguard(my_mutex);
testfun1();

如果出现recursive_mutex，就要考虑代码的效率是不是有问题，最好能不使用。递归次数有限制，递归太多可能报异常。

//#define __WINDOWSJQ_  //定义一个开关，WINDOWS开关

//本类用于自动释放windows下的临界区，防止忘记LeaveCriticalSection()导致死锁情况的发生，类似于c++11中的std::lock_guard<std::mutex>功能
class CWinLock  //叫RAII类（Resourse Acquisition is initialization）中文“资源获取及初始化”。容器、智能指针这种类，都属于RAII类
{
public:
	CWinLock(CRITICAL_SECTION* pCripem)  //构造函数
	{
		m_pCritical = pCripem;
		EnterCriticalSection(m_pCritical);
	}
	~CWinLock()  //析构函数
	{
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION* m_pCritical;
};

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

#ifdef __WINDOWSJQ_ 
			CWinLock wlock(&my_winsec);  //wlock，wlock2都属于RAII类
			CWinLock wlock2(&my_winsec);  //wlock，wlock2都属于RAII类
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#else
			std::lock_guard<std::recursive_mutex> sbguard(my_mutex);
			testfun1();  //加了三次锁，报异常(只要lock超过1次就报异常)
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#endif
		}
	}

	bool outMsgLUProc(int& command)
	{
#ifdef __WINDOWSJQ_ 
		EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			return true;
		}
		LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
#else
		my_mutex.lock();
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
		}
		my_mutex.unlock();
#endif
		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;
	}

	MA()
	{
#ifdef __WINDOWSJQ_ 
		InitializeCriticalSection(&my_winsec);  //用临界区之前要先初始化
#endif
	}

	void testfun1()
	{
		std::lock_guard<std::recursive_mutex> sbguard(my_mutex);
		//干一些事情
		testfun2();  //奔溃
	}
	void testfun2()
	{
		std::lock_guard<std::recursive_mutex> sbguard(my_mutex);
		//干另一些事情
	}

private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	//std::mutex my_mutex;  //创建了一个互斥量
	std::recursive_mutex my_mutex;  //递归式的独占互斥量
#ifdef __WINDOWSJQ_  //解开开关
	CRITICAL_SECTION my_winsec;  //windwos中的临界区，非常类似于c++11中的mutex
#endif
};

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;
}

五：带超时的互斥量std::time_mutex和std::recursive_timed_mutex

<1>std::timed_mutex :带超时功能的独占互斥量

try_lock_for()：参数是等待一段时间。如果我拿到了锁，或者等待超过时间没拿到锁头，就走下来；

//#define __WINDOWSJQ_  //定义一个开关，WINDOWS开关

//本类用于自动释放windows下的临界区，防止忘记LeaveCriticalSection()导致死锁情况的发生，类似于c++11中的std::lock_guard<std::mutex>功能
class CWinLock  //叫RAII类（Resourse Acquisition is initialization）中文“资源获取及初始化”。容器、智能指针这种类，都属于RAII类
{
public:
	CWinLock(CRITICAL_SECTION* pCripem)  //构造函数
	{
		m_pCritical = pCripem;
		EnterCriticalSection(m_pCritical);
	}
	~CWinLock()  //析构函数
	{
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION* m_pCritical;
};

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

#ifdef __WINDOWSJQ_ 
			CWinLock wlock(&my_winsec);  //wlock，wlock2都属于RAII类
			CWinLock wlock2(&my_winsec);  //wlock，wlock2都属于RAII类
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#else
			std::chrono::milliseconds timeout(100);  //100毫秒
			if (my_mutex.try_lock_for(timeout))  //等待一百毫秒尝试获取锁头 
			{
				//在这100毫秒之内拿到了锁
				msgRecvQueue.push_back(i);
				my_mutex.unlock();  //用完了要解锁；
			}
			else
			{
				//这次没拿到锁头
				std::chrono::milliseconds sleeptime(100);
				std::this_thread::sleep_for(sleeptime);
			}
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#endif
		}
	}

	bool outMsgLUProc(int& command)
	{
#ifdef __WINDOWSJQ_ 
		EnterCriticalSection(&my_winsec);  //进入临界区(加锁)
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
			return true;
		}
		LeaveCriticalSection(&my_winsec);  //离开临界区(解锁)
#else
		my_mutex.lock();
		std::chrono::milliseconds sleeptime(1000000);
		std::this_thread::sleep_for(sleeptime);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();  //返回第一个元素，但不检查元素是否存在；
			msgRecvQueue.pop_front();  //移除第一个元素，但不返回
			my_mutex.unlock();
			return true;
		}
		my_mutex.unlock();
#endif
		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;
	}

	MA()
	{
#ifdef __WINDOWSJQ_ 
		InitializeCriticalSection(&my_winsec);  //用临界区之前要先初始化
#endif
}

private:
	list<int> msgRecvQueue;  //容器(消息队列)，专门用于代表玩家发送的命令
	//std::mutex my_mutex;  //创建了一个互斥量
	std::timed_mutex my_mutex;  //带超时功能的独占互斥量
#ifdef __WINDOWSJQ_  //解开开关
	CRITICAL_SECTION my_winsec;  //windwos中的临界区，非常类似于c++11中的mutex
#endif
};

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;
}

try_lock_until()：参数是一个未来的时间点，在这个未来时间没到的时间段内。如果拿到了锁，那么就走下来；如果时间到了，没拿到锁，程序流程也走下来。

	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素： " << i << endl;

#ifdef __WINDOWSJQ_ 
			CWinLock wlock(&my_winsec);  //wlock，wlock2都属于RAII类
			CWinLock wlock2(&my_winsec);  //wlock，wlock2都属于RAII类
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#else
			std::chrono::milliseconds timeout(100);  //100毫秒
			if (my_mutex.try_lock_until(chrono::steady_clock::now() + timeout))
			{
				//在这100毫秒之内拿到了锁
				msgRecvQueue.push_back(i);
				my_mutex.unlock();  //用完了要解锁；
			}
			else
			{
				//这次没拿到锁头
				std::chrono::milliseconds sleeptime(100);
				std::this_thread::sleep_for(sleeptime);
			}
			msgRecvQueue.push_back(i);  //假设这个数字i就是我收到的命令，直接弄到消息队列中
#endif
		}
	}

<2>std::recursive_timed_mutex：带超时功能的递归独占互斥量(允许同一个线程多次获取这个互斥量)。