《Windows核心编程》の线程间同步

Windows中线程间同步的方法主要有：事件（Event）、临界区（Critical Section）、互斥量（Mutex）和信号灯（Semaphore）。

1）使用事件对象进行线程间同步：
在使用CreateEvent函数创建事件对象时，将bManualReset参数设置为FALSE，然后在需要独占操作的代码前面加上一个WaitForSingleObject函数，后面加上一个SetEvent即可。
由于bManualReset参数为FALSE，这样当某个线程等待到Event后，Event对象的状态马上就变为复位状态，这样其他线程执行到WaitForSingleObject时就全部处于等待中了，当活动的线程操作完毕后，执行SetEvent函数，Event对象的状态才恢复到置位，这样其他等待的线程才会有一个能继续操作。

SetEvent函数原型如下：
HANDLE WINAPI CreateEvent(
__in_opt LPSECURITY_ATTRIBUTES lpEventAttributes, //安全描述符
__in BOOL bManualReset, //指定事件对象是否需要手动复位
__in BOOL bInitialState, //指定事件对象创建时的初始状态，为TRUE表示初始状态是置位状态；
//为FALSE表示初始状态是复位状态
__in_opt LPCTSTR lpName //指定事件对象名称
);
当一个事件被创建后，程序就可以通过SetEvent和ResetEvent函数来设置事件的状态：
BOOL WINAPI SetEvent(
__in HANDLE hEvent
);
BOOL WINAPI ResetEvent(
__in HANDLE hEvent
);

事件对象不仅可以用于一个进程中多线程同步，还可以用于多进程中的线程同步，只要在创建事件对象时指定事件名字，在其他进程中可以使用OpenEvent函数根据名称打开该事件对象进行使用：
HANDLE WINAPI OpenEvent(
__in DWORD dwDesiredAccess, //对事件对象的访问限制
__in BOOL bInheritHandle, //子进程是否继承该事件句柄
__in LPCTSTR lpName //事件对象的名字
);

实例代码如下：
#include <windows.h>
#include <stdio.h>

#define THREADCOUNT 4

HANDLE ghWriteEvent;
HANDLE ghThreads[THREADCOUNT];

DWORD WINAPI ThreadProc(LPVOID);

void CreateEventsAndThreads(void)
{
int i;
DWORD dwThreadID;

// Create a manual-reset event object. The write thread sets this
// object to the nonsignaled state when it finishes writing to a
// shared buffer.

ghWriteEvent = CreateEvent(
NULL, // default security attributes
TRUE, // manual-reset event
FALSE, // initial state is nonsignaled
TEXT("WriteEvent") // object name
);

if (ghWriteEvent == NULL)
{
printf("CreateEvent failed (%d)/n", GetLastError());
return;
}

// Create multiple threads to read from the buffer.

for(i = 0; i < THREADCOUNT; i++)
{
// TODO: More complex scenarios may require use of a parameter
// to the thread procedure, such as an event per thread to
// be used for synchronization.
ghThreads[i] = CreateThread(
NULL, // default security
0, // default stack size
ThreadProc, // name of the thread function
NULL, // no thread parameters
0, // default startup flags
&dwThreadID);

if (ghThreads[i] == NULL)
{
printf("CreateThread failed (%d)/n", GetLastError());
return;
}
}
}

void WriteToBuffer(VOID)
{
// TODO: Write to the shared buffer.

printf("Main thread writing to the shared buffer.../n");

// Set ghWriteEvent to signaled

if (! SetEvent(ghWriteEvent) )
{
printf("SetEvent failed (%d)/n", GetLastError());
return;
}
}

void CloseEvents()
{
// Close all event handles (currently, only one global handle).

CloseHandle(ghWriteEvent);
}

