前言
多线程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;
}
运行截图：
总结
（1）了解windows临界区；
（2）了解linux递归锁和互斥锁；
（3）了解基本函数的使用。