Win32 互斥体

已于 2023-12-13 18:05:53 修改
阅读量114 收藏
点赞数
分类专栏： 滴水逆向 文章标签： windows
于 2023-12-12 16:53:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77816603/article/details/134953749
版权

 1.WaitForSingleObject

示例代码：

DWORD WINAPI ThreadProc1(LPVOID lpParameter)					
{					
	for(int i=0;i<5;i++)				
	{				
		printf("+++++++++\n");			
		Sleep(1000);			
	}				
	return 0;				
}					
					
int main(int argc, char* argv[])					
{					
					
	//创建一个新的线程				
	HANDLE hThread1 = ::CreateThread(NULL, 0, ThreadProc1, 				
		NULL, 0, NULL);			
					
	DWORD dwCode = ::WaitForSingleObject(hThread1, INFINITE);				
					
	MessageBox(0,0,0,0);				
					
	return 0;				
}

2.WaitForMultipleObjects

 详情请参见：WaitForSingleObject等待函数

WaitForSingleObject函数在等待成功呢时通常不会修改状态，但是在遇到自动重置事件作为对象时（CreateEvent函数第二个参数是false时），就会自动将事件的状态修改为未通知状态。

代码演示：

DWORD WINAPI ThreadProc1(LPVOID lpParameter)							
{							
	for(int i=0;i<5;i++)						
	{						
		printf("+++++++++\n");					
		Sleep(1000);					
	}						
	return 0;						
}							
							
DWORD WINAPI ThreadProc2(LPVOID lpParameter)							
{							
	for(int i=0;i<3;i++)						
	{						
		printf("---------\n");					
		Sleep(1000);					
	}						
							
	return 0;						
}							
							
							
int main(int argc, char* argv[])							
{							
							
	HANDLE hArray[2];						
							
	//创建一个新的线程						
	HANDLE hThread1 = ::CreateThread(NULL, 0, ThreadProc1, 						
		NULL, 0, NULL);					
							
	//创建一个新的线程						
	HANDLE hThread2 = ::CreateThread(NULL, 0, ThreadProc2, 						
		NULL, 0, NULL);					
							
	hArray[0] = hThread1;						
	hArray[1] = hThread2;						
							
	DWORD dwCode = ::WaitForMultipleObjects(2, hArray,FALSE,INFINITE);						
							
	MessageBox(0,0,0,0);						
							
	return 0;						
}

3.跨进程的线程控制——互斥体

CreateMutex函数第二个参数是true时，表示初始化创建互斥体占有者立即占用该内核对象，即其他的WaitFor只能阻塞

参见：CreateMutex用法 

OpenMutex函数用于在多进程时能够获取其他进程互斥体，并赋予新的句柄。

	
	进程一：
	
	HANDLE g_hMutex = CreateMutex(NULL,FALSE, "XYZ");
	
	
	进程二：
	
	HANDLE g_hMutex = OpenMutex(MUTEX_ALL_ACCESS,FALSE, "XYZ");
	
	WaitForSingleObject(g_hMutex,INFINITE);
	
	//逻辑代码
	
	ReleaseMutex(g_hMutex);
	
	
	进程三：
	
	HANDLE g_hMutex = OpenMutex(MUTEX_ALL_ACCESS,FALSE, "XYZ");
	
	WaitForSingleObject(g_hMutex,INFINITE);
	
	//逻辑代码
	
	ReleaseMutex(g_hMutex);

这里互斥体可以实现对于多个进程之间线程的控制，假如在进程1中创建一个互斥体，

在进程2中OpenMutex打开一个命名的互斥体，然后使用WaitForSingleObject函数，可以实现对于线程的自愿等待。效果类似前面学习的临界区

 互斥体与临界区的区别：

1.临界区只能用于单个进程中线程的控制

互斥体可以用于不同进程中的线程控制，通过WaitForSingleObject函数实现线程的控制

2.互斥体可以设置等待超时，临界区不可以

互斥体可以通过WaitForSingleObject函数第三个参数，实现是否超时

3.线程意外终结时，Mutex可以避免无限等待

