第十二節 windows臨界區、其他各種mutex互斥量

一和二、windows臨界區
Windows臨界區，同一個線程是可以重復進入的，但是進入的次數與離開的次數必須相等。
C++互斥量則不允許同一個線程重復加鎖。

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 < 1000; ++i)
		{
			cout << "收到消息，并放入隊列 " << i << endl;

#ifdef  __WINDOWSJQ_
			EnterCriticalSection(&my_winsec);	//	進入臨界區
			//EnterCriticalSection(&my_winsec);	//	可以再次進入臨界區,程序不會出錯
			msgRecvQueue.push_back(i);
			LeaveCriticalSection(&my_winsec);	//	離開臨界區
			//LeaveCriticalSection(&my_winsec);	//	如果進入兩次，必須離開兩次不會報錯
#elif
			my_mutex.lock();
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
#endif //  __WINDOWSJQ_
		}

		cout << "消息入隊結束" << endl;
	}

	// 從隊列中取出消息
	void outMsgRecvQueue()
	{
		for (size_t i = 0; i < 1000; ++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);	//	離開臨界區
#elif
			my_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;
}

三、自動析構技術
C++：lock_guard防止忘了釋放信號量，自動釋放
windows：可以寫個類自動釋放臨界區：

class CWinLock {
public:
    CWinLock(CRITICAL_SECTION *pCritmp)
    {
        my_winsec =pCritmp;
        EnterCriticalSection(my_winsec);
    }
    ~CWinLock()
    {
        LeaveCriticalSection(my_winsec)
    };
private:
    CRITICAL_SECTION *my_winsec;
};

上述這種類RAII類（Resource Acquisition is initialization），即資源獲取及初始化。容器，智能指針屬于這種類。

四、遞歸獨占互斥量 std::recursive_mutex
std::mutex 獨占式互斥量

std::recursive_mutex：允許在同一個線程中同一個互斥量多次被 lock() ，（但是遞歸加鎖的次數是有限制的，太多可能會報異常），效率要比mutex低。

如果你真的用了 recursive_mutex 要考慮代碼是否有優化空間，如果能調用一次 lock()就不要調用多次。

五、帶超時的互斥量 std::timed_mutex 和 std::recursive_timed_mutex

5.1 std::timed_mutex：是待超時的獨占互斥量

• try_lock_for()：

等待一段時間，如果拿到了鎖，或者超時了未拿到鎖，就繼續執行（有選擇執行）如下：

std::chrono::milliseconds timeout(100);
if (my_mymutex.try_lock_for(timeout)){
    //......拿到鎖返回ture
}
else{
    std::chrono::milliseconds sleeptime(100);
    std::this_thread::sleep_for(sleeptime);
}

• try_lock_until()：

參數是一個未來的時間點，在這個未來的時間沒到的時間內，如果拿到了鎖頭，流程就走下來，如果時間到了沒拿到鎖，流程也可以走下來。

std::chrono::milliseconds timeout(100);
if (my_mymutex.try_lock_until(chrono::steady_clock::now() + timeout)){
    //......拿到鎖返回ture
}
else{
    std::chrono::milliseconds sleeptime(100);
    std::this_thread::sleep_for(sleeptime);
}

兩者的區別就是一個參數是時間段，一個參數是時間點

5.2 std::recursive_timed_mutex：是待超時的遞歸獨占互斥量