《Windows核心编程》读书笔记九 用内核模式进行线程同步

第九章 用内核对象进行线程同步

本章内容

9.1 等待函数

9.2 等待成功所引起的副作用

9.3 事件内核对象

9.4 可等待的计时器内核对象

9.5 信号量内核对象

9.6 互斥量内核对象

9.7 线程同步对象速查表

9.8 其他的线程同步函数

用户模式下的线程同步高性能，但是存在一些局限。例如无法进行进程间线程的同步，Iterlocked系函数不会把线程切换到等待状态，

进入临界区无法设置最长等待时间等。

内核对象来进行线程同步，功能强大许多。但是唯一的缺点就是性能。

对于线程内核对象可能处于触发（signaled）和未触发（nosignaled）

进程内核对象，在创建时其内部有一个BOOL变量是FALSE， 单进程终止时该内核对象会变成TRUE 表示已经触发

但是这个过程是不可逆的。

以下列出可能处于未触发也可以处于触发状态的内核对象：

进程，线程，作业，文件以及控制台的标准输入流/输出流/错误流

事件，可等待的计时器， 信号量，互斥量

9.1 等待函数

等待函数使一个线程资源进入等待状态，直到指定的内核对象被触发为止。如果在调用一个等待函数时，响应的内核对象已经处于触发状态，那么线程是不会进入等待状态的。

WINBASEAPI
DWORD
WINAPI
WaitForSingleObject(
    _In_ HANDLE hHandle,
    _In_ DWORD dwMilliseconds
    );

hObject用来标识等待的内核对象，可以处于触发或未触发状态。

dwMilliseconds 指定线程最多愿意花多长时间来等待对象被触发

一直等待直到目标进程终止

WaitForSingleObject(hProcess, INFINITE);

	DWORD dw = WaitForSingleObject(hProcess, 5000);
	switch (dw) {
	case WAIT_OBJECT_0:
		// The process terminated.
		break;
	case WAIT_TIMEOUT:
		// The process did not terminate within 5000 milliseconds.
		break;
	case WAIT_FAILED:
		// Bad call to function (invalid handle?)
		break;
	}

WaitForSingleObject的返回值表示为什么调用线程又能继续执行了。

以下函数可以等待多个内核对象的触发状态

WINBASEAPI
DWORD
WINAPI
WaitForMultipleObjects(
    _In_ DWORD nCount,
    _In_reads_(nCount) CONST HANDLE *lpHandles,
    _In_ BOOL bWaitAll,
    _In_ DWORD dwMilliseconds
    );

nCount表示希望函数检查内核对象的数量。 必须在（1~MAXIMUM_WAIT_OBJECTS之间）

lpHandles 指向内核对象句柄的数组

bWaitAll 是否等待全部触发，FALSE 表示只要一个触发即可

dwMilliseconds 等待时间

一个例子说明WaitForMultipleObjects的返回值

	HANDLE h[3];
	h[0] = hProcess1;
	h[1] = hProcess2;
	h[2] = hProcess3;
	DWORD dw = WaitForMultipleObjects(3, h, FALSE, 5000);
	switch (dw) {
	case WAIT_FAILED:
		// Bad call to function (invalid handle?)
		break;

	case WAIT_TIMEOUT:
		// None of the objects became signaled within 5000 milliseconds.
		break;

	case WAIT_OBJECT_0 + 0:
		// The process identified by h[0] (hProcess1) terminated.
		break;

	case WAIT_OBJECT_0 + 1:
		// The process identified by h[1] (hProcess1) terminated.
		break;

	case WAIT_OBJECT_0 + 2:
		// The process identified by h[2] (hProcess1) terminated.
		break;
	}

如果给bWaitAll传递TRUE那么所有内核对象都触发了以后返回值是 WAIT_OBJECT_0

9.2 等待成功锁引起的副作用

如果WaitForXXXObject成功返回，那么传入的句柄对象发生了变化，成为“等待成功锁引起的副作用”。

有些内核对象在WaitForXXX返回以后会被自动设置为非触发状态（例如自动重置事件对象）

例如一个例子

HANDLE h[2];

WaitForMultipleObjects(2, h, TRUE, INFINITE);

1）两个线程执行同样的代码，

2）其中一个事件触发了，两个线程都能检测到，但是由于另外一个事件未触发，所以线程会继续等待

3）另一个事件也触发了，其中一个线程检测到两个事件都触发以后，将两个事件又设置为非触发状态并返回

4）另一个线程会继续等待直到两个事件同时触发为止。

WaitForMultipleObjects是以原子操做的方式工作的，当他检查内核对象的状态时，任何其他线程都不能在背后修改对象的状态。这就防止了死锁的发生。

9.3 事件内核对象

事件包含一个使用计数器，一个用来标识事件是自动重置还是手动重置的布尔值，以及另一个布尔值用来表示事件有没有被触发。

当一个手动重置事件被触发的时候，正在等待该事件的所有线程都变成可调度状态。

当一个自动重置事件被触发时，只有一个正在等待该事件的线程会变成可调度状态。

事件常用于让一个线程执行初始化工作，然后再触发另一个线程，让它执行剩余的工作。

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
CreateEventW(
    _In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,
    _In_ BOOL bManualReset,
    _In_ BOOL bInitialState,
    _In_opt_ LPCWSTR lpName
    );

bManualRest TRUE（手动触发）， FALSE（自动触发）

bInitialState 初始状态 TRUE（已触发）， FALSE （未触发）

创建以后会返回一个事件内核对象句柄，该事件和当前进程相关联。

还有一个CreateEventEx函数用于创建事件。

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
CreateEventExW(
    _In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,
    _In_opt_ LPCWSTR lpName,
    _In_ DWORD dwFlags,
    _In_ DWORD dwDesiredAccess
    );

dwFlags参数可以接受两个位的掩码

dwDesiredAccess 允许指定在创建事件时返回的句柄对事件有何种访问权限。（ex可以限制权限）

如果要调用SetEvent， ResetEvent， PulseEvent。必须使用

EVENT_MODIFY_STATE

其他进程中的线程可以通过多种方式来访问该事件对象，

CreateEvent并在pszName参数中传入相同的值，

使用继承（子进程继承父进程，两者的句柄表中的位置完全一样）

使用DuplicateHandle

