Killing current TimerTask

[Victor Subick]

Is there an elegant & easy way to kill a current(executing) TimerTask if a certain time has elapsed (Say 2 minutes). This situation can occur if my TimerTask is blocked on IO.
My code implements a TimeMonitor class and listener interface. Based on code from JavaWorld tips 125. http://www.javaworld.com/javaworld/javatips/jw-javatip125.html
I am trying to stop the current executing TimerTask thread if a certain time has elapsed.
Here is the code.
TimeMonitorListener.java

package mypackage;
/**
 * An Interface for the implementation of a Dynamic Schedule Listener.
 * 
 */
interface TimeMonitorListener
{
    /** 
     * Invoked when the period interval has elapsed. 
     *    
     * @param period interval to sleep before waking up thread.
     */
    void wakeUp( long period );
}

TimeMonitor.java

package mypackage;
import java.util.*;
import java.io.*;
import java.net.*;
/**
 * A Monitoring device enabling the listening for a change based on interval 
 * timestamp. 
 */
public class TimeMonitor 
{
    // Singleton Instance
    private static final TimeMonitor instance = new TimeMonitor();    
    private static final long defaultScheduleDelay = 1000 * 60 * 5; // 5 Min. 
 
    // Timing device enabling timing device as a daemon.
    private Timer timer;
    static TimeMonitorTask task = null;
    /**
     * @return Singleton instance of TimeMonitor.
     */
    public static TimeMonitor getInstance() 
    {
        return instance;
    }
    /**
     * Constructs Time Monitor, cannot call directly because Singleton method
     * contructs instance.
     */    
    protected TimeMonitor() 
    { 
        // Create timer, run timer thread as daemon.
        timer = new Timer( true );
    }
    
    /** 
     * Add a monitored file with a TimeMonitorListener.
     *
     * @param listener listener to notify when timestamp changed.
     * @param period polling period in milliseconds.
     */
    public void addTimeMonitorListener( TimeMonitorListener listener 
                                        , long period )
        throws IllegalStateException
    {
        removeTimeMonitorListener();
        task = new TimeMonitorTask( listener, period );
        try
        {
            timer.schedule( task, 0, period );
        }
        catch( IllegalArgumentException error )
        {
            timer.schedule( task, 0, defaultScheduleDelay );
        }
    }
    /** 
     * Remove the listener from the Timer. Only one task can be scheduled at a 
     * time.
     *
     * @param listener the listener to be removed.
     * @param period key to identify unique object.
     */
    private void removeTimeMonitorListener() 
    {
        if( task != null ) 
        {
            task.cancel();
        }
    }  
    /**
     * Notifies Listener if schedule time has elapsed.
     *
     * @param listener the listener to notify.
     * @param period key to identify unique object.
     */
    protected void fireTimeChangeEvent( TimeMonitorListener listener 
                                        , long period ) 
    {
        listener.wakeUp( period );
    }
    /**
     * Inner class allows functionality to time a task. 
     */  
    class TimeMonitorTask extends TimerTask 
    {
        private static final long MAX_TARDINESS = 1000 * 60 * 30; // 1/2 hour
        private final TimeMonitorListener listener;
        private final long period;
        /**
         * Constructs a timed task for monitoring. 
         * 
         * @param   listener   TimeMonitorListener that we need refrence to.
         * @param   fileName   name of file we want to listen.
         */
        public TimeMonitorTask( TimeMonitorListener listener, long period ) 
        {
            this.listener = listener;
            this.period = period;
        }
        /**
         * Thread run method.
         */
        public void run() 
        {
            if( System.currentTimeMillis() - scheduledExecutionTime() 
                    <  MAX_TARDINESS )
                fireTimeChangeEvent( this.listener, this.period );         
        }
    }
}

Calling class with main method: Test.java

package mypackage;
public class Test implements TimeMonitorListener
{
    public Test()
    {
        long delay = 2000; //2 seconds
        TimeMonitor.getInstance().addTimeMonitorListener( this, delay );
    }
    public void wakeUp( long interval )
    {
        System.out.println( "Hello" );    
    }
    public static void main( String[] args ) throws InterruptedException
    {
        Test test = new Test();
        while( true )
        {
            Thread.sleep( Long.MAX_VALUE );
        }
    }
}

[ August 07, 2003: Message edited by: Victor Subick ]