PString New_Job ="";
HWND h_Job = 0;

LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam )
{
  switch( message )
  {
    case WM_COPYDATA:
      COPYDATASTRUCT* pcds;
      pcds = (COPYDATASTRUCT*)lparam;
      } else if (pcds->dwData == 71) {//new job
          h_Job = (HWND)wparam;
          New_Job = PString((LPCTSTR)(pcds->lpData));
          return 1;
...
    case WM_TIMER:
      if (New_Job.GetLength() > 0) {
...
          PString f = New_Job;
...
          'код запуска задания
...
          SendMessage(h_Job, WM_COPYDATA, 0, (LPARAM) &cds); 'сообщение что задание запущено(и можно повторять процесс)

          New_Job = "";
          h_Job = 0;
        }
      }

void OpalConnection::SetPhase(Phases phaseToSet)
{
  //cout << "\nOpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this << "\n";
  //PTRACE(3, "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this);

  try
  {
  PWaitAndSignal m(phaseMutex);
  }
  catch (int i){}

  // With next few lines we will prevent phase to ever go down when it
  // reaches ReleasingPhase - end result - once you call Release you never
  // go back.
  try
  {
  if (phase < ReleasingPhase || (phase == ReleasingPhase && phaseToSet == ReleasedPhase))
    phase = phaseToSet;
  }
  catch (int i){}
}

PWaitAndSignal m(phaseMutex);

On Error resume Next

void OpalConnection::OnReleased(){
...
  SetPhase(ReleasedPhase);
}


void OpalConnection::SetPhase(Phases phaseToSet)
{
  PTRACE(3, "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this);

  PWaitAndSignal m(phaseMutex);

  // With next few lines we will prevent phase to ever go down when it
  // reaches ReleasingPhase - end result - once you call Release you never
  // go back.
  if (phase < ReleasingPhase || (phase == ReleasingPhase && phaseToSet == ReleasedPhase))
    phase = phaseToSet;
}

Sleep (INFINITE);

void OpalConnection::SetPhase(Phases phaseToSet)
{
  try
  {
  cout << "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this << "\n";
  }
  catch (...)
  {
    PTRACE(3, "Problem in SetPhase!");
    Sleep (INFINITE);
  }
  PTRACE(3, "OpalCon\tSetPhase from " << phase << " to " << phaseToSet << " for " << *this);

  PWaitAndSignal m(phaseMutex);

  // With next few lines we will prevent phase to ever go down when it
  // reaches ReleasingPhase - end result - once you call Release you never
  // go back.
  if (phase < ReleasingPhase || (phase == ReleasingPhase && phaseToSet == ReleasedPhase))
    phase = phaseToSet;
}

void OpalConnection::Release(CallEndReason reason)
{
  {
    PWaitAndSignal m(phaseMutex);
    if (phase >= ReleasingPhase) {
      PTRACE(2, "OpalCon\tAlready released " << *this);
      return;
    }
    SetPhase(ReleasingPhase);
  }

  if (synchronousOnRelease) {
    if (!LockReadWrite()) {
      PTRACE(2, "OpalCon\tAlready released " << *this);
      return;
    }

    PTRACE(3, "OpalCon\tReleasing " << *this);

    // Now set reason for the connection close
    SetCallEndReason(reason);

    UnlockReadWrite();

    OnReleased();
    return;
  }

  PTRACE(3, "OpalCon\tReleasing asynchronously " << *this);

  // Add a reference for the thread we are about to start
  SafeReference();
  PThread::Create(PCREATE_NOTIFIER(OnReleaseThreadMain), reason.AsInteger(),
                  PThread::AutoDeleteThread,
                  PThread::NormalPriority,
                  "OnRelease");
}


void OpalConnection::OnReleaseThreadMain(PThread &, INT reason)
{
  if (LockReadWrite()) {
    // Now set reason for the connection close
    SetCallEndReason(CallEndReason(reason));
	UnlockReadWrite();
  }

  OnReleased();

  PTRACE(4, "OpalCon\tOnRelease thread completed for " << *this);

  // Dereference on the way out of the thread
  SafeDereference();
}

  PWaitAndSignal m(phaseMutex);
...
  if (phase < ReleasingPhase || (phase == ReleasingPhase && phaseToSet == ReleasedPhase))
    phase = phaseToSet;

  private:
    PMutex               phaseMutex;
    Phases               phase;

    enum Phases {
      UninitialisedPhase,   //!< Indicates the OpalConnection instance has just been constructed
      SetUpPhase,           //!< In the process of sending/receiving the initial INVITE packet
      ProceedingPhase,      //!< The remote is now responsible for completing the call
      AlertingPhase,        //!< The remote says there is a phone ringing, somewhere
      ConnectedPhase,       //!< There is agreement on having a call, usually means billing will apply
      EstablishedPhase,     //!< Media is flowing, control streams  are all operational
      ForwardingPhase,      //!< Connection is in the process of being forwarded
      ReleasingPhase,       //!< Hangup packet has been sent/received, media and control not yet stopped
      ReleasedPhase,        //!< Media and control streams have been terminated
      NumPhases             //!< Number of available phases. Can be used to indicate an unknown phase
    };

If (задница)
  поток -> спать
  поток -> на выход (как вариант)
else
  делай код как написано
endif

try
  Делай код
catch
  поток -> спать
  поток -> на выход (как вариант)
endif

void OpalConnection::OnReleased()
{ 
  PTRACE(3, "OpalCon\tOnReleased " << *this);

  CloseMediaStreams();

  endpoint.OnReleased(*this);

  __try
  {
    SetPhase(ReleasedPhase);
  }
  __except(EXCEPTION_EXECUTE_HANDLER)
  {
    PTRACE(3,"Thread is closed!");
    ExitThread(13);    
    //PTRACE(3,"Thread is sleeping!");
    //Sleep(INFINITE);
  }
}

2013/10/03 04:45:27.890	     PSimpleThread:6492	Call[Ceeaac12f363] cleared (EndedByRemoteUser)
2013/10/03 04:45:27.890	     PSimpleThread:6492	OpalMan	OnClearedCall Call[Ceeaac12f363] from "t38:FaxTester" to "sip:400@192.168.11.2"
2013/10/03 04:45:27.890	     PSimpleThread:6492	OpalCon	SetPhase from ReleasingPhase to ReleasedPhase for PObject
2013/10/03 04:45:27.890	     PSimpleThread:6492	Thread is closed! //ну это я так считаю.???????
2013/10/03 04:45:27.890	               Pool:964	OpalMan	OnOpenMediaStream 

  __try
  {
    SetPhase(ReleasedPhase);
  }
  __except(EXCEPTION_EXECUTE_HANDLER)
  {
    PTRACE(3,"Thread is closed!");
    ExitThread(13);    
    //Sleep(INFINITE);
  }