如果使用临界区时，中途发生了线程终止，那么就无法“归还令牌”，那么后面的线程就无法获取令牌，线程就无法运行

通过实验可知：互斥体的方式是通过判断线程内核对象是否通知的状态来判断是否等待

如果前面的线程意外终止，那么就会被认定为被通知状态，WaitForSingleObject函数就会停止等待，运行下面的代码

4.互斥体的效率没有临界区高

4.作业：

1.使用临界区的方式： 

   
#include "stdafx.h"
#include<windows.h>
#include"resource.h"
#include<stdio.h>
 
HWND hEdit1;
HWND hEdit2;
HWND hEdit3;
HWND hEdit4;
 
HANDLE hThread1;
 
HANDLE hThread2;
 
HANDLE hThread3;

HANDLE g_hMutex;

CRITICAL_SECTION cs;			

DWORD WINAPI ThreadProc1(LPVOID lpParameter)    ///线程函数1-----------------------------------
{	
	TCHAR szBuffer[10];	
	memset(szBuffer,0,10);
	DWORD dwIndex = 0;				
	int dwCount=0;	

    EnterCriticalSection(&cs);			

	while(dwIndex<50)				
	{
		GetWindowText(hEdit1,szBuffer,10);			
		sscanf( szBuffer, "%d", &dwCount );	
		if(dwCount<=50)
		{
			ExitThread(2);
		}
		dwCount--;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit1,szBuffer);	
		
		memset(szBuffer,0,10);
		dwCount=0;
		GetWindowText(hEdit2,szBuffer,10);		//修改EditText1值		
		sscanf( szBuffer, "%d", &dwCount );		
		dwCount++;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit2,szBuffer);			
		
		dwIndex++;			
	}
	LeaveCriticalSection(&cs);
		return 0;	
}
 
DWORD WINAPI ThreadProc2(LPVOID lpParameter)    ///线程函数2-----------------------------------
{
	TCHAR szBuffer[10];	
	memset(szBuffer,0,10);
	DWORD dwIndex = 0;				
	int dwCount=0;	
	
	EnterCriticalSection(&cs);			

	
	while(dwIndex<50)				
	{
		GetWindowText(hEdit1,szBuffer,10);			
		sscanf( szBuffer, "%d", &dwCount );	
		if(dwCount<=50)
		{
			ExitThread(2);
		}
		dwCount--;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit1,szBuffer);	

		memset(szBuffer,0,10);
		dwCount=0;
		GetWindowText(hEdit3,szBuffer,10);	//修改第二功能块值		
		sscanf( szBuffer, "%d", &dwCount );	
		dwCount++;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit3,szBuffer);	
		
		dwIndex++;	
	}	
	
	LeaveCriticalSection(&cs);			
	return 0;	
}
 
DWORD WINAPI ThreadProc3(LPVOID lpParameter)    ///线程函数2-----------------------------------
{
	
	
	TCHAR szBuffer[10];	
	memset(szBuffer,0,10);
	DWORD dwIndex = 0;				
	DWORD dwCount=0;				
		
	EnterCriticalSection(&cs);			
			
	while(dwIndex<50)				
	{
		GetWindowText(hEdit1,szBuffer,10);			
		sscanf( szBuffer, "%d", &dwCount );	
		if(dwCount<=50)
		{
			ExitThread(2);
		}
		dwCount--;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit1,szBuffer);

		memset(szBuffer,0,10);
		dwCount=0;
		GetWindowText(hEdit4,szBuffer,10);	//修改第3功能块值		
		sscanf( szBuffer, "%d", &dwCount );			
		dwCount++;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit4,szBuffer);			
	
		dwIndex++;		
	}
	LeaveCriticalSection(&cs);			

	return 0;	
}
 
DWORD WINAPI ThreadProc4(LPVOID lpParameter)
{
	while(1)
	{
		hThread1=CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);
 
		hThread2=CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);
 
		hThread3=CreateThread(NULL,0,ThreadProc3,NULL,0,NULL);
 
		CloseHandle(hThread1);
		CloseHandle(hThread2);
		CloseHandle(hThread3);
		Sleep(500);

		DWORD num=0;
	
	}
	CloseHandle(g_hMutex);
	
	return 0;
}
 