void main()
{
DWORD dwWaitResult;

// TODO: Create the shared buffer

// Create events and THREADCOUNT threads to read from the buffer

CreateEventsAndThreads();

// At this point, the reader threads have started and are most
// likely waiting for the global event to be signaled. However,
// it is safe to write to the buffer because the event is a
// manual-reset event.

WriteToBuffer();

printf("Main thread waiting for threads to exit.../n");

// The handle for each thread is signaled when the thread is
// terminated.
dwWaitResult = WaitForMultipleObjects(
THREADCOUNT, // number of handles in array
ghThreads, // array of thread handles
TRUE, // wait until all are signaled
INFINITE);

switch (dwWaitResult)
{
// All thread objects were signaled
case WAIT_OBJECT_0:
printf("All threads ended, cleaning up for application exit.../n");
break;

// An error occurred
default:
printf("WaitForMultipleObjects failed (%d)/n", GetLastError());
return;
}

// Close the events to clean up

CloseEvents();
}

DWORD WINAPI ThreadProc(LPVOID lpParam)
{
DWORD dwWaitResult;

printf("Thread %d waiting for write event.../n", GetCurrentThreadId());

dwWaitResult = WaitForSingleObject(
ghWriteEvent, // event handle
INFINITE); // indefinite wait

switch (dwWaitResult)
{
// Event object was signaled
case WAIT_OBJECT_0:
//
// TODO: Read from the shared buffer
//
printf("Thread %d reading from buffer/n",
GetCurrentThreadId());
break;

// An error occurred
default:
printf("Wait error (%d)/n", GetLastError());
return 0;
}

// Now that we are done reading the buffer, we could use another
// event to signal that this thread is no longer reading. This
// example simply uses the thread handle for synchronization (the
// handle is signaled when the thread terminates.)

printf("Thread %d exiting/n", GetCurrentThreadId());
return 1;
}

2）使用临界区对象进行线程间同步：
临界区对象（Critical Section）是定义在数据段中的一个CRITICAL_SECTION结构，它的维护和测试工作都是由Windows来完成的。结构应该定义成全局变量，因为在各线程中都有测试它。
定义了CRITICAL_SECTION结构后，必须首先对其进行初始化：
void WINAPI InitializeCriticalSection(
__out LPCRITICAL_SECTION lpCriticalSection
);
由于Windows系统保证临界区对象同时只能被一个线程进入，所以在需要独占操作的代码前加上进入临界区的操作，在代码后面加上离开临界区的操起，就可以保证操作的独占性了。
进入临界区的工作由函数EnterCriticalSection来完成：
void WINAPI EnterCriticalSection(
__inout LPCRITICAL_SECTION lpCriticalSection
);
如果当前其他线程拥有临界区，函数不会返回；反之如果函数返回就表示现在可以独占数据了。
当完成操作时，将临界区交还给Windows，以便其他线程可以申请使用，这个工作由函数LeaveCriticalSection来完成：
void WINAPI LeaveCriticalSection(
__inout LPCRITICAL_SECTION lpCriticalSection
);

最后，当程序不再需要临界区时，必须使用函数DeleteCriticalSection将它删除：
void WINAPI DeleteCriticalSection(
__inout LPCRITICAL_SECTION lpCriticalSection
);

与事件对象不同，由于临界区对象无法命名，所以无法跨进程使用，但正是因为事件对象可以跨进程使用，需要占用更多的资源，所以相比之下临界区对象在速度上的优势很明显。
使用临界区的缺点在于，如果某个线程进入临界区后挂掉了，那么将无法被其他等待的线程检测到，因为这些线程都被陷在EnterCriticalSection函数中了。而使用事件则不同，它可以在WaitForSingleObject函数中指定一个超时时间。
一般在对速度要求比较高，且不必跨进程进行同步的情况下，建议使用临界区对象。

实例代码片段如下：
// Global variable
CRITICAL_SECTION CriticalSection;

void main()
{
...

// Initialize the critical section one time only.
if (!InitializeCriticalSectionAndSpinCount(&CriticalSection,
0x80000400) )
return;
...

// Release resources used by the critical section object.
DeleteCriticalSection(&CriticalSection);
}