或者调用OpenEvent

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
OpenEventW(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL bInheritHandle,
    _In_ LPCWSTR lpName
    );

设置事件为触发状态

BOOL SetEvent(HANDLE hEvent); 

设置事件为非触发状态

BOOL ResetEvent(HANDLE hEvent);

自动事件由于等待成功所引起的副作用的影响，当事件被线程等待以后会自动设置为非触发，因此不需要ResetEvent。

HANDLE g_hEvent;

DWORD WINAPI WordCount(PVOID pvParam) {
	
	// Wait until the file's data is in memory.
	WaitForSingleObject(g_hEvent, INFINITE);

	// Access the memory block.
	// ...

	return 0;
}


DWORD WINAPI SpellCheck(PVOID pvParam) {

	// Wait until the file's data is in memory.
	WaitForSingleObject(g_hEvent, INFINITE);

	// Access the memory block.
	// ...

	return 0;
}

DWORD WINAPI GrammarCheck(PVOID pvParam) {

	// Wait until the file's data is in memory.
	WaitForSingleObject(g_hEvent, INFINITE);

	// Access the memory block.
	// ...
	return 0;
}



int _tmain(int argc, TCHAR* argv[], TCHAR * env[])
{
	// Crate the manual-reset, nosignaled event.
	g_hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	// Spawn 3 new threads.
	HANDLE hThread[3];
	DWORD dwThreadID;
	hThread[0] = CreateThread(NULL, 0, WordCount, NULL, 0, &dwThreadID);
	hThread[1] = CreateThread(NULL, 0, SpellCheck, NULL, 0, &dwThreadID);
	hThread[2] = CreateThread(NULL, 0, GrammarCheck, NULL, 0, &dwThreadID);

	OpenFileAndReadContentsIntoMemory(...);

	// Allow all 3 threads to access the memory.
	SetEvent(g_hEvent);
	return 0;
}

因为这里使用了手动重置事件，所以当主线程准备好数据以后3个子线程都能同时运行。

如果使用自动重置事件，那么3个子线程只会有一个能继续运行。为了让3个子线程都能执行代码，修改了一下3个子线程的代码

DWORD WINAPI WordCount(PVOID pvParam) {
	
	// Wait until the file's data is in memory.
	WaitForSingleObject(g_hEvent, INFINITE);

	// Access the memory block.
	// ...
	SetEvent(g_hEvent);
	return 0;
}


DWORD WINAPI SpellCheck(PVOID pvParam) {

	// Wait until the file's data is in memory.
	WaitForSingleObject(g_hEvent, INFINITE);

	// Access the memory block.
	// ...
	SetEvent(g_hEvent);
	return 0;
}

DWORD WINAPI GrammarCheck(PVOID pvParam) {

	// Wait until the file's data is in memory.
	WaitForSingleObject(g_hEvent, INFINITE);

	// Access the memory block.
	// ...
	SetEvent(g_hEvent);
	return 0;
}

这个3个线程都会被系统调用，而且每个线程都能独占的读写资源。

BOOL PulseEvent(HANDLE hEvent);

将一个事件变成触发状态以后立即恢复到未触发状态。

Handshake 示例程序

/******************************************************************************
Module:  Handshake.cpp
Notices: Copyright (c) 2008 Jeffrey Richter & Christophe Nasarre
******************************************************************************/

#include "..\CommonFiles\CmnHdr.h"
#include <windowsx.h>
#include <tchar.h>
#include "Resource.h"

//
#define BUFFERSIZ	1024


// This event is signaled when the client has a request for the server
HANDLE	g_hevtRequestSubmitted;

// This event is signaled when the server has a result for the client
HANDLE	g_hevtResultReturned;

// The buffer shared between the client and server threads
TCHAR	g_szSharedRequestAndResultBuffer[BUFFERSIZ];

// The special value sent from the client that causes the
// server thread to terminate cleanly.
TCHAR	g_szServerShutdown[] = TEXT("Server Shutdown");

// The server thread will check that the main dialog is no longer alive
// When the shutdown message is received.
HWND	g_hMainDlg;

//

// This is the code executed by the server thread
DWORD WINAPI ServerThread(PVOID pvParam) {

	// Assume that the server thread is to run forever
	BOOL fShutdown = FALSE;

	while (!fShutdown) {

		// Wait for the client to submit a request
		WaitForSingleObject(g_hevtRequestSubmitted, INFINITE);

		// Check to see if the client wants the server to terminate
		fShutdown =
			(g_hMainDlg == NULL) &&
			(_tcscmp(g_szSharedRequestAndResultBuffer, g_szServerShutdown) == 0);

		if (!fShutdown) {
			// Process the client's request (reverse the string)
			_tcsrev(g_szSharedRequestAndResultBuffer);
		}

		// Let the client process the request's result
		SetEvent(g_hevtResultReturned);
	}

	// The client wants us to shut down, exit
	return 0;
}


//

BOOL Dlg_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam) {

	chSETDLGICONS(hwnd, IDI_HANDSHAKE);

	// Initialize the edit control with some test data request
	Edit_SetText(GetDlgItem(hwnd, IDC_REQUEST), TEXT("Some test data"));

	// Store the main dialog window handle
	g_hMainDlg = hwnd;

	return TRUE;
}

void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) {

	switch (id) {

	case IDCANCEL:
		EndDialog(hwnd, id);
		break;

	case IDC_SUBMIT:		// Submit a request to the server thread

		// Copy the request string into the shared data buffer
		Edit_GetText(GetDlgItem(hwnd, IDC_REQUEST),
			g_szSharedRequestAndResultBuffer,
			_countof(g_szSharedRequestAndResultBuffer));

		// Let the server thread know that a request is ready in the buffer
		// Wait for the server to process the request and give us the result
		SignalObjectAndWait(g_hevtRequestSubmitted, g_hevtResultReturned, INFINITE, false);

		// Let the user know the result
		Edit_SetText(GetDlgItem(hwnd, IDC_RESULT),
			g_szSharedRequestAndResultBuffer);

		break;
	}
}

//

INT_PTR WINAPI Dlg_Proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

	switch (uMsg)
	{
		chHANDLE_DLGMSG(hwnd, WM_INITDIALOG, Dlg_OnInitDialog);
		chHANDLE_DLGMSG(hwnd, WM_COMMAND, Dlg_OnCommand);
	}

	return FALSE;
}


//