BOOL CALLBACK MainDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)					
{					
					
						
		switch(uMsg)				
		{				
		case WM_CLOSE:				
			{			
				EndDialog(hDlg,0);		
				break;		
			}			
		case WM_INITDIALOG:				
			{			
				hEdit1 = GetDlgItem(hDlg,IDC_EDIT1);		
				SetWindowText(hEdit1,"1000");
				
				hEdit2 = GetDlgItem(hDlg,IDC_EDIT2);		
				SetWindowText(hEdit2,"0");
				
				hEdit3 = GetDlgItem(hDlg,IDC_EDIT3);		
				SetWindowText(hEdit3,"0");
 
				hEdit4 = GetDlgItem(hDlg,IDC_EDIT4);		
				SetWindowText(hEdit4,"0");
				break;		
			}			
		case WM_COMMAND:				
			{		
				switch (LOWORD (wParam))			
				{			
				case IDC_BUTTON1:			
					{		
						HANDLE hThread4=CreateThread(NULL,0,ThreadProc4,NULL,0,NULL);
						CloseHandle(hThread4);
						return TRUE;	
					}		
					
				}			
						
						
			}		
			break;			
		}
		return FALSE;
}
 
 
 
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
	InitializeCriticalSection(&cs);			

 
 	DialogBox(hInstance,MAKEINTRESOURCE(IDD_DIALOG_MAIN),NULL,MainDlgProc);	
 
	
 
	//Sleep(99999*99999);
	return 0;
}

我们要注意，想要循环实现抢红包的功能不可以直接在函数里循环创建线程，因为此时对话框界面还有消息处理函在主线程中，所以必须单独创建一个线程来创建三个线程，不然就会发生线程抢占

2.使用Mutex互斥体的方式：

 
#include "stdafx.h"
#include<windows.h>
#include"resource.h"
#include<stdio.h>
 
HWND hEdit1;
HWND hEdit2;
HWND hEdit3;
HWND hEdit4;
 
HANDLE hThread1;
 
HANDLE hThread2;
 
HANDLE hThread3;

HANDLE g_hMutex;

DWORD WINAPI ThreadProc1(LPVOID lpParameter)    ///线程函数1-----------------------------------
{	
	TCHAR szBuffer[10];	
	memset(szBuffer,0,10);
	DWORD dwIndex = 0;				
	int dwCount=0;	

	g_hMutex=CreateMutex(NULL,FALSE,"XYZ");	
	WaitForSingleObject(g_hMutex,-1);

	while(dwIndex<50)				
	{
		GetWindowText(hEdit1,szBuffer,10);			
		sscanf( szBuffer, "%d", &dwCount );	
		if(dwCount<=50)
		{
			ExitThread(2);
		}
		dwCount--;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit1,szBuffer);	
		
		memset(szBuffer,0,10);
		dwCount=0;
		GetWindowText(hEdit2,szBuffer,10);		//修改EditText1值		
		sscanf( szBuffer, "%d", &dwCount );		
		dwCount++;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit2,szBuffer);			
		
		dwIndex++;			
	}
		ReleaseMutex(g_hMutex);
		return 0;	
}
 
DWORD WINAPI ThreadProc2(LPVOID lpParameter)    ///线程函数2-----------------------------------
{
	TCHAR szBuffer[10];	
	memset(szBuffer,0,10);
	DWORD dwIndex = 0;				
	int dwCount=0;	
	
	WaitForSingleObject(g_hMutex,-1);
	
	while(dwIndex<50)				
	{
		GetWindowText(hEdit1,szBuffer,10);			
		sscanf( szBuffer, "%d", &dwCount );	
		if(dwCount<=50)
		{
			ExitThread(2);
		}
		dwCount--;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit1,szBuffer);	

		memset(szBuffer,0,10);
		dwCount=0;
		GetWindowText(hEdit3,szBuffer,10);	//修改第二功能块值		
		sscanf( szBuffer, "%d", &dwCount );	
		dwCount++;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit3,szBuffer);	
		
		dwIndex++;	
	}	
	
	ReleaseMutex(g_hMutex);				
	return 0;	
}
 
