The Java 2 SDK 1.3 includes two handy
classes for timed
code execution. If you write a clock
application, for example, you want to update the display every second
or so. Or you might want to play an alarm sound at some predetermined
time. You could accomplish these tasks with multiple threads and
calls to Thread.sleep( )
. But it’s simpler
to use the
java.util.Timer
and
java.util.TimerTask
classes.
Instances of Timer
watch the clock and execute
TimerTask
s at appropriate times. You could, for
example, schedule a task to run at a specific time like this:
import java.util.*; public class Y2K { public static void main(String[] args) { Timer timer = new Timer( ); TimerTask task = new TimerTask( ) { public void run( ) { System.out.println("Boom!"); } }; Calendar c = new GregorianCalendar(2000, Calendar.JANUARY, 1); timer.schedule(task, c.getTime( )); } }
TimerTask
implements the
Runnable
interface. To create a
task, you can simply subclass
TimerTask
and supply a run( )
method. Here we’ve created a simple anonymous subclass of
TimerTask
, which prints a message to
System.out
. Using the schedule( )
method of Timer
,
we’ve asked that the task be run on January 1, 2000.
(Oops—too late! But you get the idea.)
There are some other varieties of schedule( )
; you
can run tasks once or at recurring intervals. There are two kinds of
recurring tasks—fixed
delay and fixed rate. Fixed delay
means that a fixed amount of time elapses between the end of the
task’s execution and the beginning of the next execution. Fixed
rate means that the task should begin execution at fixed time
intervals.
You could, for example, update a clock display every second with code like this:
Timer timer = new Timer( ); TimerTask task = new TimerTask( ) { public void run( ) { repaint( ); // update the clock display } }; timer.schedule(task, 0, 1000);
Timer
can’t really make any guarantees about
exactly when things are executed; you’d need a real-time
operating system for that kind of precision. However,
Timer
can give you reasonable assurance that tasks
will be executed at particular times, provided the tasks are not
overly complex; with a slow-running task, the end of one execution
might spill into the start time for the next execution.