int WINAPI _tWinMain(HINSTANCE hInstanceExe, HINSTANCE, PTSTR, int) {

	// Create & initialize the 2 nonsignaled, auto-reset events
	g_hevtRequestSubmitted = CreateEvent(NULL, FALSE, FALSE, NULL);
	g_hevtResultReturned = CreateEvent(NULL, FALSE, FALSE, NULL);

	// Spawn the server thread
	DWORD dwThreadID;
	HANDLE hThreadServer = chBEGINTHREADEX(NULL, 0, ServerThread, NULL,
		0, &dwThreadID);

	// Execute the client thread's user interface
	DialogBox(hInstanceExe, MAKEINTRESOURCE(IDD_HANDSHAKE), NULL, Dlg_Proc);
	g_hMainDlg = NULL;

	// The client's UI is closing, have the server thread shutdown
	_tcscpy_s(g_szSharedRequestAndResultBuffer,
		_countof(g_szSharedRequestAndResultBuffer), g_szServerShutdown);
	SetEvent(g_hevtRequestSubmitted);

	HANDLE h[2];
	h[0] = g_hevtResultReturned;
	h[1] = hThreadServer;
	WaitForMultipleObjects(2, h, TRUE, INFINITE);

	// Properly clean up everything
	CloseHandle(hThreadServer);
	CloseHandle(g_hevtRequestSubmitted);
	CloseHandle(g_hevtResultReturned);

	// The client thread terminates with the whole process
	return 0;
}

运行结果

使用CONDITION_VARIABLE实现的handshake例子。虽然用CONDITION_VARIABLE和SRWLOCK效率高，但是使用起来代码的复杂度更高。

Console版本的HandShake

#define  _CRT_SECURE_NO_WARNINGS
#include <tchar.h>
#include <windows.h>
#include <stdio.h>
#include <Shlobj.h>
#include <strsafe.h>
#include <malloc.h>
#include <process.h>
#include <winnt.h>
#include <ctype.h>

CONDITION_VARIABLE		g_cvReturnResult;
CONDITION_VARIABLE		g_cvSubmitRequest;
SRWLOCK					g_srwLock;

TCHAR					g_szSharedBuffer[BUFSIZ];
TCHAR					g_szShutdown[] = TEXT("Server Shutdown");

unsigned __stdcall serverThread(void * pParam) {

	bool  bShutdown = false;
	_tprintf(TEXT("Server Started! \n"));
	while (!bShutdown) {
		AcquireSRWLockExclusive(&g_srwLock);
		SleepConditionVariableSRW(&g_cvSubmitRequest,
			&g_srwLock, INFINITE, 0); // for Exclusive SRWLock

		bShutdown =
			(_tcscmp(g_szSharedBuffer, g_szShutdown) == 0);

		if (!bShutdown)
			_tcsrev(g_szSharedBuffer);

		ReleaseSRWLockExclusive(&g_srwLock);
		WakeConditionVariable(&g_cvReturnResult);
	}
	_tprintf(TEXT("Server exit with 0! \n"));
	return 0;
}


int _tmain(int argc, TCHAR* argv[], TCHAR * env[])
{
	// Init Condition variable and srwlock
	InitializeConditionVariable(&g_cvReturnResult);
	InitializeConditionVariable(&g_cvSubmitRequest);
	InitializeSRWLock(&g_srwLock);

	_tprintf(TEXT("Handshake Console Version v 0.1\n"));

	unsigned int iThreadID;
	HANDLE hThreadServer = (HANDLE)_beginthreadex(NULL, 0,
		serverThread, NULL, 0, &iThreadID);

	bool bShutdown = false;
	while (!bShutdown) {
		
		_tprintf(TEXT("Please input the request:\n"));
#ifdef UNICODE
		_getws(g_szSharedBuffer);
#else
		gets(g_szSharedBuffer);
#endif

		bShutdown = (_tcscmp(g_szSharedBuffer, g_szShutdown) == 0);
		if (!bShutdown) {
			AcquireSRWLockExclusive(&g_srwLock);
			WakeConditionVariable(&g_cvSubmitRequest); // signal the server thread
			SleepConditionVariableSRW(&g_cvReturnResult, &g_srwLock, INFINITE, 0);
			_tprintf(TEXT("Result:\t%s\n"), g_szSharedBuffer);
			ReleaseSRWLockExclusive(&g_srwLock);
		}
		else {
			WakeConditionVariable(&g_cvSubmitRequest); // signal the server thread to shutdown.	
		}
	}

	WaitForSingleObject(hThreadServer, INFINITE);

	// Clean UP
	CloseHandle(hThreadServer);
	system("pause");
	return 0;
}

9.4 可等待的计时器内核对象

可等待的计时器是这样一种内核对象：他们会在某个指定的时间触发，或每间隔一段时间触发。

创建一个可等待的计时器

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
CreateWaitableTimerW(
    _In_opt_ LPSECURITY_ATTRIBUTES lpTimerAttributes,
    _In_     BOOL bManualReset,
    _In_opt_ LPCWSTR lpTimerName
    );

打开一个可等待的计时器

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
OpenWaitableTimerW(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL bInheritHandle,
    _In_ LPCWSTR lpTimerName
    );

bManualReset表示要创建的是手动重置还是自动重置的计时器。

手动重置，等待该计时器的所有线程都变成可调度状态

自动重置，只有一个等待该计时器的线程会变成可调度状态

调用SetWaitableTimer设置计时器，能让其触发

WINBASEAPI
BOOL
WINAPI
SetWaitableTimer(
    _In_ HANDLE hTimer,
    _In_ const LARGE_INTEGER * lpDueTime,
    _In_ LONG lPeriod,
    _In_opt_ PTIMERAPCROUTINE pfnCompletionRoutine,
    _In_opt_ LPVOID lpArgToCompletionRoutine,
    _In_ BOOL fResume
    );

hTimer ：计时器内核对象句柄

pDueTime ： 计时器第一次触发的时间应该在什么时候

lPeriod：计时器在第一次触发以后应该以怎样的频度触发。

