11.windows临界区，其他各种mutex互斥量

最新推荐文章于 2023-03-28 09:14:28 发布
最新推荐文章于 2023-03-28 09:14:28 发布
阅读量186 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42341040/article/details/108728952
版权

1.windows临界区

和c++11中的mutex非常类似

#include <iostream>
#include <thread>
#include<vector>
#include<string>
#include<queue>
#include<mutex>
#include<windows.h>
using namespace std;


#define __WINDOWSJQ__	//一个开关，用windows编程 临界区取代mutex
class A {
public:
	A() {
#ifdef __WINDOWSJQ__
		InitializeCriticalSection(&my_winsec);//用临界区之前要初始化
#endif
	}
	void inMsg() {
		for (int i = 0; i < 10000; i++) {
			cout << "插入一个元素:" << i << endl;
#ifdef __WINDOWSJQ__
			EnterCriticalSection(&my_winsec);//进入临界区（加锁）
			myQueue.push(i);
			LeaveCriticalSection(&my_winsec);//离开临界区（解锁）
#else
			//lock unlock成对保护数据
			myMutex.lock();
			myQueue.push(i);
			myMutex.unlock();
#endif
		}
	}
	void outMsg() {
		for (int i = 0; i < 10000; i++) {
#ifdef __WINDOWSJQ__
			EnterCriticalSection(&my_winsec);//进入临界区（加锁）
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
			LeaveCriticalSection(&my_winsec);//离开临界区（解锁）
#else

			myMutex.lock();
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
			myMutex.unlock();
#endif
		}
	}
private:
	queue<int>myQueue;//消息队列
	mutex myMutex;//互斥量
#ifdef __WINDOWSJQ__
	CRITICAL_SECTION my_winsec;//windows中的临界区，非常类似于c++11中的mutex
#endif
};

int main() {
	A myobj;
	thread outObj(&A::outMsg, &myobj);//第二个参数传入的是this指针 等价ref(myobj)
	thread inObj(&A::inMsg, &myobj);
	outObj.join();
	inObj.join();
	cout << "hello,world!" << endl;//最后执行这句话

	//输出正常
	return 0;

}

2.多次进入临界区试验

在同一线程中，windows中的“相同临界区变量”代表的临界区连续进入EnterCriticalSection可以多次，但是LeaveCriticalSection次数也要一样，而c++11 中mutex只能连续lock一次，unlock一次

#include <iostream>
#include <thread>
#include<vector>
#include<string>
#include<queue>
#include<mutex>
#include<windows.h>
using namespace std;


#define __WINDOWSJQ__	//一个开关，用windows编程 临界区取代mutex
class A {
public:
	A() {
#ifdef __WINDOWSJQ__
		InitializeCriticalSection(&my_winsec);//用临界区之前要初始化
#endif
	}
	void inMsg() {
		for (int i = 0; i < 10000; i++) {
			cout << "插入一个元素:" << i << endl;
#ifdef __WINDOWSJQ__
			//连续enter两次
			EnterCriticalSection(&my_winsec);//进入临界区 lock
			EnterCriticalSection(&my_winsec);//进入临界区 lock
			myQueue.push(i);
			LeaveCriticalSection(&my_winsec);//离开临界区 unlock
			LeaveCriticalSection(&my_winsec);//离开临界区 unlock
#else
			//lock unlock成对保护数据
			myMutex.lock();
			myQueue.push(i);
			myMutex.unlock();
#endif
		}
	}
	void outMsg() {
		for (int i = 0; i < 10000; i++) {
#ifdef __WINDOWSJQ__
			EnterCriticalSection(&my_winsec);//进入临界区
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
			LeaveCriticalSection(&my_winsec);//离开临界区
#else

			myMutex.lock();
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
			myMutex.unlock();
#endif
		}
	}
private:
	queue<int>myQueue;//消息队列
	mutex myMutex;//互斥量
#ifdef __WINDOWSJQ__
	CRITICAL_SECTION my_winsec;//windows中的临界区，非常类似于c++11中的mutex
#endif
};

