C++11并发与多线程笔记（12）windows临界区、其他各种mutex互斥量

最新推荐文章于 2023-05-14 20:22:13 发布
最新推荐文章于 2023-05-14 20:22:13 发布
阅读量590 收藏
点赞数
分类专栏： C++多线程 文章标签： c++ 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/badmanWang/article/details/121176045
版权

文章目录

1、Windows临界区

1.1 创建Windows临界区

  • CRITICAL_SECTION 临界区名
CRITICAL_SECTION my_winsec;	//Windows中的临界区，非常类似于c++11中的mutex

1.2 临界区初始化

  • InitializeCriticalSection(临界区名)
InitializeCriticalSection(&my_winsec);		//用临界区之前要先初始化

1.3 进入临界区

  • EnterCriticalSection(临界区名)
EnterCriticalSection(&my_winsec);		//进入Windows临界区，和mutex加锁一个道理

1.4 离开临界区

  • LeaveCriticalSection(临界区名)
LeaveCriticalSection(&my_winsec);		//离开Windows临界区，和mutex解锁一个道理

1.5 示例代码

#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <Windows.h>
using namespace std;

#define __WINDOWSJQ_

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

#ifdef __WINDOWSJQ_
			EnterCriticalSection(&my_winsec);		//进入Windows临界区，和mutex加锁一个道理
			msgRecvQueue.push_back(i);
			LeaveCriticalSection(&my_winsec);		//离开Windows临界区，和mutex解锁一个道理
#else
			my_mutex.lock();
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
#endif // __WINDOWSJQ_
		}
		return;
	}

	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 // __WINDOWSJQ_

		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;

		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULProc(command);

			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << 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 myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

2、多次进入临界区试验

  • 在同一个线程中，Windows中的相同临界区变量代表的临界区可以被多次进入（EnterCriticalSection），但是调用了几次EnterCriticalSection就得调用几次LeaveCriticalSection。
  • 但是c++11中的同一个mutex是不支持在同一个线程中多次lock()和unlock()的，否则报异常。
EnterCriticalSection(&my_winsec);		//进入Windows临界区，和mutex加锁一个道理
EnterCriticalSection(&my_winsec);
msgRecvQueue.push_back(i);
LeaveCriticalSection(&my_winsec);		//离开Windows临界区，和mutex解锁一个道理
LeaveCriticalSection(&my_winsec);

3、自动析构技术

  • 编写一个类实现自动进入临界区和离开临界区，和C++11的lock_guard一样。

示例代码：

类代码：

class CWinLock	//叫RAII类（Resource Acquisition is initialization）中文：“资源获取即初始化”
{
public:
	CWinLock(CRITICAL_SECTION* pCritmp)		//构造函数
	{
		m_pCritical = pCritmp;
		EnterCriticalSection(m_pCritical);
	}

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

private:
	CRITICAL_SECTION* m_pCritical;

};

程序整体代码：

#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <Windows.h>
using namespace std;

#define __WINDOWSJQ_

class CWinLock	//叫RAII类（Resource Acquisition is initialization）中文：“资源获取即初始化”
{
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 < 100000; i++)
		{
			cout << "inMsgRecvQueue()执行，插入一个元素：" << i << endl;

#ifdef __WINDOWSJQ_
			//EnterCriticalSection(&my_winsec);		//进入Windows临界区，和mutex加锁一个道理
			CWinLock wlock(&my_winsec);
			CWinLock wlock2(&my_winsec);			//可以多次调用
			msgRecvQueue.push_back(i);
			//LeaveCriticalSection(&my_winsec);	//离开Windows临界区，和mutex解锁一个道理
#else
			my_mutex.lock();
			msgRecvQueue.push_back(i);
			my_mutex.unlock();
#endif // __WINDOWSJQ_
		}
		return;
	}

	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 // __WINDOWSJQ_

		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;

		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULProc(command);

			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << 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 myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

4、recursive_mutex

  • recursive_mutex：递归的独占互斥量，允许同一个线程，同一个互斥量被多次lock()。
  • recursive_mutex也有lock()和unlcok()。
  • 递归次数有限，递归太多次可能报异常，一般情况下，够用。
  • 使用recursive_mutex时，要考虑代码是否有优化空间。

示例代码：

#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <Windows.h>
using namespace std;

class A
{
public:
	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			std::lock_guard<std::recursive_mutex> sbguard(my_mutex);
			testfunc1();

			msgRecvQueue.push_back(i);
             cout << "inMsgRecvQueue()执行，插入一个元素：" << i << endl;
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		std::lock_guard<std::recursive_mutex> sbguard(my_mutex);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();		//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();							//移除第一个元素，但不返回
			return true;
		}
		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;

		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULProc(command);

			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
	}

	void testfunc1()
	{
		std::lock_guard<std::recursive_mutex> sbguard(my_mutex);
		//......
		testfunc2();
	}

	void testfunc2()
	{
		std::lock_guard<std::recursive_mutex> sbguard(my_mutex);
		//......
	}

private:
	list<int> msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	std::recursive_mutex my_mutex;	//创建了一个递归独占互斥量
};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

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