例如以下代码把计时器第一次触发时间设为2018年1月1日下午1:00，以后没间隔6小时触发一次：

	// Declare our local variables.
	HANDLE				hTimer;
	SYSTEMTIME			st;
	FILETIME			ftLocal, ftUTC;
	LARGE_INTEGER		liUTC;

	// Create an auto-reset timer.
	hTimer = CreateWaitableTimer(NULL, FALSE, NULL);

	// First signaling is a January 1, 2018, at 1:00 P.M. (local time).
	st.wYear			= 2018;	// Year
	st.wMonth			= 1;	// January
	st.wDayOfWeek		= 0;	// Ignored
	st.wDay				= 1;	// The first of the month
	st.wHour			= 13;	// 1PM
	st.wMinute			= 0;	// 0 minutes into the hour
	st.wSecond			= 0;	// 0 seconds into the minute
	st.wMilliseconds	= 0;	// 0 milliseconds into the second

	SystemTimeToFileTime(&st, &ftLocal);

	// Convet local time to UTC time.
	LocalFileTimeToFileTime(&ftLocal, &ftUTC);
	// Convert FILETIME to LARGE_INTEGER because of different alignment.
	liUTC.LowPart = ftUTC.dwLowDateTime;
	liUTC.HighPart = ftUTC.dwHighDateTime;

	// Set the timer.
	SetWaitableTimer(hTimer, &liUTC, 6 * 60 * 60 * 1000,
		NULL, NULL, FALSE);

注意这里有一个FILETIME 和LARGE_INTEGER结构转换的问题

因为前者是32位对齐，后者是64位对齐。如果直接传递可能会导致对齐错误抛出一个（EXCEPTION_DATATYPE_MISALIGNMENT异常）

还可以给pDueTime传入一个相对时间，给其传入负值。（100纳秒的整数倍）

1秒 = 1000 毫秒 = 1000 000 微妙 = 10 000 000 （个 100 纳秒）

以下例子把计时器第一次触发时间设置为SetWaitableTimer调用结束的5秒钟后；

	// Declare our local variables.
	HANDLE				hTimer;
	LARGE_INTEGER		li;

	// Create an auto-reset timer.
	hTimer = CreateWaitableTimer(NULL, FALSE, NULL);

	// Set the timer to go off 5 seconds after calling SetWaitableTimer.
	// Timer unit is 100 nanoseconds.
	const int nTimerUnitsPerSecond = 10000000;

	// Negate the time so that SetWaitableTimer knows we
	// want relative time instead of absolute time.
	li.QuadPart = -(5 * nTimerUnitsPerSecond);

	// Set the timer.
	SetWaitableTimer(hTimer, &li, 6 * 60 * 60 * 1000,
		NULL, NULL, FALSE);

对于一次性计时器，只要给lPeriod 传递0 。然后调用CloseHandle关闭计时器即可。 或者调用SetWaitableTimer来重置计时器。

bResume（TRUE） 会使的计算机结束挂起模式（如果机器处于挂起模式下）并唤醒等待该计时器的线程。

FALSE 计时器会被触发，但是在机器继续执行前（挂起状态），被唤醒的线程都得不到CPU时间。

CancelWaitableTimer

WINBASEAPI
BOOL
WINAPI
CancelWaitableTimer(
    _In_ HANDLE hTimer
    );

取消计时器内核对象句柄所对应的计时器。

另外每次调用SetWaitableTimer都会重置计时器。

一个倒计时的例子。从9倒计时到0

#define  _CRT_SECURE_NO_WARNINGS
#include <tchar.h>
#include <windows.h>
#include <stdio.h>
#include <Shlobj.h>
#include <strsafe.h>
#include <malloc.h>
#include <process.h>
#include <winnt.h>
#include <ctype.h>

// Declare our local variables.
HANDLE				hTimer;


unsigned __stdcall OnTimer(void * param) {
	int nCount = 10;
	while (nCount--) {
		WaitForSingleObject(hTimer, INFINITE);
		_tprintf(TEXT("count:\t%d\n"), nCount);
	}
	return 0;
}

int _tmain(int argc, TCHAR* argv[], TCHAR * env[])
{

	LARGE_INTEGER		li;

	// Create an auto-reset timer.
	hTimer = CreateWaitableTimer(NULL, FALSE, NULL);

	// Set the timer to go off 5 seconds after calling SetWaitableTimer.
	// Timer unit is 100 nanoseconds.
	const int nTimerUnitsPerSecond = 10000000;

	// Negate the time so that SetWaitableTimer knows we
	// want relative time instead of absolute time.
	li.QuadPart = -(5 * nTimerUnitsPerSecond);

	// Set the timer.
	SetWaitableTimer(hTimer, &li, 1000,
		NULL, NULL, FALSE);

	// Create the OnTimer Thread
	unsigned int ThreadID;
	HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, OnTimer, NULL, NULL, &ThreadID);

	WaitForSingleObject(hThread, INFINITE);
	
	system("pause");
	return 0;
}

9.4.1 让可等待的计时器添加APC调用

APC异步过程调用（asynchronous procedure call）

SetWaitableTimer允许传入一个APC过程，触发了计时器会调用该过程。

当计时器触发时，当且仅当SetWaitableTimer调用的线程处于可提醒状态（Alertable stabe）（SleepEx, WaitForSingleObjectEx, WaitForMultipleObjectEx, MsgWaitForMultipleObjectEx,SignalObjectAndWait而进入的状态）

如果非处于可提醒状态，系统不会把计时器的APC函数添加到队列中。

#define  _CRT_SECURE_NO_WARNINGS
#include <tchar.h>
#include <windows.h>
#include <stdio.h>
#include <Shlobj.h>
#include <strsafe.h>
#include <malloc.h>
#include <process.h>
#include <winnt.h>
#include <ctype.h>
#include <io.h>
#include <fcntl.h>

VOID APIENTRY TimerAPCRountine(PVOID pvArgToCompletionRountine,
	DWORD dwTimerLowValue, DWORD dwTimerHighValue) {

	FILETIME	ftUTC, ftLocal;
	SYSTEMTIME	st;
	TCHAR		szBuf[256];

	// Put the time in a FILETIME structure.
	ftUTC.dwLowDateTime = dwTimerLowValue;
	ftUTC.dwHighDateTime = dwTimerHighValue;

	// Convert the UTC time to the user's local time.
	FileTimeToLocalFileTime(&ftUTC, &ftLocal);

	// Convert the FILETIME to the SYSTEMTIME structure
	// required by GetDateFormat and GetTimeFormat.
	FileTimeToSystemTime(&ftLocal, &st);

	// Construct a string with the
	// date/time that the timer went off.
	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')),
		(int)(_countof(szBuf) - _tcslen(szBuf)));

	// Show the time to the user.
	//MessageBox(NULL, szBuf, TEXT("Timer went off at..."), MB_OK);
	_tprintf(TEXT("%s\n"), szBuf);
}

