Java应用程序中定时执行任务

更新时间:2023-07-08 09:02:46 阅读：评论：0

所有类型的 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.amples;

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

}

}, 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.amples;

SimpleDateFormat;

import java.util.Date;

import org.tiling.scheduling.Scheduler;

import org.tiling.scheduling.SchedulerTask;

import org.amples.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, cond;

public AlarmClock(int hourOfDay, int minute, int cond) {

this.hourOfDay = hourOfDay;

this.minute = minute;

d = cond;

}

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

}

}, new DailyIterator(hourOfDay, minute, cond));

}

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.amples.iterators;

import org.tiling.scheduling.ScheduleIterator;

import java.util.Calendar;

import java.util.Date;

/**

* A DailyIterator class returns a quence of dates on subquent days

* reprenting the same time each day.

public class DailyIterator implements ScheduleIterator {

private final int hourOfDay, minute, cond;

private final Calendar calendar = Instance();

public DailyIterator(int hourOfDay, int minute, int cond) {

this(hourOfDay, minute, cond, new Date());

}

public DailyIterator(int hourOfDay, int minute, int cond, Date date) {

this.hourOfDay = hourOfDay;

this.minute = minute;

d = cond;

calendar.tTime(date);

calendar.t(Calendar.HOUR_OF_DAY, hourOfDay);

calendar.t(Calendar.MINUTE, minute);

calendar.t(Calendar.SECOND, cond);

calendar.t(Calendar.MILLISECOND, 0);

十二星座属性

if (!Time().before(date)) {

calendar.add(Calendar.DATE, -1);

}

public Date next() {

calendar.add(Calendar.DATE, 1);

Time();

}

实现计划框架

在上一节，我们学习了如何使用计划框架，并将它与 Java 定时器框架进行了比较。下面，我将向您展示如何实现这个框架。除了清单 3 中展示的 ScheduleIterator 接口，构成这个框架的还有另外两个类 —— Scheduler 和 SchedulerTask 。这些类实际上在内部使用 Timer 和 SchedulerTask，因为计划其实就是一系列的单次定时器。清单 5 和 6 显示了这两个类的源代码：

清单 5. Scheduler

package org.tiling.scheduling;

import java.util.Date;

import java.util.Timer;

import java.util.TimerTask;

public class Scheduler {

class SchedulerTimerTask extends TimerTask {

private SchedulerTask schedulerTask;

private ScheduleIterator iterator;

public SchedulerTimerTask(SchedulerTask schedulerTask,

ScheduleIterator iterator) {

this.schedulerTask = schedulerTask;

this.iterator = iterator;

}

public void run() {

schedulerTask.run();

reschedule(schedulerTask, iterator);

}

private final Timer timer = new Timer();

public Scheduler() {

}

public void cancel() {

timer.cancel();

}

public void schedule(SchedulerTask schedulerTask,

ScheduleIterator iterator) {

Date time = ();

if (time == null) {

schedulerTask.cancel();

} el {

synchronized(schedulerTask.lock) {

if (schedulerTask.state != SchedulerTask.VIRGIN) {

throw new IllegalStateException("Task already

scheduled " + "or cancelled");

}

schedulerTask.state = SchedulerTask.SCHEDULED;

schedulerTask.timerTask =

new SchedulerTimerTask(schedulerTask, iterator);

timer.schedule(schedulerTask.timerTask, time);

}

private void reschedule(SchedulerTask schedulerTask,

ScheduleIterator iterator) {

Date time = ();

if (time == null) {

schedulerTask.cancel();

} el {

synchronized(schedulerTask.lock) {

if (schedulerTask.state != SchedulerTask.CANCELLED) {

schedulerTask.timerTask =

new SchedulerTimerTask(schedulerTask, iterator);

timer.schedule(schedulerTask.timerTask, time);

}

清单 6 显示了 SchedulerTask 类的源代码：

package org.tiling.scheduling;

import java.util.TimerTask;

public abstract class SchedulerTask implements Runnable {

final Object lock = new Object();

int state = VIRGIN;

static final int VIRGIN = 0;

static final int SCHEDULED = 1;

static final int CANCELLED = 2;

TimerTask timerTask;

protected SchedulerTask() {

}

public abstract void run();

public boolean cancel() {

synchronized(lock) {

if (timerTask != null) {

timerTask.cancel();

}

boolean result = (state == SCHEDULED);

state = CANCELLED;

return result;

}

public long scheduledExecutionTime() {

synchronized(lock) {

return timerTask == null ? 0 : timerTask.scheduledExecutionTime();

}

就像煮蛋计时器，Scheduler 的每一个实例都拥有 Timer 的一个实例，用于提供底层计划。Scheduler 并没有像实现煮蛋计时器时那样使用一个单次定时器，它将一组单次定时器串接在一起，以便在由 ScheduleIterator 指定的各个时间执行 SchedulerTask 类。

考虑 Scheduler 上的 public schedule() 方法 —— 这是计划的入口点，因为它是客户调用的方法（在取消任务一节中将描述仅有的另一个 public 方法 cancel()）。通过调用 ScheduleIterator 接口的 next()，发现第一次执行 SchedulerTask 的时间。然后通过调用底层 Timer 类的单次 schedule() 方法，启动计划在这一时刻执行。为单次执行提供的 TimerTask 对象是嵌入的 SchedulerTimerTask 类的一个实例，它包装了任务和迭代器（iterator）。在指定的时间，调用嵌入类的 run() 方法，它使用包装的任务和迭代器引用以便重新计划任务的下一次执行。reschedule() 方法与 schedule() 方法非常相似，只不过它是 private 的，并且执行一组稍有不同的 SchedulerTask 状态检查。重新计划过程反复重复，为每次计划执行构造一个新的嵌入类实例，直到任务或者调度程序被取消（或者 JV

M 关闭）。

类似于 TimerTask，SchedulerTask 在其生命周期中要经历一系列的状态。创建后，它处于 VIRGIN 状态，这表明它从没有计划过。计划以后，它就变为 SCHEDULED 状态，再用下面描述的方法之一取消任务后，它就变为 CANCELLED 状态。管理正确的状态转变 —— 如保证不对一个非 VIRGIN 状态的任务进行两次计划 —— 增加了 Scheduler 和 SchedulerTask 类的复杂性。在进行可能改变任务状态的操作时，代码必须同步任务的锁对象。

取消任务

取消计划任务有三种方式。第一种是调用 SchedulerTask 的 cancel() 方法。这很像调用 TimerTask 的 cancel()方法：任务再也不会运行了，不过已经运行的任务仍会运行完成。 cancel() 方法的返回值是一个布尔值，表示如果没有调用 cancel() 的话，计划的任务是否还会运行。更准确地说，如果任务在调用 cancel() 之前是 SCHEDULED 状态，那么它就

返回 true。如果试图再次计划一个取消的（甚至是已计划的）任务，那么 Scheduler 就会抛出一个 IllegalStateException。

取消计划任务的第二种方式是让 ScheduleIterator 返回七月流血事件 null。这只是第一种方式的简化操作，因为 Scheduler 类调用 SchedulerTask 类的 cancel()方法。如果您想用迭代器而不是任务来控制计划停止时间时，就用得上这种取消任务的方式了。

第三种方式是通过调用其 cancel() 方法取消整个 Scheduler。这会取消调试程序的所有任务，并使它不能再计划任何任务。

扩展 cron 实用程序

可以将计划框架比作 UNIX 的 cron 实用程序，只不过计划次数的规定是强制性而不是声明性的。例如，在 AlarmClock 实现中使用的 DailyIterator 类，它的计划与 cron 作业的计划相同，都是由以 0 7 * * * 黄色小书开始的 crontab 项指定的（这些字段分别指定分钟、小时、日、

月和星期）。

不过，计划框架比 cron 更灵活。想像一个在早晨打开热水的 HeatingController 应用程序。我想指示它“在每个工作日上午 8:00 打开热水，在周未上午 9:00 打开热水”。使用 cron，我需要两个 crontab 项（0 8 * * 1,2,3,4,5 和 0 9 * * 6,7）。而使用 ScheduleIterator 的解决方案更简洁一些，因为我可以使用复合（composition）来定义单一迭代器。清单 7 显示了其中的一种方法：

清单 7. 用复合定义单一迭代器

本文发布于:2023-07-08 09:02:46，感谢您对本站的认可！

本文链接：https://www.wtabcd.cn/fanwen/fan/89/1072762.html

上一篇：计划流程

下一篇：中英文(双语版)幼儿园一日活动作息时间表

标签：计划任务框架执行时间使用

留言与评论（共有 0 条评论）