How do I block until a thread is returned to the pool?

Question

As part of a windows service I'm accepting incoming socket connection using myListener.BeginAcceptSocket(acceptAsync, null)

The acceptAsync function executes on a seperate thread (just as expected).

When the service is requested to shutdown, I "signal" the threads that accepted and are currently working on the sockets, to finish up.

After signaling each thread to end,I need to block until they are all done. I have a list of threads, that I thought I could iterate through and Join each thread until they were all done.

Howerver it seems that these threads don't end, but return to the pool, so the Join will wait for ever.

How do I block until a thread is returned to the pool?

Answer 1

You shouldn't use Join in this case. Rather, you should use a series of WaitHandles (specifically, an AutoResetEvent or ManualResetEvent) which your threads will signal when they are done with their work.

You would then call the static WaitAll method on the WaitHandle class, passing all of the events to wait on.

Answer 2

The canonical pattern for doing this is to use a CountdownEvent . The main thread will increment the event to indicate that it is participating and the worker threads will do the same once they start. After the worker threads have finished they will decrement the event. When the main thread is ready to wait for completion it should decrement the event and then wait on it. If you are not using .NET 4.0 then you can get an implemention of a countdown event from part 4 of Joe Albahari's threading ebook .

public class Example
{
  private CountdownEvent m_Finisher = new CountdownEvent(0);

  public void MainThread()
  {
    m_Finisher.AddCount();

    // Your stuff goes here.
    // myListener.BeginAcceptSocket(OnAcceptSocket, null);

    m_Finisher.Signal();
    m_Finisher.Wait();
  }

  private void OnAcceptSocket(object state)
  {
    m_Finisher.AddCount()
    try
    {
      // Your stuff goes here.
    }
    finally
    {
      m_Finisher.Signal();
    }
  }
}

Answer 3

The best way would be to change acceptAsync so that it signals on a semaphore, your main thread can then wait on that semaphore.

You don't have a lot of acces to or control over Threapool threads.