void SomeFunc() {
	// Create a timer. (It doesn't matter  whether it's manual-reset
	// or auto-reset.)
	HANDLE hTimer = CreateWaitableTimer(NULL, TRUE, NULL);

	// Set timer to go off in 5 seconds.
	LARGE_INTEGER li = { 0 };
	SetWaitableTimer(hTimer, &li, 5000, TimerAPCRountine, NULL, FALSE);

	// Wait in an alertable state for the timer to go off.
	SleepEx(INFINITE, TRUE);

	CloseHandle(hTimer);
}

int _tmain(int argc, TCHAR* argv[], TCHAR * env[])
{
	_setmode(_fileno(stdout), _O_WTEXT);
	SomeFunc();

	system("pause");
	return 0;
}

不应该同时使用等待函数又同时以可提醒的方式等待一个计时器。

例如

SetWaitableTimer(hTimer,..., TimerAPCRountine,...);

WaitForSingleObjectEx(hTimer, INFINITE, TRUE);

9.4.2 计时器的剩余问题

在通信协议中会大量用到计时器，但是通常为每个请求创建计时器内核对象，将严重影响系统性能。

有一个CreateThreadpoolTimer可以创建线程池函数对应的计时器。

大多数应用程序不使用APC， 而是使用IO完成端口

用户计时器SetTimer ：在应用程序中使用大量的用户界面基础设置，从而消费更多的资源。而且通过消息机制触发，只有一个线程能得到通知

（WM_TIMER不一定准时，因为其具有最低的优先级）

可等待计时器是内核对象，可以在多个线程间共享。多个线程可以得到通知。

9.5 信号量内核对象

信号量内核对象用来对资源进行计数，除了使用计数器。还包含（32bit值）一个最大资源计数和当前资源计数。

如果当前资源计数大于0，信号量处于触发状态。

如果当前资源计数等于0，信号量处于未触发状态。

创建信号量

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
CreateSemaphoreW(
    _In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
    _In_     LONG lInitialCount,
    _In_     LONG lMaximumCount,
    _In_opt_ LPCWSTR lpName
    );

psa pszName 前面讲过了。

dwFlags是系统保留的设为0.

参数lMaximumCount 系统能够处理的资源的最大数量

lInitialCoun 初始化有多少资源可用。

例如给服务器进程初始化，没有客户端请求，因此使用一下代码来调用CreateSemaphore

HANDLE hSemaphore = CreateSemaphore(NULL, 0, 5, NULL);

打开一个信号量

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
OpenSemaphoreW(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL bInheritHandle,
    _In_ LPCWSTR lpName
    );

dwDesiredAccess参数指定访问权限

线程通过调用ReleaseSemahore来递增信号量的当前资源计数：

WINBASEAPI
BOOL
WINAPI
ReleaseSemaphore(
    _In_ HANDLE hSemaphore,
    _In_ LONG lReleaseCount,
    _Out_opt_ LPLONG lpPreviousCount
    );

lReleaseCount 的值会加到信号量当前资源计数上。

9.6 互斥量内核对象

互斥量（mutex）内核对象用来确保一个线程独占一个资源的访问。

互斥量与临界区的行为完全相同。（内部保护递归计数）

互斥量的规则：

1）如果线程ID为0，那么互斥量不为任何线程所占用，它处于触发状态

2）如果线程ID为非零值，那么一个线程已经占用了该互斥量，它处与未触发状态。

3）与所有其他内核对象不同，操作系统对互斥量进行了特殊处理，允许它们违反一些常规的规则。（递归计数器的存在，运行同一个线程ID多次进入）

创建互斥量

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
CreateMutexW(
    _In_opt_ LPSECURITY_ATTRIBUTES lpMutexAttributes,
    _In_ BOOL bInitialOwner,
    _In_opt_ LPCWSTR lpName
    );

bInitialOwner控制互斥量的初始状态。FALSE， 互斥量的线程ID和递归计数都被设为0.处于触发状态。

给bInitialOwner穿TRUE，那么对象的线程ID被设为调用线程的ID，递归计数器被设为1.（未触发状态）

或者使用CreateMutexEx

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
CreateMutexExW(
    _In_opt_ LPSECURITY_ATTRIBUTES lpMutexAttributes,
    _In_opt_ LPCWSTR lpName,
    _In_ DWORD dwFlags,
    _In_ DWORD dwDesiredAccess
    );

dwDesiredAccess指定访问权限

dwFlags（代替bInitialOwned） 0表示FALSE，  CREATE_MUTEX_INITIAL_OWNER等价于TRUE

另一个进程可以调用OpenMutex来得到一个已经存在的互斥量句柄。

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
OpenMutexW(
    _In_ DWORD dwDesiredAccess,
    _In_ BOOL bInheritHandle,
    _In_ LPCWSTR lpName
    );

BOOL ReleaseMutex(HANDLE hMutex); 

使互斥量对象的递归计数器减1， 当递归计数器为0时，还会设置线程ID为0，这就触发了对象。

9.6.1 遗弃问题

互斥量具有线程所有权的功能，即使未触发也能多次进入。

如果占用互斥量的线程在释放互斥量之前终止（ExitThread ，TerminateThread ，ExitProcess 或TerminateProcess）

系统认为互斥量被遗弃（abandoned） 此时会自动将互斥量线程ID设为0，递归计数器设为0，并检查有没有正在等待该互斥量的线程。