DWORD WINAPI ThreadProc3(LPVOID lpParameter)    ///线程函数2-----------------------------------
{
	WaitForSingleObject(g_hMutex,-1);
	
	TCHAR szBuffer[10];	
	memset(szBuffer,0,10);
	DWORD dwIndex = 0;				
	DWORD dwCount=0;				
						
	while(dwIndex<50)				
	{
		GetWindowText(hEdit1,szBuffer,10);			
		sscanf( szBuffer, "%d", &dwCount );	
		if(dwCount<=50)
		{
			ExitThread(2);
		}
		dwCount--;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit1,szBuffer);

		memset(szBuffer,0,10);
		dwCount=0;
		GetWindowText(hEdit4,szBuffer,10);	//修改第3功能块值		
		sscanf( szBuffer, "%d", &dwCount );			
		dwCount++;			
		memset(szBuffer,0,10);			
		sprintf(szBuffer,"%d",dwCount);			
		SetWindowText(hEdit4,szBuffer);			
	
		dwIndex++;		
	}
	ReleaseMutex(g_hMutex);
	return 0;	
}
 
DWORD WINAPI ThreadProc4(LPVOID lpParameter)
{
	while(1)
	{
		hThread1=CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);
 
		hThread2=CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);
 
		hThread3=CreateThread(NULL,0,ThreadProc3,NULL,0,NULL);
 
		CloseHandle(hThread1);
		CloseHandle(hThread2);
		CloseHandle(hThread3);
		Sleep(500);

		DWORD num=0;
		if(GetExitCodeThread(hThread1,&num)==2 || GetExitCodeThread(hThread2,&num)==2 || GetExitCodeThread(hThread3,&num)==2)
		{
			ExitThread(3);
		}
	}
	CloseHandle(g_hMutex);
	
	return 0;
}
 
BOOL CALLBACK MainDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)					
	{					
					
						
		switch(uMsg)				
		{				
		case WM_CLOSE:				
			{			
				EndDialog(hDlg,0);		
				break;		
			}			
		case WM_INITDIALOG:				
			{			
				hEdit1 = GetDlgItem(hDlg,IDC_EDIT1);		
				SetWindowText(hEdit1,"1000");
				
				hEdit2 = GetDlgItem(hDlg,IDC_EDIT2);		
				SetWindowText(hEdit2,"0");
				
				hEdit3 = GetDlgItem(hDlg,IDC_EDIT3);		
				SetWindowText(hEdit3,"0");
 
				hEdit4 = GetDlgItem(hDlg,IDC_EDIT4);		
				SetWindowText(hEdit4,"0");
				break;		
			}			
		case WM_COMMAND:				
						
			switch (LOWORD (wParam))			
			{			
			case IDC_BUTTON1:			
				{		
					HANDLE hThread4=CreateThread(NULL,0,ThreadProc4,NULL,0,NULL);
					CloseHandle(hThread4);
					return TRUE;	
				}		
				
			}			
			break ;			
		}				
						
		return FALSE;				
	}					
 
 
 
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
	
 
 	DialogBox(hInstance,MAKEINTRESOURCE(IDD_DIALOG_MAIN),NULL,MainDlgProc);	
 
	
 
	//Sleep(99999*99999);
	return 0;
}

