🚀 go-pugleaf

"Eyyub Volkan �ektimur" <evcektimur@prokon.com.tr> wrote in message
news:3f44c115@newsgroups.borland.com...

>     I'm using windows SetEvent method , i need to wait triggered event
> finishs the operation. but SetEvent do not wait triggered event.

SetEvent() triggers the event where other threads are waiting for using
WaitForSingleObject().


> Is there any way to do this ?
> SetEvent(hEvent);
> Wait for finish.... ???

If you want one thread to signal an event and then wait until another thread
has responded to that event, you'll need a second event the calling thread
can wait for and the waiting thread can signal.  E.g.;

thread A:
---------
  SetEvent(hEvent);
  WaitForSingleObject(hEventHandled);

thread B:
---------
  WaitForSingleObject(hEvent);
  // do stuff
  SetEvent(hEventHandled);


This only works with two threads.  When you want more threads to wait for
the event, you'll need some sort of registration mechanism.  This mechanism
will allow multiple threads to register the same event and one particular
thread (the owner) to signal it.  When the owner signals the event, it then
waits until all registered threads notify that they have handled the event.

Thread A creates the event.  Thread B, C and D register the event and wait
for it.  At some point thread A signals the event.  Thread B, C and D
respond to that and when they are done they unregister the event.  When all
threads have unregistered the event, 'thread A is signalled'.

This is just a draft, the registration mechanism is very poor and not
foolproof, but it might give you an idea on how to proceed;


  class MultiEvent {
  private:
    HEVENT m_hEvent;
    HEVENT m_hEventHandled;
    ULONG m_ulRefCount;

  public:
    MultiEvent(): m_ulRefCount(0) {
      m_hEvent = CreateEvent(
        NULL,
        TRUE, /* manual reset */
        FALSE,
        NULL
      );
      m_hEventHandled = CreateEvent(
        NULL,
        FALSE,
        FALSE,
        NULL
      );
    }

    ~MultiEvent() {
      CloseHandle(m_hEvent);
      CloseHandle(m_hEventHandled);
    }

    DWORD Signal() {
      SetEvent(m_hEvent);
      WaitForSingleObject(m_hEventHandled);
    }

    DWORD Register() {
      InterlockedIncrement(&m_ulRefCount);
      return WaitForSingleObject(m_hEvent, INFINITE);
    }

    void Unregister() {
      if(!InterlockedDecrement(&m_ulRefCount)) {
        ResetEvent(m_hEvent);
        SetEvent(m_hEventHandled);
      }
    }
  };


thread A:
  MultiEvent* e = new MultiEvent();
  // do stuff
  e->Signal();


thread B:
  e->Register();
  // handle event
  e->Unregister();

thread C:
  e->Register();
  // handle event
  e->Unregister();

thread D:
  e->Register();
  // handle event
  e->Unregister();


Ralph