等待函数返回WAIT_ABANDONED(只适用互斥量）

9.6.2 互斥量与关键段（临界区）的对比

互斥量的任意时间长度等待修正为： WaitForSingleObject(hmtx, dwMilliseconds);

9.6.3 Queue 示例程序

本章的Queue使用了互斥量和信号量来对一个队列的简单数据元素进行控制。

/******************************************************************************
Module:  Queue.cpp
Notices: Copyright (c) 2008 Jeffrey Richter & Christophe Nasarre
******************************************************************************/


#include "..\CommonFiles\CmnHdr.h"
#include <windowsx.h>
#include <tchar.h>
#include <StrSafe.h>
#include "Resource.h"

//

class CQueue {
public:
	struct ELEMENT {
		int m_nThreadNum, m_nRequestNum;
		// Other element data should go there
	};
	typedef ELEMENT * PELEMENT;

private:
	PELEMENT	m_pElements;		// Array of elements to be processed
	int			m_nMaxElements;		// Maximum # of elements in the array
	HANDLE		m_h[2];				// Mutex & semaphore handles
	HANDLE		&m_hmtxQ;			// Reference to m_h[0]
	HANDLE		&m_hsemNumElements;	// Reference to m_h[1]

public:
	CQueue(int nMaxElements);
	~CQueue();

	BOOL Append(PELEMENT pElement, DWORD dwMilliseconds);
	BOOL Remove(PELEMENT pElement, DWORD dwMilliseconds);
};

//

CQueue::CQueue(int nMaxElements)
	: m_hmtxQ(m_h[0]),
	m_hsemNumElements(m_h[1]) {

	m_pElements = (PELEMENT)
		HeapAlloc(GetProcessHeap(), 0, sizeof(ELEMENT) * nMaxElements);
	m_nMaxElements = nMaxElements;
	m_hmtxQ = CreateMutex(NULL, FALSE, NULL);
	m_hsemNumElements = CreateSemaphore(NULL, 0, nMaxElements, NULL);
}

//

CQueue::~CQueue() {

	CloseHandle(m_hsemNumElements);
	CloseHandle(m_hmtxQ);
	HeapFree(GetProcessHeap(), 0, m_pElements);
}

//

BOOL CQueue::Append(PELEMENT pElement, DWORD dwTimeout) {

	BOOL fOk = FALSE;
	DWORD dw = WaitForSingleObject(m_hmtxQ, dwTimeout);

	if (dw == WAIT_OBJECT_0) {
		// This thread has exclusive access to the queue

		// Increment the number of elements in the queue
		LONG lPrevCount;
		fOk = ReleaseSemaphore(m_hsemNumElements, 1, &lPrevCount);
		if (fOk) {
			// The queue is not full, append the new element
			m_pElements[lPrevCount] = *pElement;
		}
		else {

			// The queue is full, set the error code and return failure
			SetLastError(ERROR_DATABASE_FULL);
		}

		// Allow other threads to access the queue
		ReleaseMutex(m_hmtxQ);
	}
	else {
		// Timeout, set error code and return failure
		SetLastError(ERROR_TIMEOUT);
	}

	return fOk;		// Call GetLastError for more info
}

//

BOOL CQueue::Remove(PELEMENT pElement, DWORD dwTimeout) {

	// Wait for exclusive access to queue and for queue to have element.
	BOOL fOk = (WaitForMultipleObjects(_countof(m_h), m_h, TRUE, dwTimeout)
		== WAIT_OBJECT_0);

	if (fOk) {
		// The queue has an element, pull it from the queue
		*pElement = m_pElements[0];

		// Shift the remaining elements down
		MoveMemory(&m_pElements[0], &m_pElements[1],
			sizeof(ELEMENT) * (m_nMaxElements - 1));

		// Allow other threads to access the queue
		ReleaseMutex(m_hmtxQ);
	}
	else {
		// Timeout, set error code and return failure
		SetLastError(ERROR_TIMEOUT);
	}

	return fOk;		// Call GetLastError for more info
}


//

CQueue g_q(10);						// The shared queue
volatile LONG g_fShutdown = FALSE;	// Signals client/server threads to die
HWND g_hwnd;						// How client/server threads give status

// Handles to all client/server threads & number of client/server threads
HANDLE	g_hThreads[MAXIMUM_WAIT_OBJECTS];
int		g_nNumThreads = 0;

//

DWORD WINAPI ClientThread(PVOID pvParam) {

	int nThreadNum = PtrToUlong(pvParam);
	HWND hwndLB = GetDlgItem(g_hwnd, IDC_CLIENTS);

	int nRequestNum = 0;
	while (1 != InterlockedCompareExchange(&g_fShutdown, 0, 0)) {

		// Keep track of the current processed element
		nRequestNum++;

		TCHAR sz[1024];
		CQueue::ELEMENT e = { nThreadNum, nRequestNum };

		// Try to put an element on the queue
		if (g_q.Append(&e, 200)) {

			// Indicate which thread sent it and which request
			StringCchPrintf(sz, _countof(sz), TEXT("Sending %d:%d"),
				nThreadNum, nRequestNum);
		}
		else {

			// Couldn't put an element on the queue
			StringCchPrintf(sz, _countof(sz), TEXT("Sending %d:%d (%s)"),
				nThreadNum, nRequestNum, (GetLastError() == ERROR_TIMEOUT)
				? TEXT("timeout") : TEXT("full"));
		}

		// Show result of appending element
		ListBox_SetCurSel(hwndLB, ListBox_AddString(hwndLB, sz));
		Sleep(2500);	// Wait before appending another element
	}

	return 0;
}

//

DWORD WINAPI ServerThread(PVOID pvParam) {

	int nThreadNum = PtrToUlong(pvParam);
	HWND hwndLB = GetDlgItem(g_hwnd, IDC_SERVERS);

	while (1 != InterlockedCompareExchange(&g_fShutdown, 0, 0)) {

		TCHAR sz[1024];
		CQueue::ELEMENT e;

		// Try to get an element from the queue
		if (g_q.Remove(&e, 5000)) {

			// Indicate which thread is processing it, which thread
			// sent it and which request we're processing
			StringCchPrintf(sz, _countof(sz), TEXT("%d: Processing %d:%d"),
				nThreadNum, e.m_nThreadNum, e.m_nRequestNum);

			// The server takes some time to process the request
			Sleep(2000 * e.m_nThreadNum);
		}
		else {
			// Couldn't get an element from the queue
			StringCchPrintf(sz, _countof(sz), TEXT("%d: (timeout)"), nThreadNum);
		}

		// Show result of processing element
		ListBox_SetCurSel(hwndLB, ListBox_AddString(hwndLB, sz));
	}

	return 0;
}

//

BOOL Dlg_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam) {

	chSETDLGICONS(hwnd, IDI_QUEUE);

	g_hwnd = hwnd;		// Used by client/server threads to show status

	DWORD dwThreadID;

	// Create the client threads
	for (int x = 0; x < 4; x++)
		g_hThreads[g_nNumThreads++] =
		chBEGINTHREADEX(NULL, 0, ClientThread, (PVOID)(INT_PTR)x,
		0, &dwThreadID);

	// Create the server threads
	for (int x = 0; x < 2; x++)
		g_hThreads[g_nNumThreads++] =
		chBEGINTHREADEX(NULL, 0, ServerThread, (PVOID)(INT_PTR)x,
		0, &dwThreadID);

	return TRUE;
}

//

void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) {

	switch (id) {
	case IDCANCEL:
		EndDialog(hwnd, id);
		break;
	}
}


INT_PTR WINAPI Dlg_Proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

	switch (uMsg) {
		chHANDLE_DLGMSG(hwnd, WM_INITDIALOG, Dlg_OnInitDialog);
		chHANDLE_DLGMSG(hwnd, WM_COMMAND, Dlg_OnCommand);
	}

	return FALSE;
}

//

int WINAPI _tWinMain(HINSTANCE hInstExe, HINSTANCE, PTSTR pszCmdLine, int) {

	DialogBox(hInstExe, MAKEINTRESOURCE(IDD_QUEUE), NULL, Dlg_Proc);
	InterlockedExchange(&g_fShutdown, TRUE);

	// Wait for all the threads to terminate & then cleanup
	WaitForMultipleObjects(g_nNumThreads, g_hThreads, TRUE, INFINITE);
	while (g_nNumThreads--)
		CloseHandle(g_hThreads[g_nNumThreads]);

	return 0;
}

 End of File //

9.7 线程同步速查表

9.8 其他线程同步函数

9.8.1 异步设备I/O

异步设备IO（asynchronous device I/O）允许线程开始读取操作或写入操作，但不必等待读取操作或写入操作完成。

设备对象是是可同步的内核对象，可以调用WaitForSingleObject并传入句柄，套接字，通信端口等。

9.8.2 WaitForInputIdle函数

线程可以调用此函数将自己挂起

WINUSERAPI
DWORD
WINAPI
WaitForInputIdle(
    _In_ HANDLE hProcess,
    _In_ DWORD dwMilliseconds);

常用于等待子进程，父进程知道子进程已经初始化完毕的唯一方法，就是等待子进程，直到它不再处理任何输入为止。

当我们要强制在应用程序中输入一些按键的时候，也可以使用WaitForInputIdle。

当向目标进程发送一系列按键消息以后，调用WaitForInputIdle等待其处理完按键消息，然后再发送后续的按键消息。

9.8.3 MsgWaitForMultipleObjects(Ex)函数

WINUSERAPI
DWORD
WINAPI
MsgWaitForMultipleObjects(
    _In_ DWORD nCount,
    _In_reads_opt_(nCount) CONST HANDLE *pHandles,
    _In_ BOOL fWaitAll,
    _In_ DWORD dwMilliseconds,
    _In_ DWORD dwWakeMask);

WINUSERAPI
DWORD
WINAPI
MsgWaitForMultipleObjectsEx(
    _In_ DWORD nCount,
    _In_reads_opt_(nCount) CONST HANDLE *pHandles,
    _In_ DWORD dwMilliseconds,
    _In_ DWORD dwWakeMask,
    _In_ DWORD dwFlags);

函数功能:阻塞时仍可以响应消息


MsgWaitForMultipleObjects()函数类似WaitForMultipleObjects()，


但它会在“对象被激发”或“消息到达队列”时被唤醒而返回。


MsgWaitForMultipleObjects()多接收一个参数，允许指定哪些消息是观察对象。

一个应用的例子 该函数同时等待对象，若有消息到底也返回。运行主线程处理消息后继续等待。

	DWORD dwRet = 0;
	MSG msg;
	DWORD dwStartTime = GetTickCount();
	while (TRUE)
	{
		//超时判断  5s  
		dwRet = GetTickCount() - dwStartTime;
		if ((GetTickCount() - dwStartTime) > 10000)
		{
			AfxMessageBox(_T("获取数据超时，请检测设备网络连接!"), MB_OK | MB_ICONERROR);
			return NULL;
		}

		//wait for m_hThread to be over，and wait for    
		//QS_ALLINPUT（Any message is in the queue）   
		//dwRet = WaitForSingleObject(g_hRetEvent, INFINITE);  
		dwRet = MsgWaitForMultipleObjects(1, &g_hRetEvent, FALSE, 100, QS_ALLINPUT);
		switch (dwRet)
		{
		case WAIT_OBJECT_0: //返回数据达到  
			break; //break the loop    
		case WAIT_OBJECT_0 + 1: //界面消息  
			//get the message from Queue    
			//and dispatch it to specific window    
			if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
			continue;
		case WAIT_TIMEOUT: //超时  
			continue;
		default:
			AfxMessageBox(_T("数据获取失败，未知错误!"), MB_OK | MB_ICONERROR);
			return NULL;
			break; // unexpected failure    
		}
		break;
	}

9.8.4 WaitForDebugEvent 函数

调试器Attach到被调试程序以后，调用WaitForDebugEvent来等待调试事件。

WINBASEAPI
BOOL
APIENTRY
WaitForDebugEvent(
    _Out_ LPDEBUG_EVENT lpDebugEvent,
    _In_ DWORD dwMilliseconds
    );

9.8.5 SignalObjectAndWait函数

WINBASEAPI
DWORD
WINAPI
SignalObjectAndWait(
    _In_ HANDLE hObjectToSignal,
    _In_ HANDLE hObjectToWaitOn,
    _In_ DWORD dwMilliseconds,
    _In_ BOOL bAlertable
    );

使用一个原子操作来触发一个内核对象，并等待另一个内核对象。

hObjectToSignal必须是一个互斥量，信号量或事件。（其他任何对象将导致函数返回WAIT_FAILD）调用GetLastError返回ERROR_INVALID_HANDLE.

hObjectToWaitOn可以是互斥量，信号量，事件，进程，线程，作业，控制台输入变更通知，作业。等等

dwMilliseconds 函数最多花多长时间来等待。

bAlertable表示当线程处于等待状态的时候，是否能够堆添加到队列中的异步过程调用进行处理。

返回值：WAIT_OBJECT_0, WAIT_TIMEOUT, WAIT_FAILED, WAIT)ABANDONED, WAIT_IO_COMPLETION

