Windows核心编程学习笔记(18)--内核模式下的线程同步1

Drecik学习经验分享

转载请注明出处：http://blog.csdn.net/drecik__/article/details/8101549

虽然用户模式下的线程同步机制提供了非常好的性能，但它们也存在一些局限性，不适用于许多应用程序。所以操作系统提供了使用内核模式来对线程同步，内核对象的用途要广泛很多，实际上内核对象唯一的缺点就是它们的性能。

我们讨论过的好几种内核对象（进程，线程，作业等），几乎所有这些内核对象都可以进行同步。例如：进程内核对象在创建时是处于未触发的，当进程结束后，该进程内核对象将被触发，并且永远保持这种状态，线程内核对象跟进程内核对象一样，创建时是未触发，结束后触发并保持这种状态。

下面内核对象既可以处在触发状态也可以处在未触发状态：

• 进程
• 线程
• 作业
• 文件以及控制台的标准输入流/输出流/错误流
• 事件
• 可等待的计时器
• 信号量
• 互斥量

在这些内核对象中，有一个布尔值表示该内核对象的触发状态，我们可以利用操作系统提供的函数检查该布尔值就能知道内核对象的触发状态，例如，我们可以检查进程内核对象或线程内核对象的触发状态，从而知道它们是否还在运行。

1. 等待函数

等待函数是使一个线程自愿进入等待状态，等待的时候线程将被挂起不占用CPU时间，直到指定的内核对象被触发位置，如果等待的时候该内核对象是触发的，则不进入等待状态继续执行，等待函数有下面两种：

// 返回结果有三种：
//	1. WAIT_OBJECT_0：表示等待的内核对象出发;
//	2. WAIT_TIMEOUT：表示超时，INFINITE将不会出现该返回结果;
//	3. WAIT_FAILED：调用函数错误，可能传入无效的内核对象;
DWORD WaitForSingleObject(
	HANDLE hHandle,			// 指定等待的内核对象;
	DWORD dwMilliseconds	// 等待的时间，INFINITE表示一直等待;
	);

// 返回值：
//	1. 当有事件触发的时候，如果bWaitAll为FALSE，则将返回;
//		WAIT_OBJECT_0~WAIT_OBJECT_0+nCount-1之间的一个数，表示哪个事件触发;
//		如果bWaitAll为TRUE，则一定返回WAIT_OBJECT_0;
//	2. WAIT_TIMEOUT：表示超时，INFINITE将不会出现该返回结果;
//	3. WAIT_FAILED：调用函数错误，可能传入无效的内核对象;
DWORD WaitForMultipleObjects(
	DWORD nCount,			// 等待事件的个数;
	CONST HANDLE *lpHandles,// 指向一个等待事件的句柄数组;
	BOOL bWaitAll,			// 是否等数组中全部的事件都触发在返回;
	DWORD dwMilliseconds	// 等待事件;
	);

2. 事件内核对象

事件内核对象是最简单的内核对象，该对象包含一个使用计数，一个用来表示事件是自动重置事件还是手动重置事件的布尔值，以及一个用来表示事件有没有被触发的布尔值。

事件对象有两种：

• 手动重置事件：当该种事件被触发的时候，所有正在等待该事件的线程都将被唤醒。
• 自动重置事件：当该种事件被触发的时候，在所有正在等待该事件的其中一个线程将被唤醒，并且事件状态将会变为未触发，所有等待的线程都是公平的获得机会被唤醒。

事件内核对象的创建：

// 返回事件句柄;
HANDLE CreateEventW(
	LPSECURITY_ATTRIBUTES lpEventAttributes,	// 安全属性;
	BOOL bManualReset,			// TRUE为手动重置事件，FALSE为自动重置时间;
	BOOL bInitialState,			// 创建时候，该事件的触发状态;
	LPCWSTR lpName				// 事件的名称，可以为NULL;
	);

创建时间后可以通过许多方式来访问该事件对象，例如再次调用CreateEvent传入相同的名字，使用继承，使用DuplicateHandle赋值函数，或者调用OpenEvent：

// 返回事件句柄;
HANDLE OpenEventW(
	DWORD dwDesiredAccess,		// 打开事件的权限;
	BOOL bInheritHandle,		// 是否可以被继承;
	LPCWSTR lpName				// 事件名称;
	);

我们可以利用下面函数控制事件状态：

// 设置事件为触发状态;
BOOL SetEvent( HANDLE hEvent );


// 设置事件为未触发状态;
BOOL ResetEvent( HANDLE hEvent );


// 该函数不常使用，因为我们不知道在调用该函数的时候，是否有线程正在等待该事件;
// 函数作用：触发事件，并立即将事件恢复到未触发状态，相当于调用SetEvent后又调用ResetEvent;
BOOL PulseEvent( HANDLE hEvnet );

给出两个例子，分别为手动重置事件和自动重置事件：

