Threading Practice with Polling.

Question

I have a C# application that has to constantly read from a program; sometimes there is a chance it will not find what it needs, which will throw an exception. This is a limitation of the program it has to read from.

This frequently causes the program to lock up as it tries to poll. So I solved it by spawning the 'polling' off into a separate thread. However watching the debugger, the thread is created and destroyed each time. I am uncertain if this is typical or not; but my question is, is this good practice, or am I using the threading for the wrong purpose?

ProgramReader
{ 
  static Thread oThread;
  public static void Read( Program program )
  {
    // check to see if the program exists
    if ( false )
      oThread = new ThreadStart(program.Poll);
    if(oThread != null || !oThread.IsAlive )
      oThread.Start();
  }
}

This is my general pseudocode. It runs every 10 seconds or so. Is this a huge hit to performance? The operation it performs is relatively small and lightweight; just repetitive.

Answer 1

Either create a thread which waits and sleeps, or use the ThreadPool, which sounds like the thing to do for your task.

Answer 2

A Thread can't be "restarted", which is why you're seeing what you're seeing in the debugger. It's normal behaviour, but I'm worried about two issues here:

1. You say specifically that the Program will throw an exception sometimes, but you never actually catch it. Unhandled exceptions on background threads will bring down your entire process.

2. You spawn threads regardless of circumstances. It's not clear whether or not Program.Poll is actually thread-safe (my guess is no), and even if it is, you may not want to flood the system with these requests.

A better design would probably be something like:

private AutoResetEvent polledEvent = new AutoResetEvent(true);

public void Read(Program program)
{
    polledEvent.WaitOne();
    ThreadPool.QueueUserWorkItem(s => 
    {
        try
        {
            program.Poll();
        }
        catch (PollingException ex)
        {
            // Handle the exception
        }
        polledEvent.Set();
    });
}

This will solve both of the above problems by handling any exceptions as well as throttling the number of polling requests that can happen at the same time. It also reuses threads by using the ThreadPool.

If the Poll method is really thread-safe and you're OK with several requests being queued up, change the AutoResetEvent to a Semaphore and initialize it with the actual number of requests you want to happen simultaneously.

One final note: If this is happening in a Windows Forms, Windows Service or WPF application, I'd recommend using a BackgroundWorker instead of rolling your own threading code. Most of the work is already done for you there, you just need to write your polling loop inside the DoWork event handler.