5.1 std::timed_mutex

  • 带超时功能的独占互斥量

try_lock_for()

  • 等待一段时间。

  • 参数是一段时间。

  • 如果在等待时间内拿到了锁，或者超过等待时间没拿到锁，就会继续走下去。

  • 示例代码：

    #include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <Windows.h>
using namespace std;

class A
{
public:
	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			msgRecvQueue.push_back(i);

			std::chrono::milliseconds timeout(100);	//100ms
			if (my_mutex.try_lock_for(timeout))		//等待100ms来尝试获取锁
			{
				//再100ms内拿到了锁
				msgRecvQueue.push_back(i);
				cout << "inMsgRecvQueue()执行，插入一个元素：" << i << endl;
				my_mutex.unlock();		//用完了要解锁
			}
			else
			{
				//这次没拿到锁头，休息一下，休息完再尝试
				std::chrono::milliseconds sleeptime(100);
				std::this_thread::sleep_for(sleeptime);
			}
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		my_mutex.lock();
		std::chrono::milliseconds cutTime(100000);
		std::this_thread::sleep_for(cutTime);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();		//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();							//移除第一个元素，但不返回
             my_mutex.unlock();
			return true;
		}
         my_mutex.unlock();

		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;

		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULProc(command);

			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
	}
    
private:
	list<int> msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	std::timed_mutex my_mutex;		//创建了一个带超时功能的独占互斥量


};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

try_lock_until()

  • 参数是一个未来的时间点，在还没有到未来时间点的这段时间内，如果拿到了锁头，流程就走下来，如果时间到了没拿到锁，流程也会走下来。

    #include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <Windows.h>
using namespace std;

class A
{
public:
	//把收到的消息（玩家命令）入到一个队列的线程
	void inMsgRecvQueue()
	{
		for (int i = 0; i < 100000; i++)
		{
			msgRecvQueue.push_back(i);

			std::chrono::milliseconds timeout(100);	//100ms
             //std::chrono::steady_clock::now() 当前时间
			if (my_mutex.try_lock_until(std::chrono::steady_clock::now() + timeout))
			{
				//再100ms内拿到了锁
				msgRecvQueue.push_back(i);
				cout << "inMsgRecvQueue()执行，插入一个元素：" << i << endl;
				my_mutex.unlock();		//用完了要解锁
			}
			else
			{
				//这次没拿到锁头，休息一下，休息完再尝试
				std::chrono::milliseconds sleeptime(100);
				std::this_thread::sleep_for(sleeptime);
			}
		}
		return;
	}

	bool outMsgLULProc(int& command)
	{
		my_mutex.lock();
		std::chrono::milliseconds cutTime(100000);
		std::this_thread::sleep_for(cutTime);
		if (!msgRecvQueue.empty())
		{
			//消息不为空
			command = msgRecvQueue.front();		//返回第一个元素，但不检查元素是否存在
			msgRecvQueue.pop_front();							//移除第一个元素，但不返回
             my_mutex.unlock();
			return true;
		}
         my_mutex.unlock();

		return false;
	}

	//把数据从消息队列中取出的线程
	void outMsgRecvQueue()
	{
		int command = 0;

		for (int i = 0; i < 100000; i++)
		{
			bool result = outMsgLULProc(command);

			if (result == true)
			{
				cout << "outMsgRecvQueue()执行，取出一个元素" << command << endl;
				//接下来就考虑处理数据......
			}
			else
			{
				//消息队列为空
				cout << "outMsgRecvQueue()执行，但目前消息队列中为空" << i << endl;
			}
		}
	}
    
private:
	list<int> msgRecvQueue;		//容器，专门用于代表玩家给咱们发送过来的命令
	std::timed_mutex my_mutex;		//创建了一个带超时功能的独占互斥量


};

int main()
{
	A myobja;
	thread myOutnMsgObj(&A::outMsgRecvQueue, &myobja);
	thread myInMsgObj(&A::inMsgRecvQueue, &myobja);

	myInMsgObj.join();
	myOutnMsgObj.join();


	cout << "I live China!" << endl;	//最后执行这句，整个进程退出

	system("pause");
	return 0;
}

5.2 std::recursive_timed_mutex

  • 带超时功能的递归独占互斥量
  • 允许同一个线程多次获取这个互斥量，可以多次lock()和unlock()。
  • 同std::recursive_mutex一样，只不过和std::timed_mutex一样，多了一个超时功能。

注：本人学习c++多线程视频地址：C++多线程学习地址