int main() {
	/*
	 
		在同一线程中，windows中的“相同临界区变量”代表的临界区连续进入EnterCriticalSection可以多次，但是LeaveCriticalSection次数也要一样
		而c++11 中mutex只能连续lock一次，unlock一次
	 */
	A myobj;
	thread outObj(&A::outMsg, &myobj);//第二个参数传入的是this指针 等价ref(myobj)
	thread inObj(&A::inMsg, &myobj);
	outObj.join();
	inObj.join();
	cout << "hello,world!" << endl;//最后执行这句话

	//输出正常
	return 0;

}

3. 自动析构技术

RAII

#include <iostream>
#include <thread>
#include<vector>
#include<string>
#include<queue>
#include<mutex>
#include<windows.h>
using namespace std;


#define __WINDOWSJQ__	//一个开关，用windows编程 临界区取代mutex

//本例用于自动释放windows下的临界区，防止忘记LeaveCriticalSection导致死锁情况的发生，类似于cpp11中的std::lock_guard<mutex>
class CWinLock {//RAII类，资源获取即初始化
public:
	CWinLock(CRITICAL_SECTION* pCritmp) {
		m_pCritical = pCritmp;
		EnterCriticalSection(m_pCritical);
	}
	~CWinLock() {
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION* m_pCritical;
};
class A {
public:
	A() {
#ifdef __WINDOWSJQ__
		InitializeCriticalSection(&my_winsec);//用临界区之前要初始化
#endif
	}
	void inMsg() {
		for (int i = 0; i < 10000; i++) {
			cout << "插入一个元素:" << i << endl;
#ifdef __WINDOWSJQ__
		
			CWinLock wlock(&my_winsec);		
			myQueue.push(i);
#else
			
			std::lock_guard<mutex>sbguard(myMutex);
			myQueue.push(i);
			
#endif
		}
	}
	void outMsg() {
		for (int i = 0; i < 10000; i++) {
#ifdef __WINDOWSJQ__
			CWinLock wlock(&my_winsec);
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
#else

			std::lock_guard<mutex>sbguard(myMutex);
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
		
#endif
		}
	}
private:
	queue<int>myQueue;//消息队列
	mutex myMutex;//互斥量
#ifdef __WINDOWSJQ__
	CRITICAL_SECTION my_winsec;//windows中的临界区，非常类似于c++11中的mutex
#endif
};


int main() {
	/*

		在同一线程中，windows中的“相同临界区变量”代表的临界区连续进入EnterCriticalSection可以多次，但是LeaveCriticalSection次数也要一样
		而c++11 中mutex只能连续lock一次，unlock一次
	 */
	A myobj;
	thread outObj(&A::outMsg, &myobj);//第二个参数传入的是this指针 等价ref(myobj)
	thread inObj(&A::inMsg, &myobj);
	outObj.join();
	inObj.join();
	cout << "hello,world!" << endl;//最后执行这句话
	
	
	//输出正常
	return 0;

}

4.recursive_mutex递归的独占互斥量

问题提出：

#include <iostream>
#include <thread>
#include<vector>
#include<string>
#include<queue>
#include<mutex>
#include<windows.h>
using namespace std;


//#define __WINDOWSJQ__	//一个开关，用windows编程 临界区取代mutex

//本例用于自动释放windows下的临界区，防止忘记LeaveCriticalSection导致死锁情况的发生，类似于cpp11中的std::lock_guard<mutex>
class CWinLock {//RAII类，资源获取即初始化
public:
	CWinLock(CRITICAL_SECTION* pCritmp) {
		m_pCritical = pCritmp;
		EnterCriticalSection(m_pCritical);
	}
	~CWinLock() {
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION* m_pCritical;
};
class A {
public:
	A() {
#ifdef __WINDOWSJQ__
		InitializeCriticalSection(&my_winsec);//用临界区之前要初始化
#endif
	}
	void testfunc1() {
		std::lock_guard<mutex>sbguard(myMutex);
		//干各种事
		testfunc2();//连续lock两次了
	}
	void testfunc2() {
		std::lock_guard<mutex>sbguard(myMutex);
		//干各种其他事

	}
	void inMsg() {
		for (int i = 0; i < 10000; i++) {
			cout << "插入一个元素:" << i << endl;
#ifdef __WINDOWSJQ__
		
			CWinLock wlock(&my_winsec);		
			myQueue.push(i);
#else
			
			std::lock_guard<mutex>sbguard(myMutex);
			testfunc1();//连续lock 3次了，肯定崩溃	！！！！！！！！！！！！
			myQueue.push(i);
			
#endif
		}
	}
	void outMsg() {
		for (int i = 0; i < 10000; i++) {
#ifdef __WINDOWSJQ__
			CWinLock wlock(&my_winsec);
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
#else

			std::lock_guard<mutex>sbguard(myMutex);
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
		
#endif
		}
	}
private:
	queue<int>myQueue;//消息队列
	mutex myMutex;//互斥量
#ifdef __WINDOWSJQ__
	CRITICAL_SECTION my_winsec;//windows中的临界区，非常类似于c++11中的mutex
#endif
};


int main() {
	/*

		在同一线程中，windows中的“相同临界区变量”代表的临界区连续进入EnterCriticalSection可以多次，但是LeaveCriticalSection次数也要一样
		而c++11 中mutex只能连续lock一次，unlock一次
	 */
	A myobj;
	thread outObj(&A::outMsg, &myobj);//第二个参数传入的是this指针 等价ref(myobj)
	thread inObj(&A::inMsg, &myobj);
	outObj.join();
	inObj.join();
	cout << "hello,world!" << endl;//最后执行这句话
	
	
	//输出正常
	return 0;

}

解决：recursive_mutex
std::mutex独占互斥量，自己lock时别人lock不了
recursive_mutex : 递归的独占互斥量，允许同一个线程，同一个互斥量多次被连续lock()。使用它需要考虑代码是否有优化空间，效率上比mutex差。递归次数有限制。

#include <iostream>
#include <thread>
#include<vector>
#include<string>
#include<queue>
#include<mutex>
#include<windows.h>
using namespace std;


//#define __WINDOWSJQ__	//一个开关，用windows编程 临界区取代mutex

//本例用于自动释放windows下的临界区，防止忘记LeaveCriticalSection导致死锁情况的发生，类似于cpp11中的std::lock_guard<mutex>
class CWinLock {//RAII类，资源获取即初始化
public:
	CWinLock(CRITICAL_SECTION* pCritmp) {
		m_pCritical = pCritmp;
		EnterCriticalSection(m_pCritical);
	}
	~CWinLock() {
		LeaveCriticalSection(m_pCritical);
	}
private:
	CRITICAL_SECTION* m_pCritical;
};
class A {
public:
	A() {
#ifdef __WINDOWSJQ__
		InitializeCriticalSection(&my_winsec);//用临界区之前要初始化
#endif
	}
	void testfunc1() {
		std::lock_guard<recursive_mutex>sbguard(myMutex);
		//干各种事
		testfunc2();//连续lock两次了
	}
	void testfunc2() {
		std::lock_guard<recursive_mutex>sbguard(myMutex);
		//干各种其他事

	}
	void inMsg() {
		for (int i = 0; i < 10000; i++) {
			cout << "插入一个元素:" << i << endl;
#ifdef __WINDOWSJQ__
		
			CWinLock wlock(&my_winsec);		
			myQueue.push(i);
#else
			
			std::lock_guard<recursive_mutex>sbguard(myMutex);
			testfunc1();//连续lock 3次了，不报异常了	！！！！！！！！！！！！
			myQueue.push(i);
			
#endif
		}
	}
	void outMsg() {
		for (int i = 0; i < 10000; i++) {
#ifdef __WINDOWSJQ__
			CWinLock wlock(&my_winsec);
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
#else

			std::lock_guard<recursive_mutex>sbguard(myMutex);
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
		
#endif
		}
	}
private:
	queue<int>myQueue;//消息队列
	//mutex myMutex;//互斥量
	std::recursive_mutex myMutex;//递归独占互斥量
#ifdef __WINDOWSJQ__
	CRITICAL_SECTION my_winsec;//windows中的临界区，非常类似于c++11中的mutex
#endif
};


int main() {
	/*

		在同一线程中，windows中的“相同临界区变量”代表的临界区连续进入EnterCriticalSection可以多次，但是LeaveCriticalSection次数也要一样
		而c++11 中mutex只能连续lock一次，unlock一次
	 */
	A myobj;
	thread outObj(&A::outMsg, &myobj);//第二个参数传入的是this指针 等价ref(myobj)
	thread inObj(&A::inMsg, &myobj);
	outObj.join();
	inObj.join();
	cout << "hello,world!" << endl;//最后执行这句话
	
	
	//输出正常
	return 0;

}

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

5.1 time_mutex：带超时功能的独占互斥量

5.1.1 try_lock_for()：

是等待一段时间，如果我拿到了，或者等待超过时间没拿到锁，就走下来

#include <iostream>
#include <thread>
#include<vector>
#include<string>
#include<queue>
#include<mutex>
#include<windows.h>
using namespace std;


//#define __WINDOWSJQ__	//一个开关，用windows编程 临界区取代mutex


class A {
public:
	A() {

	}

