11 —— windows临界区、其它mutex互斥量

最新推荐文章于 2024-07-10 09:38:05 发布

原创最新推荐文章于 2024-07-10 09:38:05 发布 · 204 阅读

0 ·

CC 4.0 BY-SA版权

C++并发专栏收录该内容

17 篇文章

订阅专栏

本文深入探讨了Windows临界区和C++11中的多种互斥量，包括mutex、recursive_mutex及timed_mutex的使用场景与特性。通过实例讲解了如何在多线程环境中正确使用这些同步机制，避免竞态条件，实现线程安全的数据操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

Windows中的临界区同mutex一样，可以保护一个代码段。但windows的临界区可以进入两次，离开一次。也可以进入两次，离开两次。不会引起程序报异常出错。

二其它mutex互斥量

递归的独占互斥量recursive_mutex

#include <iostream>
#include <thread>
#include <list>
#include <mutex>


using namespace std;


class A
{
public:
	void test1()
	{
		std::lock_guard<std::mutex> guard_1(my_mutex);
		//	做些其它的事情
		test2();	//	奔溃，又要加锁。
	}

	void test2()
	{
		std::lock_guard<std::mutex> guard_2(my_mutex);
		//	做些其它的事情
	}

private:
	mutex my_mutex;	

};


int main()
{
	A myobj;
	thread	my_task(&A::test1, &myobj);
	my_task.join();

	getchar();
	return 0;
}

试考虑以上情况，如果在test1()中再次调用test2()函数，会对mutex加锁两次。这样会导致报异常奔溃。这时，可以用recursive_mutex来代替mutex。它允许同一线程，同一互斥量，多次lock()；只需要做如下修改：

	std::recursive_mutex my_mutex;	
	
	void test2()
	{
		std::lock_guard<std::recursive_mutex> guard_2(my_mutex);
		//	做些其它的事情
	}
	
	void test1()
	{
		std::lock_guard<std::recursive_mutex> guard_1(my_mutex);
		//	做些其它的事情
		test2();	//	此时不会奔溃
	}

recursive_mutex可以加锁多次（但是递归加锁的次数是有限制的，太多可能会报异常），但是它效率上要比mutex差。如果需要加锁多次时，可以考虑是否需要优化代码。

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

std::timed_mutex提供了两个额外的成员函数：
1） try_lock_for()：参数是一段时间。等待一段时间，如果取到的锁，或者没有取到锁，可以走分别的流程，不用卡在那。
2） try_lock_until()：参数是一个未来的时间点。在未来的时间没有到的时间内，如果取到的锁，或者没有取到锁，可以走分别的流程，不用卡在那。

try_lock_for()用法：

#include <iostream>
#include <thread>
#include <list>
#include <mutex>


using namespace std;


class A
{
public:
	// 把收到的消息传入队列
	void inMsgRecvQueue()
	{
		for (size_t i = 0; i < 1000; ++i)
		{
			cout << "收到消息，并放入队列 " << i << endl;

			if (my_mutex.try_lock_for(100ms))	//	如果在这段时间内取得了锁
			{
				msgRecvQueue.push_back(i);
				my_mutex.unlock();
			}
			else
			{
				cout << i << "入队列时没有取得锁 " << endl;
			}
		}

		cout << "消息入队结束" << endl;
	}

	// 从队列中取出消息
	void outMsgRecvQueue()
	{
		for (size_t i = 0; i < 1000; ++i)
		{
			my_mutex.lock();
			if (!msgRecvQueue.empty())
			{
				// 队列不为空
				std::this_thread::sleep_for(1000s);		//让入队列线程卡住
				int num = msgRecvQueue.front();
				cout << "从消息队列中取出 " << num << endl;
				msgRecvQueue.pop_front();
			}
			else
			{
				// 消息队列为空
				cout << "消息队列为空 " << endl;
			}
			my_mutex.unlock();
		}

		cout << "消息出队结束" << endl;
	}


private:
	list<int> msgRecvQueue;	
	std::timed_mutex my_mutex;	//	创建带超时功能的独占互斥量
};


int main()
{
	A myobj;
	thread	myInMsgObj(&A::inMsgRecvQueue, &myobj); 
	thread	myOutMsgObj(&A::outMsgRecvQueue, &myobj);
	myInMsgObj.join();
	myOutMsgObj.join();

	getchar();
	return 0;
}

try_lock_until()修改以上代码，使其功能一样：

// 把收到的消息传入队列
	void inMsgRecvQueue()
	{
		for (size_t i = 0; i < 1000; ++i)
		{
			cout << "收到消息，并放入队列 " << i << endl;

			if (my_mutex.try_lock_until(std::chrono::steady_clock::now() + 100ms))	//	设置时间点
			{
				msgRecvQueue.push_back(i);
				my_mutex.unlock();
			}
			else
			{
				cout << i << "入队列时没有取得锁 " << endl;
			}
		}

		cout << "消息入队结束" << endl;
	}