Jack丶Wang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++并发与多线程-运行时选择线程数量
01-20
使用std::thread::hardware_concurrency() 来获得当前系统可以真正并发的线程数量，和cpu的核心数有关。 #include #include #include #include #include #include std::mutex g_lock; template struct accumulate_...
C++11并发与多线程总结(五) -- window临界区
Rice__的博客
03-25 548
(1)简介 不同的操作系统有不同的API,使用方式不同,即不可跨平台 而在C++中使用的多线程接口函数都从语言本身,而不是操作系统,即可跨平台 简单了解一些Windows的临界区涨知识 (2)使用方法 1.进入临界区相当于加锁 2.可多次进入临界区 3.进入几次临界区就要调通几次离开临界区函数,否则死锁 先定义临界区变量 CRITICAL_SECTION m_winCritic...
C++11 std::thread 与 windows 运行库API _beginthreadex ；C++11 std::mutex 与 CriticalSection 的对比
chenjian60665的博客
09-11 1714
C++11 std::thread 标准库函数，跨平台；使用方便 _beginthreadex 相对createThread 安全；与std::thread 性能基本持平（VS2013测试）；使用上_beginthreadex 与createThread基本一样而std::thread 使用相对方便； C++11 std::mutex 与 CriticalSection 的对比； 如果是进程...
14C++11多线程编程之Windows临界区和各种互斥量(recursive_mutex,std::timed_mutex,recursive_timed_mutex)
weixin_44517656的博客
01-03 303
1 Windows临界区 1）Windows临界区与C++11的mutex的区别：mutex不能多次lock，而Windows的临界区可以多次进入，即EnterCriticalSection，但是进入多少次临界区就需要多次LeaveCriticalSection离开临界区。若少解锁即多上锁，它不会报错，但是它的现象的只会在该线程工作。看下图，当我inMsg少解锁了一篇，只在inMsg中插入。 2）正确的Windows临界区代码 #include<iostream> #include&l
C++11多线程：windows临界区和Linux互斥锁、递归锁的区别与使用。
weixin_55491446的博客
05-14 977
多线程windows临界区和Linux互斥锁提示：以下是本篇文章正文内容，下面案例可供参考（1）了解windows临界区；（2）了解linux递归锁和互斥锁；（3）了解基本函数的使用。
C++11并发规则：临界区越短越好
个人工作中学到的专业技术与职业发展知识笔记
05-26 272
将锁的作用域范围做到最小： std::mutex mutex_; 修改前： void func1() { std::lock_guard<std::mutex> lck(mutex_); num = 1; std::cout << "changed num" << std::endl; } 修改后： void func1() { // 缩短锁的生命周期/作用域 { std::lock_guard
c++11多线程库之互斥库使用
03-25
c++多线程库的使用demo，介绍了互斥库 mutex的使用方式
C++11多线程编程.zip
09-24
C++11多线程编程.zip 代码实例 C++11多线程编程future其他成员函数、shared_future、atomic ...C++11多线程编程windows临界区、其他各种mutex互斥量 C++11多线程编程补充知识、线程池浅谈、数量谈、总结
Linux线程同步之互斥量（mutex）
01-09
当然如果一个互斥量存放在多个进程共享的某个内存区中，那么还可以通过互斥量来进行进程间的同步。 　互斥量，从字面上可以知道是相互排斥的意思，它是基本的同步工具，用于保护临界区（共享资源），以保证在任何...
C++11 并发指南之std::mutex详解
08-25
主要介绍了C++11 并发指南之std::mutex详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C++多线程临界区
11-04
vs2010C++多线程临界区小案例 简单明了，适合初学者，，，
C++11多线程 互斥量与Windows临界区
u012507022的博客
01-09 1723
1.Windows临界区 Windows临界区与互斥量用法非常相似；但也有些差别 在“同一个线程”(不同线程中会卡住等待)中， Windows中的“相同临界区变量”代表的临界区的进入(EnterCriticalSection)可以被多次调用，但是调用了几次EnterCriticalSection(),就得调用几次EnterCriticalSection() 而在C++11中，std::mut...
C++多线程编程视频教程（C++11多线程并发）
10-29
线程与进程相比，它是一种花销小，切换快，更节俭的多任务的操作方式。多编程并发在企业中开发显得尤为重要，本课程包含Windows多线程编程与C++11高并发编程，通过浅显易懂的代码与讲解，让你的多线程编程能力得到质的飞跃，具备开发高并发代码的能力!
C++11多线程编程
09-06
本课程，讲解的重点定位在c++11新标准中的多线程开发部分，同时，老师还会结合自己的经验把多线程的讲解进一步拓展到一个比较大的范畴，因为无论是c++11多线程开发还是各种其他的多线程开发实现方法，都有很多类似的地方或者说是相通的理论、技巧和要遵循的规则；
C++11并发与多线程笔记（12） windows临界区、其他各种mutex互斥量
Cxiao_mengxin的博客
02-13 131
C++ 多线程编程
C++11 多线程编程 12.windows临界区、其他各种mutex互斥量
guonengneng的博客
09-07 210
#include<iostream> #include<mutex> #include<future> #include<vector> #include<queue> #include<list> #include<Windows.h> //#define __WINDOWSJQ_//处于定义状态 using namespace std; //本类用于自动释放windows下的临界区，防止忘记EnterCriticalS
C++多线程之使用Mutex和Critical_Section
weixin_33982670的博客
04-21 170
2019独角兽企业重金招聘Python工程师标准>>> ...
临界区多线程互斥c语言 银行存取款
最新发布
01-04
临界区是指在多线程编程中，多个线程共享的临界资源对应的代码片段。例如，在一个银行存取款的场景中，假设有多个客户同时进行存取款操作，每个客户对应一个线程。为了保证数据的一致性和正确性，需要通过临界区来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值