三种线程同步方式

三种线程同步方式，即互斥对象、事件对象和关键代码段。

一、互斥对象

1、属于内核对象，它能够确保线程拥有对单个资源的互斥访问权。互斥对象包含一个使用数量，一个线程ID和一个计数器。ID用于标识系统中的哪个线程当前拥有互斥对象，计数器用于指明该线程拥有互斥对象的次数。

2、函数：CreateMutex

函数原型：HANDLE CreateMutex( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName);

该函数可以创建或打开一个命名的或匿名的互斥对象，然后程序就可以利用该互斥对象完成线程间的同步。

函数参数：

<1>lpMutexAttributes：值为NULL时，让互斥对象使用默认的安全性。

<2>bInitialOwner：若值为真，则创建这个互斥对象的线程获得该对象的所有权；否则，该线程将不获得所创建的互斥对象的所有权。

<3>lpName：指定互斥对象的名称。如果值为NULL，则创建一个匿名的互斥对象。

PS：如果该函数调用成功，将返回所创建的互斥对象的句柄。如果创建的是命名的互斥对象，并且在CreateMutex函数调用之前，该命名的互斥对象存在，将返回已经存在的这个互斥对象的句柄，而这时调用GetLastError函数，将返回ERROR_ALREADY_EXISTS。当线程结束对互斥对象的访问后，应释放该对象的所有权，需调用ReleaseMutex函数实现。函数原型为：BOOL ReleaseMutex( HANDLE
hMutex);调用成功返回非0值，否则返回0。

线程必须主动请求共享对象的使用权才有可能获得该所有权。需要使用函数WaitForSingleObject实现，函数解释见/article/1524576.html

3、示例代码

#include <windows.h>
#include <iostream.h>

DWORD WINAPI Fun1Proc(LPVOID lpParameter  );
DWORD WINAPI Fun2Proc(LPVOID lpParameter  );
int index=0;
int tickets=100;
HANDLE hMutex;
void main()
{
	HANDLE hThread1;
	HANDLE hThread2;
	hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
	hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
	CloseHandle(hThread1);
	CloseHandle(hThread2);

	hMutex=CreateMutex(NULL,FALSE,NULL);//第二个参数为FALSE，表明无线程拥有这个互斥对象。

	Sleep(4000);
}

DWORD WINAPI Fun1Proc( LPVOID lpParameter )
{
	while(TRUE)
	{
		WaitForSingleObject(hMutex,INFINITE);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread1 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		ReleaseMutex(hMutex);
	}
	return 0;
}

DWORD WINAPI Fun2Proc(LPVOID lpParameter )
{
	
	while(TRUE)
	{
		WaitForSingleObject(hMutex,INFINITE);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread2 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		ReleaseMutex(hMutex);
	}
	return 0;
}

二、事件对象

属于内核对象，包含三个成员：

1、使用计数；

2、用于指明该事件是一个自动重置的事件还是一个人工重置事件的布尔值；

3、用于指明该事件处于已通知状态还是未通知状态的布尔值。

当人工重置的事件对象得到通知时，等待该事件对象的所有线程均变为可调度线程。当一个自动重置的事件对象得到通知时，等待该事件对象的线程中只有一个线程变为可调度线程。另外，自动重置事件得到通知并被线程拥有之后，操作系统会将该事件对象设置为无信号状态，这样，当对所保护的代码执行完成之后，需要调用SetEvent函数将该事件对象设置为有信号状态。而人工重置事件得到通知并被线程拥有之后，操作系统并不会将该事件设置为无信号状态，除非显示地调用ResetEvent函数将其设置为无信号状态。为了实现线程间的同步，不应该使用人工重置的事件对象，而应该使用自动重置的事件对象。

函数：CreateEvent

函数原型：HANDLE CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,

BOOL bManualReset, BOOL bInitialState, LPCTSTR lpName);

CreateEvent函数创建或打开一个命名的或匿名的事件对象。

函数参数：

<1>lpEventAttributes：指向SECURITY_ATTRIBUTES结构体的指针。如果值为NULL，则使用默认的安全性。

<2>bManualReset：如果值为TRUE，表示该函数将创建一个人工重置事件对象；如果值为FALSE，

表示该函数将创建一个自动重置事件对象。

<3>bInitialState：如果值为TRUE，那么该事件对象初始是有信号状态；否则是无信号状态。

<4>lpName：如果此参数为NULL，将创建一个匿名的事件对象。

设置和重置事件对象状态函数：SetEvent(HANDLE hEvent);把指定的事件对象设置为有信号状态。ResetEvent(HANDLE
hEvent);把指定的事件对象设置为无信号状态。

实例代码：

#include <windows.h>
#include <iostream.h>

DWORD WINAPI Fun1Proc( LPVOID lpParameter );
DWORD WINAPI Fun2Proc( LPVOID lpParameter);

