🚀 go-pugleaf

In a separate thread:

Brown *BThis = (Brown*)(lpParam);

 if (BThis)
 {
    HANDLE HNDConnectEvnt = BThis->BAMyAlpha->GetConnectEvntHandle();

    if (HNDConnectEvnt)
    {
        for (;;)
       {
            switch (WaitForSingleObject(HNDConnectEvnt, INFINITE))
            {
             case WAIT_OBJECT_0:
             {
                  ResetEvent(HNDConnectEvnt);

                  SOCKET SCKClient;
                  struct sockaddr_in SAClient;

                  BThis->BAMyAlpha->GetClient(0, &SCKClient, &SAClient);
                  BThis->CreateSelectThrd(SCKClient);

                  break;
             }

             case WAIT_FAILED:
                  return 0;
            }
       }
    }
}


In the primary thread:

When user closes the application, Brown is deleted.  In the destructor of
Brown:

Brown::~Brown()
{
     if (BAMyAlpha)
     {
          delete BAMyAlpha;
          BAMyAlpha = NULL;
     }

    if (HNDMonitorThrd)
    {
          switch (WaitForSingleObject(HNDMonitorThrd, INFINITE))
          {
               case WAIT_OBJECT_0:
                    CloseHandle(HNDMonitorThrd);
                    HNDMonitorThrd = NULL;
                    break;

               case WAIT_FAILED:
                    break;
          }
    }
}

In the destructor of BAlpha:

BAlpha::~BAlpha()
{
     if (HNDConnectEvnt)
     {
          CloseHandle(HNDConnectEvnt);
          HNDConnectEvnt = NULL;
     }
}

The creation of the event is done in the constructor of BAlpha, the
following function is called.

void BAlpha::CreateConnectEvnt()
{
     if (BASCurStat == BASReady)
     {
          HNDConnectEvnt = CreateEvent(NULL, TRUE, FALSE, NULL);

          if (HNDConnectEvnt == NULL)
               BASCurStat = BASErrConnectEvnt;
     }
}

Therefore when the application closes, I expect the handle to the event to
be closed during the destruction of BAlpha and
WaitForSingleObject(HNDConnectEvnt, INFINITE) in the separate thread to
return WAIT_FAILED, causing the thread to terminate.

But no, the thread is still stuck in WaitForSingleObject after the handle is
closed, why?  It works if I don't request WaitForSingleObject to wait
forever.

Paul


"Remy Lebeau (TeamB)" <gambit47@yahoo.com> wrote in message
news:3f0fc71d$3@newsgroups.borland.com...
>
> "Paul Ooi" <yitung.ooi@student.unsw.edu.au> wrote in message
> news:3f0f7f61@newsgroups.borland.com...
> > I tried with default, it doesn't work.
>
> Please show your exact code.
>
> > Is it because I close the handle AFTER the wait function is called?
>
> As long as the function is still waiting at the time of the closure, then
> no.
>
>
> Gambit
>
>