Alternative to Thread.Sleep

Question

Working on a windows service, which has to process request in every predefined interval of time. Thread.Sleep does the work perfectly fine but problem with this is when service is invoked to be stopped, service freeze if thread is in sleep mode. I have read about the alternative approach like Timer, but problem with that is after that defined interval new thread is getting started. Is there a better way to achieve same result and not run in to issue.

Answer 1

What you're looking for is the ability to respond to the notification of two different events - (1) when the timer elapses and (2) when the service is stopped. @Anurag Ranhjan is on the right track with WaitHandle, but you have two events, not one. To properly handle this, do the following.

First, define the two events you care about using ManualResetEvent. You can use AutoResetEvent if you prefer; I just prefer resetting the events manually.

using System.Threading;
ManualResetEvent shutdownEvent = new ManualResetEvent();
ManualResetEvent elapsedEvent = new ManualResetEvent();

You need to trigger these events when they occur. For the shutdownEvent, it's easy. In the OnStop callback of your Windows service, just set the event.

protected override void OnStop
{
    shutdownEvent.Set();
}

For the elapsedEvent, you could do this a couple different ways. You could create a background thread, i.e., the ThreadPool, that uses Thread.Sleep. When the thread wakes up, set the elapsedEvent and go back to sleep. Since it's a background thread, it won't hang your service when it shuts down. The alternative, as you've already suggested, is to use a timer. This is how I do it.

using System.Timers;
Timer timer = new Timer();
timer.Interval  = 5000;   // in milliseconds
timer.Elapsed  += delegate { elapsedEvent.Set(); };
timer.AutoReset = false;  // again, I prefer manual control
timer.Start();

Now that you've got events being set properly, put them in a WaitHandle array.

WaitHandle[] handles = new WaitHandle[]
{
    shutdownEvent,
    elapsedEvent
};

Instead of the WaitHandle.WaitOne method, use the WaitHandle.WaitAny method inside a while loop, like this.

while (!shutdownEvent.WaitOne())
{
    switch (WaitHandle.WaitAny(handles))
    {
        case 0:  // The shutdownEvent was triggered!
            break;
        case 1:  // The elapsedEvent was triggered!
            Process();             // do your processing here
            elapsedEvent.Reset();  // reset the event manually
            timer.Start();         // restart the timer manually
            break;
        default:
            throw new Exception("unexpected switch case");
    }
}

I've condensed this example from production code in my project. I know this mechanism works, but I may have missed something in the writeup. Let me know if you have any questions.