Waiting for Threads

From RAD Studio
Jump to: navigation, search

Go Up to How To Build Multithreaded Applications

The following are procedures that can be used to wait for threads.

  • Wait for a thread to finish executing.
  • Wait for a task to complete.
  • Check if another thread is waiting for your thread to terminate.

To wait for a thread to finish executing

  1. Use the WaitFor method of the other thread.
  2. Code your logic. For example, the following code waits for another thread to fill a thread list object before accessing the objects in the list:
if ListFillingThread.WaitFor then
  with ThreadList1.LockList do
    for I := 0 to Count - 1 do
if( ListFillingThread->WaitFor() ) {
  TList* list = ThreadList1->LockList();
  for( int i = 0; i < list->Count; i++ ) {
    DoSomething( list->Items[i] );

To wait for a task to complete

  1. Create a TEvent object of global scope.
  2. When a thread completes an operation other threads are waiting for, have the thread call TEvent.SetEvent.
  3. To turn off the signal, call TEvent.ResetEvent.

The following example is an OnTerminate event handler that uses a global counter in a critical section to keep track of the number of terminating threads. When Counter reaches 0, the handler calls the SetEvent method to signal that all processes have terminated:

procedure TDataModule.TaskTerminateThread(Sender: TObject);
  CounterGuard.Acquire; {obtain a lock on the counter}
  Dec(Counter); {decrement the global counter variable}
  if Counter = 0 then
    Event1.SetEvent; {signal if this is the last thread}
  Counter.Release; {release the lock on the counter}
void __fastcall TDataModule::TaskThreadTerminate( TObject *Sender ) {
  CounterGuard->Acquire(); // lock the counter
  if( --Counter == 0 )      // decrement counter
    Event1->SetEvent();    // signal if this is the last thread
  CounterGuard->Release(); // release lock

The main thread initializes Counter, launches the task threads, and waits for the signal that they are all done by calling the TEvent::WaitFor method. WaitFor waits a specified time period for the signal to be set and returns one of the values in the table below.

The following code example shows how the main thread launches the task threads and resumes when they have completed:

Event1.ResetEvent; {clear the event before launching the threads}
for i := 1 to Counter do
  TaskThread.Create(False); {create and launch the task threads}
if Event1.WaitFor(20000) <> wrSignaled then
  raise Exception;
{continue with main thread}
Event1->ResetEvent();  // clear the event before launching threads
for( int i = 0; i < Counter; i++ ) {
  new TaskThread( false );
if( Event1->WaitFor(20000) != wrSignaled )
  throw Exception;
// now continue with the main thread

Note: If you do not want to stop waiting for an event handler after a specified time period, pass the WaitFor method a parameter value of INFINITE. Be careful when using INFINITE, because your thread will hang if the anticipated signal is never received.

To check if another thread is waiting on your thread to terminate

  1. In your Execute procedure, implement the Terminate method by checking and responding to the Terminated property.
  2. This is one way to code the logic:
procedure TMyThread.Execute;
  while not Terminated do
void __fastcall TMyThread::Execute() {
  while( !Terminated )

WaitFor return values




The signal of the event was set.


The specified time elapsed without the signal being set.


The event object was destroyed before the timeout period elapsed.


An error occurred while waiting.

See Also