Синхронизация потоков с использованием событий в Windows

Question

Мне нужно синхронизировать потоки, используя события.Во-первых, я не понимаю концепцию событий в Windows.Я возьму пример, у меня есть основной поток и дополнительный поток.Я создал два события под названием «запись» и «тест».В основном потоке я сигнализировал о событии «запись» и ждал события «тест». Оба события получают сигнал.

В основном я портирую appli из linux в windows. Программа linux использует переменную условия длясигнализация потока. Переменная условия недоступна в окне XP.

Пример:

#include <windows.h>
#include <stdio.h>

#define THREADCOUNT 1

HANDLE ghWriteEvent;
HANDLE ghtestEvent;
HANDLE ghThreads[THREADCOUNT];

DWORD WINAPI ThreadProc(LPVOID);

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

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

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

    if (ghtestEvent  == 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)
{
    DWORD dwWaitResult;
    printf("Main thread writing to the shared buffer...\n");

    printf("Posting Events for %d\n",ghWriteEvent );

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

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

    printf("WaitForSingleObject signelled (%d)\n", GetLastError());

    if ( dwWaitResult == WAIT_OBJECT_0)
    printf("Signlled State for %d with ret val : %d\n",ghtestEvent,dwWaitResult );
}

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

    CloseHandle(ghWriteEvent);
}

int main( void )
{
    DWORD dwWaitResult;

    CreateEventsAndThreads();

    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();

    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

    printf("rcvd event for Write is  %d \n", ghWriteEvent);
    switch (dwWaitResult)
    {
        // Event object was signaled
        case WAIT_OBJECT_0:
                WaitForSingleObject(
                                ghtestEvent, // event handle
                                INFINITE);    // indefinite wait

            printf("rcvd event for %d with Error %d\n", ghtestEvent,GetLastError());

            if ( dwWaitResult == WAIT_OBJECT_0)
            {
                printf("Test event signaled for second thread \n");
            }
            break;

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

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

Output of the program is:
Main thread writing to the shared buffer...
Posting Events for 2012
WaitForSingleObject signelled (183)
Signlled State for 2008 with ret val : 0
Main thread waiting for threads to exit...
Thread 2016 waiting for write event...
rcvd event for Write is  2012 
rcvd event for 2008 with Error 0
Test event signaled for second thread 
Thread 2016 exiting
All threads ended, cleaning up for application exit...

Answer 1

После долгой борьбы я выяснил причину.Если два события создаются с одним и тем же именем, второе событие при создании вызовет ошибку «ERROR_ALREADY_EXISTS (183).

Если событие создано с другим именем, оно работает без проблем. Это хорошая программа для проверкиошибка и действуйте соответственно.

ghtestEvent = CreateEvent(
    NULL,               // default security attributes
    FALSE,               // manual-reset event
    FALSE,              // initial state is nonsignaled
    TEXT("WriteEvent")  // object name
    );
 if ( ERROR_ALREADY_EXISTS == GetLastError() )
 {
        printf("unable to create event (%d)\n".GetLastError());
        exit(0);
 }      

С уважением, Джонни

Answer 2

Вам нужно называть события только в том случае, если вы собираетесь использовать их для взаимодействия между процессами. Вы можете передать NULL в качестве имени, если вы используете потоки синхронизации только в одном процессе.

Когда я создаю именованные объекты синхронизации для межпроцессного взаимодействия, я обычно даю им описательное имя (например, «MyCompany - MyApp - WriteEvent») и добавляю GUID для хорошей меры. Вы не хотите иметь конфликт имен с другим разработчиком, который назвал свое событие «WriteEvent». Имя может быть длиной до MAX_PATH символов, без потери производительности.