Timer Delay Degrades or becomes inconsistent over time?

Question

I'm hoping someone can shed some light on what might be happening for me. Here's a summary of whats happening.

I have an application that does lots of "stuff". Its a pretty hefty application that does lots of number crunching using many threads. There are several timers that are used. Over a long period of time, the timers stop consistently invoking the elapsed handler.

For instance: I have a timer set to elapse every second. After a period of hours the timer starts randomly triggering late. If I do not restart the application the performance just degrades and the timers fire later and later eventually turning into 3 or 4 seconds, forcing me to restart the application. I have not been able to identify any leaks. CPU usage does not go up, memory does not go up, and the server is no where near being maxed out. Can anyone give me some ideas as to what may be causing this?

private void Timer_Elapsed(object source, ElapsedEventArgs e)
{
    if (seconds > 0)
    {
        seconds--;

        timer.Start();
    }
}

Answer 1

Sounds like maybe it's not really the same timer, and so the resources being "leaked" here are GDI handles.

Answer 2

Is it possible you're exhausting the thread pool? Most timers invoke the handler using a threadpool thread. If all threadpool threads are in use, it will just get queued until one is available.

If that's the case switch some of your processing to use your own threads, not threadpool threads.

To test if you're exhausting the thread pool start up a background thread that periodically (a few times a second) checks ThreadPool.GetAvailableThreads and logs a message when the available is small (even if it's never actually zero when you check, if it sometimes approaches zero then it's likely this is the problem).

The size of the pool can be changed with ThreadPool.SetMaxThreads although that may not be the best solution. If you're using threadpool threads for longer running tasks, stop it. For long-running tasks use your own threads.

Answer 3

Possible workaround:

DateTime mayContinue = DateTime.MinValue;
bool blockingUi = false;

private void Timer_Elapsed(object source, ElapsedEventArgs e)
{
    if( blockingUi )
    {
        if( DateTime.Now < mayContinue )
        {
            // Notify time remaining
            // Update the UI with a BeginInvoke
        }
        else
        {
            blockingUi = false;
            // Notify ready
            // Update the UI with a BeginInvoke                
        }
    }
}

private void BlockUi()
{
    mayContinue = DateTime.Now.AddSeconds(30);
    blockingUi = true;
}

Answer 4

the timer class you use is really important

http://msdn.microsoft.com/en-us/magazine/cc164015.aspx

but I don't think the problem is the timer itself, for instance try making an application using the same timer class

that ONLY writes the current DateTime to a log file

and leave it running for an extremely long period of time, you'll see that there's no such a 3/4 seconds delay

review your timer code and check that no shared resources are being accessed at the same time, maybe the Timer is OK, but there's a bottleneck in the event handler function or in "something" that function uses