Question

#include <windows.h>
#include <iostream>
using namespace std;

int count = 0;

DWORD WINAPI Tf1 ( LPVOID n )
{
    HANDLE hEvent = OpenEvent ( EVENT_ALL_ACCESS , false, (LPCWSTR)"MyEvent" );
    if ( !hEvent ) { return -1; }
    // Loop through and wait for an event to occur
    for ( ;; )
    {
        // Wait for the Event
        WaitForSingleObject ( hEvent, INFINITE );
        count++;
        printf("In function1, Counter value: %d\n",count);
        //    No need to Reset the event as its become non signaled as soon as
        //    some thread catches the event.
        if( count > 7 ) return 0;
    }
    CloseHandle(hEvent);
    return 0;
}

DWORD WINAPI Tf2 ( LPVOID n )
{

    HANDLE hEvent = OpenEvent ( EVENT_MODIFY_STATE , false, (LPCWSTR)"MyEvent" );
    if ( !hEvent ) return -1; 

    for ( ;; )
    {
        if( count % 2 == 0) 
            SetEvent (hEvent);
        else
        {
            count++;
            printf("In function2, Counter value: %d\n",count);
        }
        //    No need to Reset the event as its become non signaled as soon as
        //    some thread catches the event.
        if( count > 7 ) return 0;
    }
    CloseHandle(hEvent);
    return 0;
}

int main()
{
    //    Create an Auto Reset Event which automatically reset to 
    //    Non Signalled state after being signalled
    HANDLE     hEvent = CreateEvent ( NULL , false , false , (LPCWSTR)"MyEvent" );
    if ( !hEvent ) return -1;
    //    Create a Thread Which will wait for the events to occur
    HANDLE mutex = CreateMutex(NULL, FALSE, NULL);

    DWORD Id;
    HANDLE hThrd1 = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE)Tf1,0,0,&Id );
    HANDLE hThrd2 = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE)Tf2,0,0,&Id );

    if ( !hThrd1 ) { CloseHandle (hEvent); return -1; }
    if ( !hThrd2 ) { CloseHandle (hEvent); return -1; }
    // Wait for a while before continuing....
    Sleep ( 1000 );
    // Give the signal twice as the thread is waiting for 2 signals to occur

    // Wait for the Thread to Die
    WaitForSingleObject ( hThrd1, INFINITE );
    WaitForSingleObject ( hThrd2, INFINITE );

    CloseHandle ( hThrd1 );
    CloseHandle ( hThrd2 );
    CloseHandle ( hEvent );

    system ( "PAUSE" );
    return 0;
}

O / P：

In function1, Counter value: 1
In function1, Counter value: 3
In function2, Counter value: 2
In function2, Counter value: 4
In function2, Counter value: 6
In function1, Counter value: 5
In function1, Counter value: 7
In function2, Counter value: 8

期望的O / P：

In function1, Counter value: 1
In function2, Counter value: 2
In function1, Counter value: 3
In function2, Counter value: 4
In function1, Counter value: 5
In function2, Counter value: 6
In function1, Counter value: 7
In function2, Counter value: 8

我知道我没有利用线程的力量。但我的要求是这样的。我怎样才能做到这一点？

Answer 1

如果你想一个接一个地执行一个线程，你可以为每个线程分配一个Id并使用一个共享令牌，假设一个变量，每个线程递增1.一个线程只有当它的值等于这是我的。获取令牌后，线程执行其主体，然后将令牌增加1并释放它。

如果要连续执行代码，使用线程有什么意义？：）

Answer 2

此代码中没有任何可以阻止竞争条件的内容。你需要两个事件，所以线程与信号打乒乓并等待，或者你用一个关键部分保护你的计数器。

选项1：

// Thread 1
{
    increment counter
    Signal event 2
    Wait on event 1
}

// Thread 2
{
    Wait on event 2
    increment counter
    Signal event 1
}

选项2：（使用您现有的范例）

// Thread 1
{
    Wait on event
    Acquire mutex
    if count is even
        increment counter
    end
    Release mutex
}

// Thread 2
{
    Acquire mutex
    if count is even
        Signal event
    else
        increment counter
    end
    Release mutex
}

请注意，选项2在线程2中有点争吵......当线程1响应事件时，它可能会旋转多次。在这方面，您也可以完全删除该事件并将两个线程分开...如果您试图避免这种情况，那么请使用我的选项1.

还有其他方法，包括使用互锁增量，但无论如何都要尝试其中一种。

我想一个接一个地顺序执行线程的执行顺序

2 个答案: