所有类型的 java 应用程序一般都需要计划重复执行的任务。企业应用程序需要计划每日的日志或者晚间批处理过程。一个 j2se 或者 j2me 日历应用程序需要根据用户的约定计划闹铃时间。不过，标准的调度类 timer 和 timertask 没有足够的灵活性，无法支持通常需要的计划任务类型。在本文中，java 开发人员 tom white 向您展示了如何构建一个简单通用的计划框架，以用于执行任意复杂的计划任务。
　　
　　我将把 java.util.timer 和 java.util.timertask 统称为 java 计时器框架，它们使程序员可以很容易地计划简单的任务（注意这些类也可用于 j2me 中）。在 java 2 sdk, standard edition, version 1.3 中引入这个框架之前，开发人员必须编写自己的调度程序，这需要花费很大精力来处理线程和复杂的 object.wait() 方法。不过，java 计时器框架没有足够的能力来满足许多应用程序的计划要求。甚至一项需要在每天同一时间重复执行的任务，也不能直接使用 timer 来计划，因为在夏令时开始和结束时会出现时间跳跃。
　　
　　本文展示了一个通用的 timer 和 timertask 计划框架，从而允许更灵活的计划任务。这个框架非常简单 ―― 它包括两个类和一个接口 ―― 并且容易掌握。如果您习惯于使用 java 定时器框架，那么您应该可以很快地掌握这个计划框架。
　　
　　计划单次任务
　　计划框架建立在 java 定时器框架类的基础之上。因此，在解释如何使用计划框架以及如何实现它之前，我们将首先看看如何用这些类进行计划。
　　
　　想像一个煮蛋计时器，在数分钟之后（这时蛋煮好了）它会发出声音提醒您。清单 1 中的代码构成了一个简单的煮蛋计时器的基本结构，它用 java 语言编写：
　　
　　清单 1. eggtimer 类
　　
　　package org.tiling.scheduling.examples;
　　
　　import java.util.timer;
　　import java.util.timertask;
　　
　　public class eggtimer {
　　　　private final timer timer = new timer();
　　　　private final int minutes;
　　
　　　　public eggtimer(int minutes) {
　　　　　　this.minutes = minutes;
　　　　}
　　
　　　　public void start() {
　　　　　　timer.schedule(new timertask() {
　　　　　　　　public void run() {
　　　　　　　　　　playsound();
　　　　　　　　　　timer.cancel();
　　　　　　　　}
　　　　　　　　private void playsound() {
　　　　　　　　　　system.out.println("your egg is ready!");
　　　　　　　　　　// start a new thread to play a sound...
　　　　　　　　}
　　　　　　}, minutes * 60 * 1000);
　　　　}
　　
　　　　public static void main(string[] args) {
　　　　　　eggtimer eggtimer = new eggtimer(2);
　　　　　　eggtimer.start();
　　　　}
　　
　　}
　　eggtimer 实例拥有一个 timer 实例，用于提供必要的计划。用 start() 方法启动煮蛋计时器后，它就计划了一个 timertask，在指定的分钟数之后执行。时间到了，timer 就在后台调用 timertask 的 start() 方法，这会使它发出声音。在取消计时器后这个应用程序就会中止。
　　
　　计划重复执行的任务
　　通过指定一个固定的执行频率或者固定的执行时间间隔，timer 可以对重复执行的任务进行计划。不过，有许多应用程序要求更复杂的计划。例如，每天清晨在同一时间发出叫醒铃声的闹钟不能简单地使用固定的计划频率 86400000 毫秒（24 小时），因为在钟拨快或者拨慢（如果您的时区使用夏令时）的那些天里，叫醒可能过晚或者过早。解决方案是使用日历算法计算每日事件下一次计划发生的时间。而这正是计划框架所支持的。考虑清单 2 中的 alarmclock 实现：
　　
　　清单 2. alarmclock 类
　　
　　package org.tiling.scheduling.examples;
　　
　　import java.text.simpledateformat;
　　
　　import java.util.date;
　　
　　import org.tiling.scheduling.scheduler;
　　import org.tiling.scheduling.schedulertask;
　　import org.tiling.scheduling.examples.iterators.dailyiterator;
　　
　　public class alarmclock {
　　
　　　　private final scheduler scheduler = new scheduler();
　　　　private final simpledateformat dateformat =
　　　　　　new simpledateformat("dd mmm yyyy hh:mm:ss.sss");
　　　　private final int hourofday, minute, second;
　　
　　　　public alarmclock(int hourofday, int minute, int second) {
　　　　　　this.hourofday = hourofday;
　　　　　　this.minute = minute;
　　　　　　this.second = second;
　　　　}
　　
　　　　public void start() {
　　　　　　scheduler.schedule(new schedulertask() {
　　　　　　　　public void run() {
　　　　　　　　　　soundalarm();
　　　　　　　　}
　　　　　　　　private void soundalarm() {
　　　　　　　　　　system.out.println("wake up! " +
　　　　　　　　　　　　"it's " + dateformat.format(new date()));
　　　　　　　　　　// start a new thread to sound an alarm...
　　　　　　　　}
　　　　　　}, new dailyiterator(hourofday, minute, second));
　　　　}
　　
　　　　public static void main(string[] args) {
　　　　　　alarmclock alarmclock = new alarmclock(7, 0, 0);
　　　　　　alarmclock.start();
　　　　}
　　}
　　注意这段代码与煮蛋计时器应用程序非常相似。alarmclock 实例拥有一个 scheduler （而不是 timer）实例，用于提供必要的计划。启动后，这个闹钟对 schedulertask （而不是 timertask）进行调度用以发出报警声。这个闹钟不是计划一个任务在固定的延迟时间后执行，而是用 dailyiterator 类描述其计划。在这里，它只是计划任务在每天上午 7:00 执行。下面是一个正常运行情况下的输出：
　　
　　wake up! it's 24 aug 2003 07:00:00.023
　　wake up! it's 25 aug 2003 07:00:00.001
　　wake up! it's 26 aug 2003 07:00:00.058
　　wake up! it's 27 aug 2003 07:00:00.015
　　wake up! it's 28 aug 2003 07:00:00.002
　　...
　　
　　dailyiterator 实现了 scheduleiterator，这是一个将 schedulertask 的计划执行时间指定为一系列 java.util.date 对象的接口。然后 next() 方法按时间先后顺序迭代 date 对象。返回值 null 会使任务取消（即它再也不会运行）―― 这样的话，试图再次计划将会抛出一个异常。清单 3 包含 scheduleiterator 接口：
　　
　　清单 3. scheduleiterator 接口
　　
　　package org.tiling.scheduling;
　　
　　import java.util.date;
　　
　　public interface scheduleiterator {
　　　　public date next();
　　}
　　dailyiterator 的 next() 方法返回表示每天同一时间（上午 7:00）的 date 对象，如清单 4 所示。所以，如果对新构建的 next() 类调用 next()，那么将会得到传递给构造函数的那个日期当天或者后面一天的 7:00 am。再次调用 next() 会返回后一天的 7:00 am，如此重复。为了实现这种行为，dailyiterator 使用了 java.util.calendar 实例。构造函数会在日历中加上一天，对日历的这种设置使得第一次调用 next() 会返回正确的 date。注意代码没有明确地提到夏令时修正，因为 calendar 实现（在本例中是 gregoriancalendar）负责对此进行处理，所以不需要这样做。
　　
　　清单 4. dailyiterator 类
　　
　　package org.tiling.scheduling.examples.iterators;
　　
　　import org.tiling.scheduling.scheduleiterator;
　　
　　import java.util.calendar;
　　import java.util.date;
　　
　　/**
　　 * a dailyiterator class returns a sequence of dates on subsequent days
　　 * representing the same time each day.
　　 */
　　public class dailyiterator implements scheduleiterator {
　　　　private final int hourofday, minute, second;
　　　　private final calendar calendar = calendar.getinstance();
　　
　　　　public dailyiterator(int hourofday, int minute, int second) {
　　　　　　this(hourofday, minute, second, new date());
　　　　}
　　
　　　　public dailyiterator(int hourofday, int minute, int second, date date) {
　　　　　　this.hourofday = hourofday;
　　　　　　this.minute = minute;
　　　　　　this.second = second;
　　　　　　calendar.settime(date);
　　　　　　calendar.set(calendar.hour_of_day, hourofday);
　　　　　　calendar.set(calendar.minute, minute);
　　　　　　calendar.set(calendar.second, second);
　　　　　　calendar.set(calendar.millisecond, 0);
　　　　　　if (!calendar.gettime().before(date)) {
　　　　　　　　calendar.add(calendar.date, -1);
　　　　　　}
　　　　}
　　
　　　　public date next() {
　　　　　　calendar.add(calendar.date, 1);
　　　　　　return calendar.gettime();
　　　　}
　　
　　}