配合PulseEvent使用。

SignalObjectAndWait释放一个对象，同时立即等待（原子方式）

能确保其100%能看见别的线程调用的PulseEvent。

9.8.6 使用等待链遍历API来检测死锁

Vista系统以上提供了等待链遍历（Wait Chain Traversal， WCT）API，这些函数可以让我们列出所有的锁，并检测进程内部，甚至是进程之间的死锁。

LockCop示例程序

LockCop展示如何使用WCT函数来创建一个非常有用的工具。

等待链

一条等待链是一个序列，在这个序列中线程和同步对象交替出现，每个线程等待它后面的对象，而该对象却为等待链中更后面的线程所占用。

例如3212正在等待线程2260释放一个关键段，而线程2260正在等待线程3212释放另外一个关键段。这就是典型的死锁。

代码LockCop.cpp

/******************************************************************************
Module:  LockCop.cpp
Notices: Copyright (c) 2008 Jeffrey Richter & Christophe Nasarre
******************************************************************************/


#include "..\CommonFiles\CmnHdr.h"     /* See Appendix A. */
#include "..\CommonFiles\ToolHelp.h"
#include "ChainParser.h"
#include "resource.h"

#include <windowsx.h>
#include <tchar.h>
#include <StrSafe.h>


///


// Global Variables
HINSTANCE		g_hInstance;
HWND			g_hDlg;

#define DETAILS_CTRL	GetDlgItem(g_hDlg, IDC_EDIT_DETAILS)
//

// Adds a String to the "Details" edit control
void AddText(PCTSTR pszFormat, ...) {

	va_list argList;
	va_start(argList, pszFormat);

	TCHAR sz[20 * 1024];
	
	Edit_GetText(DETAILS_CTRL, sz, _countof(sz));
	_vstprintf_s(
		_tcschr(sz, TEXT('\0')), _countof(sz) - _tcslen(sz),
		pszFormat, argList);
	Edit_SetText(DETAILS_CTRL, sz);
	va_end(argList);
}

//

void OnRefreshProcesses()
{
	HWND hwndList = GetDlgItem(g_hDlg, IDC_COMBO_PROCESS);
	SetWindowRedraw(hwndList, FALSE);
	ComboBox_ResetContent(hwndList);

	CToolhelp thProcesses(TH32CS_SNAPPROCESS);
	PROCESSENTRY32 pe = { sizeof(pe) };
	BOOL fOk = thProcesses.ProcessFirst(&pe);
	for (; fOk; fOk = thProcesses.ProcessNext(&pe)) {
		TCHAR sz[1024];

		// Place the process name(without its path) & ID in the list
		PCTSTR pszExeFile = _tcschr(pe.szExeFile, TEXT('\\'));
		if (pszExeFile == NULL) {
			pszExeFile = pe.szExeFile;
		}
		else {
			pszExeFile++;		// skip over the slash
		}

		StringCchPrintf(sz, _countof(sz), TEXT("%04u - %s"), pe.th32ProcessID, pszExeFile);
		int n = ComboBox_AddString(hwndList, sz);

		// Associate the process ID with the added item
		ComboBox_SetItemData(hwndList, n, pe.th32ProcessID);
	}
	ComboBox_SetCurSel(hwndList, 0);	// Select the first entry

	// Simulate the user selecting this first item so that the
	// results pane shows something interesting
	FORWARD_WM_COMMAND(g_hDlg, IDC_COMBO_PROCESS,
		hwndList, CBN_SELCHANGE, SendMessage);

	SetWindowRedraw(hwndList, TRUE);
	InvalidateRect(hwndList, NULL, FALSE);
}

//

void OnUpdateLocks()
{
	SetWindowText(DETAILS_CTRL, TEXT(""));	// Clear the output box

	// GetCurrent process from the combo box
	HWND hwndCtl = GetDlgItem(g_hDlg, IDC_COMBO_PROCESS);
	DWORD dwSelection = ComboBox_GetCurSel(hwndCtl);
	DWORD PID = (DWORD)ComboBox_GetItemData(hwndCtl, dwSelection);

	AddText(TEXT("Thread in process %u\r\n"), PID);

	CChainParser parser(DETAILS_CTRL);
	parser.ParseThreads(PID);
}


//

void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) {

	switch (id) {
	case IDOK:
	case IDCANCEL:
		// User has clicked on the OK button
		// or dismissed the dialog with ESCAPE
		EndDialog(hwnd, id);
		break;

	case IDC_COMBO_PROCESS:
		if (codeNotify == CBN_SELCHANGE) {
			OnUpdateLocks();
		}
		break;

	case IDC_BTN_REFRESH:
		OnRefreshProcesses();
		break;

	case IDC_BTN_UPDATE:
		OnUpdateLocks();
		break;
	}
}

//

BOOL Dlg_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam) {

	chSETDLGICONS(hwnd, IDI_LOCKCOP);

	// Keep track of the main dialog window handle
	g_hDlg = hwnd;

	// Have the results window use a fixed-pitch font
	SetWindowFont(GetDlgItem(hwnd, IDC_EDIT_DETAILS),
		GetStockFont(ANSI_FIXED_FONT), FALSE);

	// Fill up the process combo-box
	OnRefreshProcesses();

	return TRUE;
}

//

INT_PTR WINAPI Dlg_Proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

	switch (uMsg) {
		chHANDLE_DLGMSG(hwnd, WM_COMMAND, Dlg_OnCommand);
		chHANDLE_DLGMSG(hwnd, WM_INITDIALOG, Dlg_OnInitDialog);
	}

	return FALSE;
}

//

int APIENTRY _tWinMain(HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPTSTR lpCmdLine,
	int nCmdShow) {

	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

	// Keep track of the module handle
	g_hInstance = hInstance;

	// Enabling the debug privilege allows the application to see
	// Information about service applications
	CToolhelp::EnablePrivilege(SE_DEBUG_NAME, TRUE);

	// Show main window
	DialogBox(hInstance, MAKEINTRESOURCE(IDD_LOCKCOP), NULL, Dlg_Proc);

	// Restore privileges
	// Even though it is not really important since the process is existing
	CToolhelp::EnablePrivilege(SE_DEBUG_NAME, FALSE);

	return 0;
}

运行结果（检测例子BadLock）

LockCop不支持WaitForMultileObjects