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