int tickets=100;
HANDLE g_hEvent;

void main()
{
	HANDLE hThread1;
	HANDLE hThread2;
	hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
	hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
	CloseHandle(hThread1);
	CloseHandle(hThread2);

	g_hEvent=CreateEvent(NULL,FALSE,TRUE,NULL);

	Sleep(4000);
	CloseHandle(g_hEvent);
}

DWORD WINAPI Fun1Proc(  LPVOID lpParameter )
{
	while(TRUE)
	{
		WaitForSingleObject(g_hEvent,INFINITE);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread1 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		SetEvent(g_hEvent);
	}
	
	return 0;
}

DWORD WINAPI Fun2Proc( LPVOID lpParameter)
{
	
	while(TRUE)
	{
		WaitForSingleObject(g_hEvent,INFINITE);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread2 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		SetEvent(g_hEvent);
	}
	
	return 0;
}

三、关键代码段

也称为临界区，工作在用户方式下。它是指一个小代码段，在代码能够执行前，它必须独占对某些资源的访问权。通常把多线程中访问同一种资源的那部分代码当作关键代码段。

相关函数：

1、InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

2、DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

3、EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

4、LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

使用这些函数之前需构造一个CRITICAL_SECTION结构体类型的对象，然后将该对象传递给函数，系统自动维护该对象。

示例代码：

#include <windows.h>
#include <iostream.h>

DWORD WINAPI Fun1Proc( LPVOID lpParameter );
DWORD WINAPI Fun2Proc( LPVOID lpParameter );

int tickets=100;

CRITICAL_SECTION g_cs;

void main()
{
	HANDLE hThread1;
	HANDLE hThread2;
	hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
	hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
	CloseHandle(hThread1);
	CloseHandle(hThread2);

	InitializeCriticalSection(&g_cs);
	Sleep(4000);

	DeleteCriticalSection(&g_cs);
}

DWORD WINAPI Fun1Proc( LPVOID lpParameter )
{
	while(TRUE)
	{
		EnterCriticalSection(&g_cs);
		Sleep(1);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread1 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		LeaveCriticalSection(&g_cs);
	}
	
	return 0;
}

DWORD WINAPI Fun2Proc( LPVOID lpParameter )
{
	while(TRUE)
	{
		EnterCriticalSection(&g_cs);
		Sleep(1);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread2 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		LeaveCriticalSection(&g_cs);
	}
	return 0;
}

四、比较

1、互斥对象和事件对象都属于内核对象，利用内核对象进行线程同步时，速度较慢，但利用互斥对象和事件对象这样的内核对象，可以在多个进程中的各个线程间进行同步。

2、关键代码段工作在用户方式下，同步速度较快，但在使用关键代码段时，很容易进入死锁状态，因为在等待进入关键代码段时无法设定超时值。

3、通常，在编写多线程程序并需要实现线程同步时，首选关键代码段，它的使用比较简单。当使用了多个临界区对象，就要注意防止线程死锁的发生。如果需要在多个进程间的各个线程间实现同步的话，可以使用互斥对象和事件对象。

线程死锁现象示例代码：

#include <windows.h>
#include <iostream.h>

DWORD WINAPI Fun1Proc( LPVOID lpParameter  );
DWORD WINAPI Fun2Proc( LPVOID lpParameter  );

int tickets=100;

CRITICAL_SECTION g_csA;
CRITICAL_SECTION g_csB;

void main()
{
	HANDLE hThread1;
	HANDLE hThread2;
	hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
	hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
	CloseHandle(hThread1);
	CloseHandle(hThread2);

	InitializeCriticalSection(&g_csA);
	InitializeCriticalSection(&g_csB);
	Sleep(4000);

	DeleteCriticalSection(&g_csA);
	DeleteCriticalSection(&g_csB);
}

DWORD WINAPI Fun1Proc(  LPVOID lpParameter )
{
	while(TRUE)
	{
		EnterCriticalSection(&g_csA);
		Sleep(1);
		EnterCriticalSection(&g_csB);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread1 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		LeaveCriticalSection(&g_csB);
		LeaveCriticalSection(&g_csA);
	}
	
	return 0;
}

DWORD WINAPI Fun2Proc(  LPVOID lpParameter  )
{	
	while(TRUE)
	{
		EnterCriticalSection(&g_csB);
		Sleep(1);
		EnterCriticalSection(&g_csA);
		if(tickets>0)
		{
			Sleep(1);
			cout<<"thread2 sell ticket : "<<tickets--<<endl;
		}
		else
			break;
		LeaveCriticalSection(&g_csA);
		LeaveCriticalSection(&g_csB);
	}
	cout<<"thread2 is running!"<<endl;
	return 0;
}

参考《VC深入详解》