1、windows临界区

Windows临界区，同一个线程是可以重复进入的，但是进入的次数与离开的次数必须相等。
C++互斥量则不允许同一个线程重复加锁 (相同的mutex变量不容许连续调用）。

windows临界区是在windows编程中的内容，了解一下即可，效果几乎可以等同于c++11的mutex
包含**#include <windows.h>**
windows中的临界区同mutex一样，可以保护一个代码段。但windows的临界区可以进入多次，离开多次，但是进入的次数与离开的次数必须相等，不会引起程序报异常出错。

#include <iostream>
#include <thread>
#include <list>
#include <mutex>
#include <Windows.h>#define __WINDOWSJQ_using namespace std;class A
{
public:// 把收到的消息传入队列void inMsgRecvQueue(){for (size_t i = 0; i < 10000; ++i){cout << "收到消息，并放入队列 " << i << endl;
//windows开关
#ifdef  __WINDOWSJQ_ EnterCriticalSection(&my_winsec);	//	进入临界区//EnterCriticalSection(&my_winsec);	//	可以再次进入临界区,程序不会出错msgRecvQueue.push_back(i);LeaveCriticalSection(&my_winsec);	//	离开临界区//LeaveCriticalSection(&my_winsec);	//	如果进入两次，必须离开两次不会报错
#elsemy_mutex.lock();msgRecvQueue.push_back(i);my_mutex.unlock();
#endif //  __WINDOWSJQ_}cout << "消息入队结束" << endl;}// 从队列中取出消息void outMsgRecvQueue(){for (size_t i = 0; i < 10000; ++i){
#ifdef  __WINDOWSJQ_EnterCriticalSection(&my_winsec);	//	进入临界区if (!msgRecvQueue.empty()){// 队列不为空int num = msgRecvQueue.front();cout << "从消息队列中取出 " << num << endl;msgRecvQueue.pop_front();}else{// 消息队列为空cout << "消息队列为空 " << endl;}LeaveCriticalSection(&my_winsec);	//	离开临界区
#elsemy_mutex.lock();if (!msgRecvQueue.empty()){// 队列不为空int num = msgRecvQueue.front();cout << "从消息队列中取出 " << num << endl;msgRecvQueue.pop_front();my_mutex.unlock();}else{// 消息队列为空cout << "消息队列为空 " << endl;my_mutex.unlock();}
#endif //  __WINDOWSJQ_}cout << "消息出队结束" << endl;}A(){
#ifdef __WINDOWSJQ_InitializeCriticalSection(&my_winsec);	//	用临界区之前要初始化
#endif // __WINDOWSJQ_}private:list<int> msgRecvQueue;mutex my_mutex;#ifdef __WINDOWSJQ_CRITICAL_SECTION my_winsec;	//	windows中的临界区，非常类似C++11中的mutex,使用之前必须初始化
#endif // __WINDOWSJQ_};int main()
{A myobj;thread	myInMsgObj(&A::inMsgRecvQueue, &myobj);thread	myOutMsgObj(&A::outMsgRecvQueue, &myobj);myInMsgObj.join();myOutMsgObj.join();getchar();return 0;
}

2、自动析构技术

C++：lock_guard防止忘了释放信号量，自动释放
windows：可以写个类自动释放临界区

//本类用于自动释放windows下的临界区，防止忘记LeaveCriticalSection导致死锁情况的发生
class CWinLock {//RALL类
public:CWinLock(CRITICAL_SECTION *pCritmp)//构造函数{my_winsec =pCritmp;EnterCriticalSection(my_winsec);//进入}~CWinLock()//析构函数{LeaveCriticalSection(my_winsec);//离开}
private:CRITICAL_SECTION *my_winsec;
};class A
{
public:// 把收到的消息传入队列void inMsgRecvQueue(){for (size_t i = 0; i < 10000; ++i){cout << "收到消息，并放入队列 " << i << endl;
//windows开关
#ifdef  __WINDOWSJQ_ CWinLock wlock(&my_winsec);//调用msgRecvQueue.push_back(i);
#elsemy_mutex.lock();msgRecvQueue.push_back(i);my_mutex.unlock();
#endif //  __WINDOWSJQ_}cout << "消息入队结束" << endl;}
};

上述这种类RAII类（Resource Acquisition is initialization），即资源获取及初始化。容器，智能指针属于这种类。

3、递归独占互斥量 std::recursive_mutex

• std::mutex： 独占式互斥量，自己lock时别人lock不了
• std::recursive_mutex：允许在同一个线程中同一个互斥量多次被 lock()，（但是递归加锁的次数是有限制的，太多可能会报异常），效率要比mutex低。

void testfunc1(){std::lock_guard<std::mutex> sbguard(my_mutex);//...干各种事情testfunc2();//多次加锁，异常
}
void testfunc2(){std::lock_guard<std::mutex> sbguard(my_mutex);//...干各种另外一些事情
}

如果你真的用了 recursive_mutex 要考虑代码是否有优化空间，如果能调用一次 lock()就不要调用多次。

4、带超时的互斥量 std::timed_mutex 和 std::recursive_timed_mutex

4.1 std::timed_mutex：是带超时的独占互斥量

1. try_lock_for()：等待一段时间
如果拿到了锁，或者超时了未拿到锁，就继续执行（有选择执行）如下：

std::chrono::milliseconds timeout(100);
if (my_mymutex.try_lock_for(timeout)){//......拿到锁返回turemy_mymutex.unlock();//用完了要解锁
}else{//没拿到锁，不会卡着，流程继续往下走
}

2. try_lock_until()：参数是一个未来的时间点
在这个未来的时间没到的时间内，如果拿到了锁头，流程就走下来，如果时间到了没拿到锁，流程也可以走下来。

std::chrono::milliseconds timeout(100);
if (my_mymutex.try_lock_until(chrono::steady_clock::now() + timeout)){//......拿到锁返回turemy_mymutex.unlock();//用完了要解锁
}
else{//没拿到锁，不会卡着，流程继续往下走
}

两者的区别就是一个参数是时间段，一个参数是时间点

4.2 std::recursive_timed_mutex：是带超时的递归独占互斥量

允许同一个线程多次获取这个互斥量