CreateEvent Function

點擊打開鏈接
#include "stdafx.h"

#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);
}

int _tmain(int argc, _TCHAR* argv[])
{
	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 1;
	} 

	// Close the events to clean up

	CloseEvents();

	getchar();

	return 0;
}

DWORD WINAPI ThreadProc(LPVOID lpParam) 
{
	// lpParam not used in this example.
	UNREFERENCED_PARAMETER(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;
}