// 下面的例子是一个手动重置事件的例子，三个线程都只对共享资源进行只读操作;
// 所以当资源准备好之后主线程可以创建手动重置事件，来唤醒三个线程进行操作;
HANDLE g_hEvent;
int WINAPI WinMain(...)
{
	// 创建一个手动重置事件;
	g_hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );

	// 创建三个线程;
	HANDLE hThread[3];
	hThread[0] = CreateThread( NULL, 0, WordCount, NULL, 0, NULL );
	hThread[1] = CreateThread( NULL, 0, SellCheck, NULL, 0, NULL );
	hThread[2] = CreateThread( NULL, 0, GrammarCheck, NULL, 0, NULL );

	// 将文件读入到内存;
	OpenFileAndReadContentsIntoMemory( ... );

	// 准许三个线程开始使用读入的内容;
	SetEvent(g_hEvent);

	...
}

DWORD CALLBACK WordCount( LPVOID lpVoid )
{
	WaitForSingleObject( g_hEvent, INFINITE );

	// 进行字数统计;

	return 0;
}

DWORD CALLBACK SpellCheck( LPVOID lpVoid )
{
	WaitForSingleObject( g_hEvent, INFINITE );

	// 进行拼写检查;

	return 0;
}

DWORD CALLBACK GrammarCheck( LPVOID lpVoid )
{
	WaitForSingleObject( g_hEvent, INFINITE );

	// 进行语法检查;

	return 0;
}

// 下面的例子是一个自动重置事件的例子，三个线程如果需要对共享资源进行独占操作;
// 那么当资源准备好之后，主线程只能唤醒一个线程，当一个线程完成之后在唤醒另外一个;
// 唤醒的线程是公平的，所以你不知道是哪个线程被唤醒;
HANDLE g_hEvent;
int WINAPI WinMain(...)
{
	// 创建一个自动重置事件;
	g_hEvent = CreateEvent( NULL, FALSE, FALSE, NULL );

	// 创建三个线程;
	HANDLE hThread[3];
	hThread[0] = CreateThread( NULL, 0, WordCount, NULL, 0, NULL );
	hThread[1] = CreateThread( NULL, 0, SellCheck, NULL, 0, NULL );
	hThread[2] = CreateThread( NULL, 0, GrammarCheck, NULL, 0, NULL );

	// 将文件读入到内存;
	OpenFileAndReadContentsIntoMemory( ... );

	// 唤醒三个线程当中的一个线程进行操作;
	SetEvent(g_hEvent);

	...
}

DWORD CALLBACK WordCount( LPVOID lpVoid )
{
	WaitForSingleObject( g_hEvent, INFINITE );

	// 进行字数统计;

	// 唤醒另外一个线程;
	SetEvent(g_hEvent);
	return 0;
}

DWORD CALLBACK SpellCheck( LPVOID lpVoid )
{
	WaitForSingleObject( g_hEvent, INFINITE );

	// 进行拼写检查;

	// 唤醒另外一个线程;
	SetEvent(g_hEvent);
	return 0;
}

DWORD CALLBACK GrammarCheck( LPVOID lpVoid )
{
	WaitForSingleObject( g_hEvent, INFINITE );

	// 进行语法检查;

	// 唤醒另外一个线程;
	SetEvent(g_hEvent);
	return 0;
}

3. 可等待计时器内核对象

可等待计时器是一个内核对象，它们会在指定的事件触发，或每隔一段时间触发一次，下面是创建和打开可等待计时器内核对象的函数：

HANDLE CreateWaitableTimerW(
	LPSECURITY_ATTRIBUTES lpTimerAttributes,	// 安全属性;
	BOOL bManualReset,		// 同事件内核对象一样表示是否手动重置;
	LPCWSTR lpTimerName		// 名称，可以为NULL;
	);

HANDLE OpenWaitableTimerW(
	DWORD dwDesiredAccess,	// 打开权限;
	BOOL bInheritHandle,	// 是否可以被继承;
	LPCWSTR lpTimerName		// 创建时的名称，不可以为NULL;
	);

创建的时候，可等待的计时器对象总是处于未触发状态，当我们想要触发计时器的时候必须调用SetWaitableTimer

BOOL SetWaitableTimer(
	HANDLE hTimer,			// 对象句柄;
	const LARGE_INTEGER *lpDueTime,	// 表示什么时候开始第一次触发;
	LONG lPeriod,					// 第一次触发之后每隔多长时间触发一次，单位为微秒;
	PTIMERAPCROUTINE pfnCompletionRoutine,	// 下面三个参数稍后分析;
	LPVOID lpArgToCompletionRoutine,
	BOOL fResume
	);

下面一个例子给出设置可等待计时器对象的方法：

	// 创建内核对象;
	HANDLE hTimer = CreateWaitableTimer( NULL, TRUE, NULL );
	
	// 设置第一次提醒的时间为2012年12月21日;
	SYSTEMTIME st = {0};
	st.wYear = 2012;
	st.wMonth = 12;
	st.wDay = 21;
	
	// 转化到全球标准时间;
	FILETIME ftLocal, ftUTC;
	SystemTimeToFileTime( &st, &ftLocal );
	LocalFileTimeToFileTime( &ftLocal, &ftUTC );

	LARGE_INTEGER liUTC;
	liUTC.HighPart= ftUTC.dwHighDateTime;
	liUTC.LowPart = ftUTC.dwLowDateTime;

	// 可以利用给第二个参数传入负值来表示从调用SetWaitableTimer起多长时间开始第一次调用;
	// 单位是100ns，例如：liUTC.QuadPart = -5*(1000*1000*10);
	// 表示经过5秒后开始第一次调用;

	// 设置之后每隔1小时提醒一次;
	// 可以传给第三个参数为0，表示只触发一次;
	SetWaitableTimer( hTimer, &liUTC, 60 * 60 * 1000, NULL, NULL, FALSE );

