Using Thread.Join to Ensure a Worker Thread Has Exited

Using threads is difficult. A developers coding complexity increases dramatically. Issues such as reentrance, deadlock and race conditions are difficult to detect and avoid. Creating, using and ending threads all require careful implementation of managing thread lifetimes.

In this discussion, we look at one way a thread can synchronize itself with another thread waiting for it to complete. This technique can be used as part of an orderly shutdown of worker threads. The System.Threading.Thread class has an instance member called Join that can provide this type of functionality. Join provides several overloads. Using Join is not difficult. But, using it wisely is.

For the simple Join case, we can call the Join overload that takes no arguments. This call will block until the thread being joined to has ended. The call is simple, but dangerous. Consider when this joined thread never ends! The calling thread would then be hung and would not be able to continue until some other thread interrupted or aborted it. This special case is difficult to code and best avoided if possible.

Thankfully Join also provides overloads that require a timeout parameter. Their use is preferred. These overloads take either a millisecond or a TimeSpan timeout. They both return a bool that is true to indicated the joined thread has exited, false otherwise.

<-- Example 1 ------------------------------->



// The semantics here are:

//     The current thread calling Join(), "joins" the myThread thread instance.

//     myThread is the thread being joined to.

//     The current thread is then blocked until the myThread's ThreadStart delegate target 

//     has returned control back to the CLR by exiting.



myThread.Join();  // blocks until myThread completes



// At this point, myThread has exited.



<-- Example 2 ------------------------------->



// Created on some managing thread

ManualResetEvent quit = new ManualResetEvent(false);

// ThreadProc is defined and used as the delegate target.

// Somehow, the ThreadProc has access to quit WaitHandle

Thread t = new Thread(new ThreadStart(ThreadProc));



// managing thread signals created thread it is time to quit

quit.Set();



// Assumes the created thread will monitor the quit WaitHandle to know when to quit.

// The amount of time until the thread quits is application dependent.

// Choose an appropriate timeout for the Join below when considering this.



// later the managing thread waits for the created thread to exit

if (!t.Join(2000)) {

    // report aborting thread

    t.Abort();

}