DWORD WINAPI ThreadProc( LPVOID lpParameter )
{
...

// Request ownership of the critical section.
EnterCriticalSection(&CriticalSection);

// Access the shared resource.

// Release ownership of the critical section.
LeaveCriticalSection(&CriticalSection);

...
}

3）使用互斥量对象进行线程间同步：
和临界区类似，互斥量也是一种只允许一个线程获取的对象，但它是可以命名的，因而是可以跨越进程使用的。
互斥量使用CreateMutex函数创建：
HANDLE WINAPI CreateMutex(
__in_opt LPSECURITY_ATTRIBUTES lpMutexAttributes, //安全描述符
__in BOOL bInitialOwner, //为TRUE，表示创建它的线程直接获取了该互斥量；
// 为FALSE，表示互斥量创建后处于空闲状态
__in_opt LPCTSTR lpName //指定互斥对象的名字，可以使用OpenMutex来打开
);

释放互斥量使用函数ReleaseMutex，但是首先调用该函数的线程必须拥有该互斥量，这一点和使用Event不同，在任何线程中都可以使用SetEvent函数来将Event对象置位：
BOOL WINAPI ReleaseMutex(
__in HANDLE hMutex
);

互斥量是靠WaitForSingleObject函数来获取的，当互斥量被某个线程获取（即等待成功）后，它的状态是复位的，否则是置位的。
当不再使用互斥量时，可以使用CloseHandle来关闭它。
使用互斥量进行同步的缺点和使用事件对象类似，也是在效率上远远低于使用临界区；优点也是类似的，就是可以跨进程使用，可以检测到其他线程是否挂掉。

实例代码如下：
#include <windows.h>
#include <stdio.h>

#define THREADCOUNT 2

HANDLE ghMutex;

DWORD WINAPI WriteToDatabase( LPVOID );

void main()
{
HANDLE aThread[THREADCOUNT];
DWORD ThreadID;
int i;

// Create a mutex with no initial owner

ghMutex = CreateMutex(
NULL, // default security attributes
FALSE, // initially not owned
NULL); // unnamed mutex

if (ghMutex == NULL)
{
printf("CreateMutex error: %d/n", GetLastError());
return;
}

// Create worker threads

for( i=0; i < THREADCOUNT; i++ )
{
aThread[i] = CreateThread(
NULL, // default security attributes
0, // default stack size
(LPTHREAD_START_ROUTINE) WriteToDatabase,
NULL, // no thread function arguments
0, // default creation flags
&ThreadID); // receive thread identifier

if( aThread[i] == NULL )
{
printf("CreateThread error: %d/n", GetLastError());
return;
}
}

// Wait for all threads to terminate

WaitForMultipleObjects(THREADCOUNT, aThread, TRUE, INFINITE);

// Close thread and mutex handles

for( i=0; i < THREADCOUNT; i++ )
CloseHandle(aThread[i]);

CloseHandle(ghMutex);
}

DWORD WINAPI WriteToDatabase( LPVOID lpParam )
{
DWORD dwCount=0, dwWaitResult;

// Request ownership of mutex.

while( dwCount < 20 )
{
dwWaitResult = WaitForSingleObject(
ghMutex, // handle to mutex
INFINITE); // no time-out interval

switch (dwWaitResult)
{
// The thread got ownership of the mutex
case WAIT_OBJECT_0:
__try {
// TODO: Write to the database
printf("Thread %d writing to database.../n",
GetCurrentThreadId());
dwCount++;
}

__finally {
// Release ownership of the mutex object
if (! ReleaseMutex(ghMutex))
{
// Handle error.
}
}
break;

// The thread got ownership of an abandoned mutex
// The database is in an indeterminate state
case WAIT_ABANDONED:
return FALSE;
}
}
return TRUE;
}