接下来看下最后一个参数：

为TURE表示当计时器被触发的时候，系统会使机器结束挂起模式（如果机器正处于挂起模式下），并唤醒正在等待该计时器的线程

为FALSE表示计时器会被触发，但如果机器在过期模式下，被唤醒的任何线程都得不到CPU

最后一个函数，CancelWaitableTimer，该函数取消句柄所标识的计时器，这样计时器永远不会在触发了，之后可以再调用SetWaitableTimer重置计时器。

需要注意的是，不需要每次调用SetWaitableTimer之前调用CancelWaitableTimer，每次调用SetWaitableTimer都会取消原来的触发时间。

最后我们来看下没有讨论的两个参数，这两个参数是为了把一个异步过程调用放到SetWaitableTimer的调用线程的队列中，该线程还必须使用SleepEx，WaitForSingleObjectEx，WaitForMultipleObjectsEx，MsgWaitForMultipleObjectsEx或SignalObjectAndWait而进入等待状态，如下面代码将展示当计时器到了之后会执行APC函数输出当前时间：

VOID APIENTRY TimerAPCRoutine( LPVOID lpvArgToCompletionRoutine,
	DWORD dwTimerLowValue, DWORD dwTimerHighValue )
{
	FILETIME ftUTC, ftLocal;
	ftUTC.dwHighDateTime = dwTimerHighValue;
	ftUTC.dwLowDateTime = dwTimerLowValue;

	FileTimeToLocalFileTime( &ftUTC, &ftLocal );

	SYSTEMTIME st;
	FileTimeToSystemTime( &ftLocal, &st );

	TCHAR szBuf[256];
	GetDateFormat( LOCALE_USER_DEFAULT, DATE_LONGDATE, &st,
		NULL, szBuf, _countof(szBuf) );

	_tcscat_s( szBuf, _countof(szBuf), TEXT(" ") );
	GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, NULL,
		_tcschr( szBuf, TEXT('\0') ), _countof(szBuf)-_tcslen(szBuf) );

	_tprintf( TEXT("%s\n"), szBuf );
}

int main()
{
	HANDLE hTimer = CreateWaitableTimer( NULL, TRUE, NULL );
	LARGE_INTEGER li = {0};
	SetWaitableTimer( hTimer, &li, 500000000, TimerAPCRoutine, NULL, FALSE );  

	SleepEx( INFINITE, TRUE );  
	getchar();
	return 0;
}

比较下可等待计时器和用户计时器（SetTimer进行设置）：

1. 用户计时器建立在大量的用户界面基础设施上，从而消耗更多资源，而且WM_TIMER只有一个线程会被通知，并且WM_TIMER消息优先级总是最低，只有在消息队列中没有其他消息时候才会被处理
2. 可等待计时器是一个内核对象，可以在多个线程和进程中共享，而且可以具备安全型，但是用起来稍微比用户计时器繁琐

4. 信号量内核对象

信号量内核对象用来对资源进行计数，它们在内部结构中包含两个32位的值：一个最大资源计数和一个当前资源计数。

信号量的规则如下：

• 如果当前资源计数大于0，那么信号量处于触发状态
• 如果当前资源计数等于0，那么信号量处于未触发状态
• 系统却对不会让当前资源计数变为负数
• 当前资源计数不会大于最大资源计数

创建和打开信号量内核对象的函数：

HANDLE CreateSemaphoreW(
	LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,	// 安全属性;
	LONG lInitialCount,		// 当前资源计数;
	LONG lMaximumCount,		// 最大资源计数;
	LPCWSTR lpName			// 资源名称，可为NULL;
	);

HANDLE OpenSemaphoreW(
	DWORD dwDesiredAccess,	// 打开权限;
	BOOL bInheritHandle,	// 是否可以被继承;
	LPCWSTR lpTimerName		// 创建时的名称，不可以为NULL;
	);

如果要获得对被保护资源的访问权，线程要调用等待函数并传入信号量的句柄，在内部等待函数会检查当前信号量的当前计数，如果大于0，则把计数器减1，并让当前线程继续执行，如果等于0，则线程进入等待状态，直到另一线程递增信号量当前资源计数。

注意信号量是以原子的方式来执行这些测试和设置操作，也就是说这些操作不会被打断。

通过下面函数可以增加信号量计数：

BOOL ReleaseSemaphore(
	HANDLE hSemaphore,		// 信号量句柄;
	LONG lReleaseCount,		// 递增的数量;
	LPLONG lpPreviousCount	// 可以用来返回之前的资源计数，可为NULL;
	);