	void inMsg() {
		for (int i = 0; i < 10000; i++) {
			cout << "插入一个元素:" << i << endl;

			myMutex.lock();
			std::chrono::milliseconds timeout(10);
			if (myMutex.try_lock_for(timeout)) {//等待10毫秒来尝试获取锁
				myQueue.push(i);
				myMutex.unlock();
			}
			else {
				//没拿到锁
				cout << "没拿到锁，休息会" << endl;
				std::chrono::microseconds sleeptime(100);//休息100微妙
				std::this_thread::sleep_for(sleeptime);
				myMutex.unlock();
			}

		}
	}
	void outMsg() {
		for (int i = 0; i < 10000; i++) {

			//std::lock_guard<recursive_mutex>sbguard(myMutex);
			myMutex.lock();
			std::chrono::milliseconds timeout(20);
			std::this_thread::sleep_for(timeout);
			if (!myQueue.empty()) {
				int command = myQueue.front();
				myQueue.pop();

			}
			else {
				cout << "队列为空，i = " << i << endl;

			}
			myMutex.unlock();
		}
	}
private:
	queue<int>myQueue;//消息队列
	//mutex myMutex;//互斥量
	std::timed_mutex myMutex;//递归独占互斥量

};


int main() {
	/*

		在同一线程中，windows中的“相同临界区变量”代表的临界区连续进入EnterCriticalSection可以多次，但是LeaveCriticalSection次数也要一样
		而c++11 中mutex只能连续lock一次，unlock一次
	 */
	A myobj;
	thread outObj(&A::outMsg, &myobj);//第二个参数传入的是this指针 等价ref(myobj)
	thread inObj(&A::inMsg, &myobj);
	outObj.join();
	inObj.join();
	cout << "hello,world!" << endl;//最后执行这句话
	
	
	//输出正常
	return 0;

}

5.1.2 try_lock_unti()：

参数一个未来的时间点，在未来时间没到的时间内，如果拿到了锁就走下来，没拿到也走下来
上面的代码改一句话就行：
在这里插入图片描述

5.2 std:recursive_timed_mutex: 带超时功能的递归独占互斥量

允许同一个线程连续多次获取互斥量
其他的差不多的

哞哞哞咩咩咩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#线程同步使用详解示例
12-31
在应用程序中使用多个线程的一个好处是每个线程都可以异步执行。对于 Windows 应用程序，...线程同步有：临界区、互斥区、事件、信号量四种方式临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、
17.12 windows临界区、其他各种mutex互斥量
zzyzxb的博客
06-24 278
windows临界区、其他各种mutex互斥量
C++11多线程 互斥量与Windows临界区
u012507022的博客
01-09 1723
1.Windows临界区 Windows临界区与互斥量用法非常相似；但也有些差别 在“同一个线程”(不同线程中会卡住等待)中， Windows中的“相同临界区变量”代表的临界区的进入(EnterCriticalSection)可以被多次调用，但是调用了几次EnterCriticalSection(),就得调用几次EnterCriticalSection() 而在C++11中，std::mut...
C++并发与多线程编程--windows临界区、其他mutex互斥量
locahuang的博客
07-24 219
1、windows临界区 临界区又称关键代码段，指的是一小段代码在代码执行前，它需要独占一些资源。 1.1 相关函数 （1）初始化 程序中通常将多线程同时访问的某个资源作为临界区，需要定义一个CRITICAL_SECTION类型的变量，然后调用InitializeCriticalSection函数对变量进行初始化； 函数原型：VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection ); 参数说明：lpCriticalSect..
windows临界区和互斥量效率_一篇文章带你解读：互斥锁、条件锁、读写锁以及自旋锁？
weixin_39844901的博客
11-23 572
锁是一个常见的同步概念，我们都听说过加锁(lock)或者解锁(unlock)，当然 学术一点地说法是获取(acquire)和释放(release)。 恰好pthread包含这几种锁的API，而C++11只包含其中的部分。接下来我将通过pthread的API来 展开回答。 mutex(互斥量) mutex(mutual exclusive)即互斥量(互斥体)。也便是常说的互斥锁。 尽管名称不含loc...
C++11并发与多线程笔记（12） windows临界区、其他各种mutex互斥量
视觉小浩
02-17 212
第十二节 windows临界区、其他各种mutex互斥量 一和二、windows临界区 在“同一个线程中”（不同线程就会卡主等待），windows中的“相同临界区变量”代表的临界区的进入（EnterCriticalSection）可以被多次调用。 Windows临界区，“同一个线程‘”是可以重复进入的，但是进入的次数与离开的次数必须相等，而不会引起程序异常报错。 C++互斥量mutex则不允许同一个线程重复加锁，会报异常。 windows临界区是windows编程中的内容，了解一下即可，效果几乎可以等同
C++11多线程编程.zip
09-24
C++11多线程编程.zip 代码实例 C++11多线程编程future其他成员函数、shared_future、atomic ...C++11多线程编程windows临界区、其他各种mutex互斥量 C++11多线程编程补充知识、线程池浅谈、数量谈、总结
在同步代码结束后，使用ReleaseMutex(THandle
08-18
2、线程Create()前用CreateMutex()来创建一个互斥量。该函数定义为： HANDLE WINAPI CreateMutex( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName:Pchar); LPSECURITY_...
生产者与消费者实验报告.docx
03-11
（2）基于环形缓冲区的生产 与消费者关系形式描述： 公用信号量mutex：初值为1，用于实现临界区互斥 生产者私用信号量empty：初值为n，指示空缓冲块数目 消费者私用信号量full：初值为0，指示满缓冲块数目 整型量i...
生产者-消费者模型模拟进程调度，带报告，课程设计
01-15
实验一 生产者-消费者模型模拟进程调度 ...接着请求该同步对象，随即进入临界区，这一步对应于互斥量的上锁；最后释放该同步对象，这对应于互斥量的解锁。这些同步对象在主进程中创建，在其子线程中都可。
std::mutex的使用备忘
smartcore
03-17 302
在实际测试中，与使用自实现的自旋做同步比较（看上也是自旋），std::mutex在效率上没有大的差异。 但是当出现竞争时，std::mutex的lock会完全的等待，此时CPU利用率会很高，当然其等待也是有收益的：效率最高。 但是，在一般的应用里，我们能查看任何管理器时，我们总是蜜汁不希望CPU满载（不想让风扇狂转？） 降低CPU负载的套路是：使用trylock。不光出让时间片，...
C++并发与多线程(十一)windows临界区、recursive_mutex、timed_mutex
Electro1ux的博客
02-02 408
windows临界区 windows临界区是在windows编程中的内容，了解一下即可，效果几乎可以等同于c++11的mutex；windows编程仅能在windows操作系统中使用，其它环境（例如linux）是不能正常运行的。 使用方法： //包含头文件 #include <Windows.h> CRITICAL_SECTION m_winsec; //windwos临界区定义 InitializeCriticalSection(&m_winsec); //windows临界区使用
C++ 线程同步之互斥锁
喜欢打篮球的普通人
06-19 5475
进行多线程编程，如果多个线程需要对同一块内存进行操作，比如：同时读、同时写、同时读写，对于后两种情况来说，如果不做任何的人为干涉就会出现各种各样的错误数据。解决多线程数据混乱的方案就是进行线程同步，最常用的就是互斥锁，在 C++11 中一共提供了四种互斥锁：不论是在 C 还是 C++ 中，进行线程同步的处理流程基本上是一致的，C++ 的 mutex 类提供了相关的 API 函数：成员函数 独占互斥锁对象有两种状态：锁定和未锁定。 除了使用 lock() 还可以使用 try_lock() 获取互斥锁
C++多线程编程(2) -- 互斥锁 信号量 事件 临界区
qq_34462436的博客
09-21 573
一、互斥锁 1、先熟悉熟悉API 1，创建互斥锁，并反正一个句柄 HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针 BOOLbInitialOwner, // 初始化互斥对象的所有者，一般设置为FALSE LPCTSTRlpName // 互斥对象名 ); 2，释放互斥对象的控制权 BOO...
【C++多线程同步】C++多线程同步和互斥的关键：std::mutex和相关类的全面使用教程与深度解析
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-10 1084
Mutex 系列类(四种) std::mutex，最基本的 Mutex 类 std::recursive_timed_mutex，递归 Mutex 类 std::timed_mutex，定时 Mutex 类。 std::recursive_timed_mutex，定时递归 Mutex Lock 类（两种） std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。 std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制
C++多线程 互斥锁 信号量 事件 临界区
小乌龟的博客
05-14 3413
一、互斥锁1、先熟悉熟悉API1，创建互斥锁，并反正一个句柄 HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针 BOOLbInitialOwner, // 初始化互斥对象的所有者，一般设置为FALSE LPCTSTRlpName // 互斥对象名 );2，释放互斥对象的控制权 BOOL ReleaseMu
Windows临界区
weixin_45983489的博客
03-10 1251
一、windows临界区 Windows临界区：（使用前必须初始化） //创建： CRITICAL_SECTION my_winsec;//创建windows中的临界区，类似与互斥量，使用前必须初始化 //初始化：（通常在类构造函数中初始化） InitializeCriticalSection(&my_winsec);//初始化临界区 //临界区使用： EnterCriticalSection(&my_winsec);//进入临界区（加锁） myQueue.push_back(i
Windows多线程-互斥量
luozhengxxf的专栏
03-28 71
Windows多线程使用互斥量互斥
pthread_mutex_lock和pthread_mutex_unlock如何实现临界区的互斥
最新发布
05-30
`pthread_mutex_lock` 和 `pthread_mutex_unlock` 是 POSIX 线程库提供的两个函数，用于实现互斥锁的加锁和解锁操作。通过这两个函数，可以实现多个线程对共享资源的互斥访问，从而避免并发访问时出现的数据竞争问题...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值