Using Event Objects
Win32-based applications use event objects in a number of situations to notify
a waiting thread of the occurrence of an event. For example, overlapped I/O
operations on files, named pipes, and communications devices use an event object
to signal their completion. For more information about the use of event objects
in overlapped I/O operations, see
Synchronization and Overlapped Input and Output.
In the following example, an application uses event objects to prevent several
threads from reading from a shared memory buffer while a master thread is
writing to that buffer. First, the master thread uses the
CreateEvent function to create a manual-reset event object. The master thread sets the
event object to nonsignaled when it is writing to the buffer and then resets the
object to signaled when it has finished writing. Then it creates several reader
threads and an auto-reset event object for each thread. Each reader thread
sets its event object to signaled when it is not reading from the buffer.
#define NUMTHREADS 4
HANDLE hGlobalWriteEvent;
- oid CreateEventsAndThreads(void)
{
HANDLE hReadEvents[NUMTHREADS], hThread;
DWORD i, IDThread;
// Create a manual-reset event object. The master thread sets
// this to nonsignaled when it writes to the shared buffer.
hGlobalWriteEvent = CreateEvent(
NULL, // no security attributes
TRUE, // manual-reset event
TRUE, // initial state is signaled
"WriteEvent" // object name
);
if (hGlobalWriteEvent == NULL) {
// error exit
}
// Create multiple threads and an auto-reset event object
// for each thread. Each thread sets its event object to
// signaled when it is not reading from the shared buffer.
for(i = 1; i <= NUMTHREADS; i++)
{
// Create the auto-reset event.
hReadEvents[i] = CreateEvent(
NULL, // no security attributes
FALSE, // auto-reset event
TRUE, // initial state is signaled
NULL); // object not named
if (hReadEvents[i] == NULL)
{
// Error exit.
}
hThread = CreateThread(NULL, 0,
(LPTHREAD_START_ROUTINE) ThreadFunction,
&hReadEvents[i], // pass event handle
0, &IDThread);
if (hThread == NULL)
{
// Error exit.
}
}
}
Before the master thread writes to the shared buffer, it uses the
ResetEvent function to set the state of hGlobalWriteEvent (an application-defined global
variable) to nonsignaled. This blocks the reader threads from starting a read
operation. The master then uses the
WaitForMultipleObjects function to wait for all reader threads to finish any current read
operations. When
WaitForMultipleObjects returns, the master thread can safely write to the buffer. After it has
finished, it sets hGlobalWriteEvent and all the reader-thread events to signaled,
enabling the reader threads to resume their read operations.
VOID WriteToBuffer(VOID)
{
DWORD dwWaitResult, i;
// Reset hGlobalWriteEvent to nonsignaled, to block readers.
if (! ResetEvent(hGlobalWriteEvent) )
{
// Error exit.
}
// Wait for all reading threads to finish reading.
dwWaitResult = WaitForMultipleObjects(
NUMTHREADS, // number of handles in array
hReadEvents, // array of read-event handles
TRUE, // wait until all are signaled
INFINITE); // indefinite wait
switch (dwWaitResult)
{
// All read-event objects were signaled.
case WAIT_OBJECT_0:
// Write to the shared buffer.
break;
// An error occurred.
default:
printf("Wait error: %d\n", GetLastError());
ExitProcess(0);
}
// Set hGlobalWriteEvent to signaled.
if (! SetEvent(hGlobalWriteEvent) )
{
// Error exit.
}
// Set all read events to signaled.
for(i = 1; i <= NUMTHREADS; i++)
if (! SetEvent(hReadEvents[i]) ) {
// Error exit.
}
}
Before starting a read operation, each reader thread uses
WaitForMultipleObjects to wait for the application-defined global variable hGlobalWriteEvent and its
own read event to be signaled. When
WaitForMultipleObjects returns, the reader thread's auto-reset event has been reset to nonsignaled.
This blocks the master thread from writing to the buffer until the reader
thread uses the
SetEvent function to set the event's state back to signaled.
VOID ThreadFunction(LPVOID lpParam)
{
DWORD dwWaitResult, i;
HANDLE hEvents[2];
hEvents[0] = (HANDLE) *lpParam; // thread's read event
hEvents[1] = hGlobalWriteEvent;
dwWaitResult = WaitForMultipleObjects(
2, // number of handles in array
hEvents, // array of event handles
TRUE, // wait till all are signaled
INFINITE); // indefinite wait
switch (dwWaitResult)
{
// Both event objects were signaled.
case WAIT_OBJECT_0:
// Read from the shared buffer.
break;
// An error occurred.
default:
printf("Wait error: %d\n", GetLastError());
ExitThread(0);
}
// Set the read event to signaled.
if (! SetEvent(hEvents[0]) )
{
// Error exit.
}
}
- Software for developers
-
Delphi Components
.Net Components
Software for Android Developers
- More information resources
-
MegaDetailed.Net
Unix Manual Pages
Delphi Examples
- Databases for Amazon shops developers
-
Amazon Categories Database
Browse Nodes Database
