前言

多线程windows临界区和Linux互斥锁

提示：以下是本篇文章正文内容，下面案例可供参考

一、windows临界区

1.1 基本概念

Linux下有递归锁，递归锁是同一个线程在不解锁的情况下，可以多次获取锁定同一个递归锁，而且不会产生死锁。windows下的互斥量和临界区（关键段）默认支持递归锁。

在windows临界区，同一个线程（不同线程就会卡住等待）中，
windows中的“相同临界区变量”代表的临界区的进入（EnterCriticalSection）可以被多次调用。而在c++11中，不允许同一线程中lock同一个互斥量多次，否则报异常。
但是你调用了几次EnterCriticalSection，你就得调用几次LeaveCriticalSection(&my_winsec);

1.2 函数使用

（1）windows临界区

//初始化一个临界区对象
void InitializeCriticalSection(  LPCRITICAL_SECTION lpCriticalSection);
//删除临界区对象释放由该对象使用的所有系统资源
void DeleteCriticalSection(_Inout_ LPCRITICAL_SECTION lpCriticalSection);
//进入临界区，相当于Linux下lock
void EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection );
//删除临界区，相当于Linux下unlock
void LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection );

（2）其他：linux递归锁和互斥锁

//自动析构技术
std::lock_guard<std::mutex>

lock()
unlock();

二、使用步骤

1.代码示例1

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

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <thread>
#include <list>
#include <mutex>
#include <future>
#include <windows.h>

using namespace std;

//#define __WINDOWSJQ_

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

	~CWinLock()	//析构函数
	{
		LeaveCriticalSection(m_pCritical);
	}

private:
	CRITICAL_SECTION *m_pCritical;
};

class A
{
public:
	//把收到的消息到队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100; ++i)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素" << i << endl;

#ifdef __WINDOWSJQ_
			//EnterCriticalSection(&my_winsec);	//进入临界区（加锁）
			//EnterCriticalSection(&my_winsec);
			CWinLock wlock(&my_winsec);		//wlock，wlock2 都属于RAII对象。
			CWinLock wlock2(&my_winsec);	//调用多次也没问题；
			msgRecvQueue.push_back(i);
			//LeaveCriticalSection(&my_winsec);	//离开临界区（解锁）
			//LeaveCriticalSection(&my_winsec);
#else
			//my_mutex.lock();
			//my_mutex.lock();	//报异常，和windows有区别；
			std::lock_guard<std::mutex> sbguard(my_mutex);
			//std::lock_guard<std::mutex> sbguard1(my_mutex);
			msgRecvQueue.push_back(i);	//假设这个数字i就是我收到的命令，我直接弄到消息队列里边来；
			//my_mutex.unlock();
			//my_mutex.unlock();
#endif
		}
	}

	bool outMsgLULProc(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 < 100; ++i)
		{
			bool result = outMsgLULProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//这里可以考虑处理数据
				//.....
			}
			else
			{
				cout << "outMsgEecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
		cout << "end" << endl;
	}

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


private:
	std::list<int> msgRecvQueue;	//容器，专门用于代表玩家给咱们发送过来的命令
	std::mutex my_mutex;	//创建互斥量

#ifdef __WINDOWSJQ_
	CRITICAL_SECTION my_winsec;	//windows种的临界区，非常类似于C++11种的mutex
#endif
};

int main()
{
	//一：windows临界区
	//二：多次进入临界区试验
	//在同一个线程（不同线程就会卡住等待）中，windows中的“相同临界区变量”代表的临界区的进入（EnterCriticalSection）可以被多次调用
		//但是你调用了几次EnterCriticalSection，你就得调用几次LeaveCriticalSection(&my_winsec);
		//而在c++11中，不允许 同一线程中lock同一个互斥量多次，否则报异常

	//三：自动析构技术
	//std::lock_guard<std::mutex>

	//四：recursive_mutex递归的独占互斥量

	A myobja;
	std::thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);	//注意这里第二个参数必须时引用，才能保证线程里用的是同一个对象
	std::thread myInMsgObj(&A::inMsgRecvQueue, &myobja);
	
	myOutnMsgObj.join();
	cout << "myOutnMsgObj  end!" << endl;
	myInMsgObj.join();
	cout << "myInMsgObj  end!" << endl;
	

	system("pause");
	return 0;
}