4）使用信号灯对象进行线程间同步：
信号灯对象是一个允许指定数量的线程获取的对象。信号灯对象一般是用于线程排队，考虑这样一种情况：服务器程序设置了3个工作线程以及n个和客户端连接的服务线程，服务线程需要在工作线程空闲时与之通讯，但3个工作线程都很忙的时候，就必须等待。这种情况下设置一个计数值为3的信号灯对象，服务线程和工作线程通讯前会首先尝试获取信号灯，这样就可以保证同时只有3个服务线程可以通过，而其他服务线程处于等待状态。
当信号灯对象的计数值为1时，就相当于一个互斥对象。

创建信号灯对象可以使用函数CreateSemaphore：
HANDLE WINAPI CreateSemaphore(
__in_opt LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, //安全描述符
__in LONG lInitialCount, //初始时计数值
__in LONG lMaximumCount, //对象的最大计数值，即最多允许多少个线程获取该对象
__in_opt LPCTSTR lpName //指定对象的名字
);

释放信号灯对象使用函数ReleaseSemaphore：
BOOL WINAPI ReleaseSemaphore(
__in HANDLE hSemaphore, //
__in LONG lReleaseCount, //指定释放时将计数值增加多少
__out_opt LPLONG lpPreviousCount //函数在此返回释放前的计数值，不需要的话可设为NULL
);
当不再需要信号灯对象时，可以调用CloseHandle函数将它关闭。

信号灯对象是靠WaitForSingleObject函数来获取的，当对象被某个线程获取后，它的计数值减1，当计数值未减到0时，对象的状态是置位的，这意味着还有线程可以继续获取该对象；当计数值减到0时，对象的状态被复位。

实例代码如下：
#include <windows.h>
#include <stdio.h>

#define MAX_SEM_COUNT 10
#define THREADCOUNT 12

HANDLE ghSemaphore;

DWORD WINAPI ThreadProc( LPVOID );

void main()
{
HANDLE aThread[THREADCOUNT];
DWORD ThreadID;
int i;

// Create a semaphore with initial and max counts of MAX_SEM_COUNT

ghSemaphore = CreateSemaphore(
NULL, // default security attributes
MAX_SEM_COUNT, // initial count
MAX_SEM_COUNT, // maximum count
NULL); // unnamed semaphore

if (ghSemaphore == NULL)
{
printf("CreateSemaphore error: %d/n", GetLastError());
return;
}

// Create worker threads

for( i=0; i < THREADCOUNT; i++ )
{
aThread[i] = CreateThread(
NULL, // default security attributes
0, // default stack size
(LPTHREAD_START_ROUTINE) ThreadProc,
NULL, // no thread function arguments
0, // default creation flags
&ThreadID); // receive thread identifier

if( aThread[i] == NULL )
{
printf("CreateThread error: %d/n", GetLastError());
return;
}
}

// Wait for all threads to terminate

WaitForMultipleObjects(THREADCOUNT, aThread, TRUE, INFINITE);

// Close thread and semaphore handles

for( i=0; i < THREADCOUNT; i++ )
CloseHandle(aThread[i]);

CloseHandle(ghSemaphore);
}

DWORD WINAPI ThreadProc( LPVOID lpParam )
{
DWORD dwWaitResult;
BOOL bContinue=TRUE;

while(bContinue)
{
// Try to enter the semaphore gate.

dwWaitResult = WaitForSingleObject(
ghSemaphore, // handle to semaphore
0L); // zero-second time-out interval

switch (dwWaitResult)
{
// The semaphore object was signaled.
case WAIT_OBJECT_0:
// TODO: Perform task
printf("Thread %d: wait succeeded/n", GetCurrentThreadId());
bContinue=FALSE;

// Simulate thread spending time on task
Sleep(5);

// Release the semaphore when task is finished

if (!ReleaseSemaphore(
ghSemaphore, // handle to semaphore
1, // increase count by one
NULL) ) // not interested in previous count
{
printf("ReleaseSemaphore error: %d/n", GetLastError());
}
break;

// The semaphore was nonsignaled, so a time-out occurred.
case WAIT_TIMEOUT:
printf("Thread %d: wait timed out/n", GetCurrentThreadId());
break;
}
}
return TRUE;
}