llzhou.
关注
专栏目录
Win32学习笔记(11)互斥体
wzprabbit的博客
12-24 827
1.内核级临界资源怎么办？ 之前我们的临界资源是一个全局变量，它是在同一个进程中由两个或者多个线程共享的，可是如果我们把临界资源放到内核中想要实现跨进程的共享怎么办呢？我们之前实现临界区的时候哪个进程拿到令牌哪个进程就使用临界资源。那么是不是在内核中也类似令牌的东西？ 2.互斥体的使用 我们可以把互斥体看作是内核中的令牌。 如图所示： 原理：当X线程访问临界资源时会先判断能否访问如果可以访问（得到令牌）那么就可以使用临界资源，这时Y线程判断是否可以访问，肯定是不行的那么Y线程就等待X线.
win32 - 互斥体 - 防止程序多开
stmlg的博客
05-13 1056
1. 内核级别的临界资源怎么办? 上面的情况是针对 同一个进程 的多个线程访问 临界资源的线程安全问题. 那么多个进程(跨进程也就意味着不同线程) 访问 临界资源 那不简单么? 还是用临界区的线程锁不就行了? 你个hape, 线程锁是针对一个进程里边的多个线程,所以可以在进程申请一个令牌, 实现多个线程问题. 但是现在的问题是 多个进程 (跨进程)访问内核的临界资源. 你在你的进程A里边申请一个令牌, 进程B不能使用啊. 你在你的进程B申请的令牌,进程A不能使用啊. 于是 , 我们把令牌 放到了.
Win32 进程间互斥示例代码 Process 1
小发猫
05-24 1416
Win32 进程间互斥示例代码 Process 1
win32线程学习总结（临界区，互斥体，事件，信号量）
hambaga的博客
06-29 462
一、临界区 CRITICAL_SECTION 例程 https://blog.csdn.net/Kwansy/article/details/106485496 临界区用于资源互斥访问，性能比互斥体好。 二、互斥体 mutex 例程 https://blog.csdn.net/Kwansy/article/details/106485496 互斥体也是用于对资源互斥访问，性能比临界区差，但可以跨进程使用，详见CreateMutex 第三个参数。 三、事件 event 例程 https://blog.csdn
Win32多线程之WaitForMultipleObjects
wjj715211的专栏
11-21 1792
Win32函数中的WaitForMultipleObjects()允许你在同一时间等待一个以上的对象。你必须将一个由handles组成的数组交给此函数，并指定要等待其中一个对象或是全部的对象，下面就是这个函数的原型： DWORD WaitForMultipleObjects( DWORD nCount, const HANDLE* lpHandles, BOOL bWa
WaitForMultipleObjects
zxl0726的专栏
06-29 428
　WaitForMultipleObjects是Windows中的一个功能非常强大的函数，几乎可以等待Windows中的所有的内核对象（关于该函数的描述和例子见MSDN，）。但同时该函数在用法上却需要一定的技巧。 　　原型：DWORD WaitForMultipleObjects( 　　DWORD nCount, 　　const HANDLE* lpHandles, 　　BOOL bWaitAll, 　　DWORD dwMilliseconds 　　); 　　当WaitForMultipleObjects等
windows笔记-【内核对象线程同步】等待函数
weixin_30670151的博客
09-03 325
等待函数可使线程自愿进入等待状态，直到一个特定的内核对象变为已通知状态为止。 WaitForSingleObject 函数 DWORD WaitForSingleObject( HANDLE hObject, DWORD dwMilliseconds ); 第一个参数hObject标识一个能够支持被通知/未通知的内核对象（前面列出的任何一种对象都适用）。 ...
使用win32互斥体来确定应用程序实例是否是第一个
最新发布
10-23
在某些情况下，应用程序需要确保它是...这可以使用互斥锁来完成。关于在不同登录会话中运行的应用程序，有几个细节需要考虑，如果这些实例是磁盘上的不同副本，是否允许运行多个实例。 互斥锁函数 HANDLE CreateMutexA
Hook函数CreateMutexA拦截互斥体创建
06-03
在这个场景中，我们关注的是`CreateMutexA`函数的钩子，这是一个用于创建互斥体（Mutex）的API。互斥体是多线程编程中一个重要的同步对象，它确保同一时间只有一个线程可以访问共享资源。 `CreateMutexA`是Windows ...
Windows内核同步-互斥体
I'MPOSSIBLE
11-03 792
概述 互斥体(Mutex)是用来支持互斥访问共享资源的一种同步机制, 内核确保同一时间只会有一个线程可以获取Mutex的所有权. 内核永远不会允许将一个拥有Mutex所有权的线程切换到User Mode, 尝试这样做会触发系统崩溃. 互斥体(Mutex) //初始化 KeInitializeMutex //获取所有权 KeWaitForMutexObject/KeWaitForXXXXObject(s) //释放所有权 KeReleaseMutex 允许递归获取所有...
线程的同步问题
qq_31833457的博客
11-14 230
先看一下进程之间的内存空间： ------------------------------------------------------------------------------------------------- 可以看到每个进程对应一个虚拟地址空间，由虚拟地址空间映射到物理空间。当然两个虚拟地址空间也可以映射到同一个物理空间，也便实现了进程间的共享。 再看线程之前的
[转]WaitForMultipleObject与MsgWaitForMultipleObjects用法
weixin_30892763的博客
08-06 319
用户模式的线程同步机制效率高，如果需要考虑线程同步问题，应该首先考虑用户模式的线程同步方法。 但是，用户模式的线程同步有限制，对于多个进程之间的线程同步，用户模式的线程同步方法无能为力。这时，只能考虑使用内核模式。 用户模式与内核模式线程同步机制比较： 用户模式 内核模式 优点 线程同步机...
Win32系统编程 线程控制(Suspendthread ResumeThread WaiteForSingleObject WaitForMultipleObjects)
woaijianji的博客
08-20 321
前面几章已经提过线程的概念，这里直接介绍线程控制常用的代码简单明了会介绍的函数将线程挂起：Suspendthread（）函数让线程恢复：ResumeThread()函数。
用C++实现多线程Mutex锁（Win32）
Bruce Che 的专栏
12-07 3万+
本文目的：用C++和Windows的互斥对象（Mutex）来实现线程同步锁。     准备知识：1，内核对象互斥体（Mutex）的工作机理，WaitForSingleObject函数的用法，这些可以从MSDN获取详情； 2，当两个或更多线程需要同时访问一个共享资源时，系统需要使用同步机制来确保一次只有一个线程使用该资源。Mutex 是同步基元，它只向一个线程授予对共享资源的独占访问权。如果一个线
《Win32多线程程序设计》（2）---WaitForMultipleObjects()
一零一六的博客专栏
02-11 986
DWORD WaitForMultipleObjects( DWORD nCount, CONST HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds ); 参数 nCount 表示lpH andles 所指之handles 数组的元素个 数。最大容量是MAXIMUM_WAIT_OBJECTS。 lpHandles 指向
WaitForMultipleObjects用法详解，一看就懵
热门推荐
照玄
09-07 4万+
WaitForMultipleObjects是Windows中的一个功能非常强大的函数，几乎可以等待Windows中的所有的内核对象 WAIT_ABANDONED_0：所有对象都发出消息，而且其中有一个或多个属于互斥体（一旦拥有它们的进程中止，就会发出信号） WAIT_TIMEOUT：对象保持未发信号的状态，但规定的等待超时时间已经超过 WAIT_OBJECT_0：所有对象都发出信号 WAIT_IO_COMPLETION：（仅适用于WaitForMultipleObjectsEx）由于一个I/O完
windows实现进程互斥
奋斗的伙计
12-27 1578
比较简单，但很实用的小文章 通过互斥量实现进程的互斥 在visual studio下测试过，是成功的 code： -------------------------------------------------------------------------------------------------------------------------------------------
Win32多线程之互斥器(Mutexes)
wjj715211的专栏
11-23 1288
Win32的Mutex用途和critical section非常类似，但是它牺牲速度以增加弹性，或许你已经猜到了。mutex 是MUTual EXclusion的缩写。一个时间内只能够有一个线程拥有mutex，就好像同一时间内只能够有一个线程进入同一个critical section一样。   虽然mutex和critical section做同样的事情，但是它们的运作还是有差别的：   1）
Win32 Mutexes：多线程互斥访问与同步解决方案
1. **创建互斥体对象**：通过`HANDLE CreateMutex()`函数创建一个Mutex实例，获取其句柄，这是后续锁定和解锁操作的基础。 2. **请求锁定**：在访问共享资源前，线程调用`WaitForSingleObject()`函数，将句柄作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值