本文实例讲述了java任务调度的常见实现方法与比较。分享给大家供大家参考，具体如下：
简介： 综观目前的 web 应用，多数应用都具备任务调度的功能。本文由浅入深介绍了几种任务调度的 java 实现方法，包括 timer，scheduler, quartz 以及 jcron tab，并对其优缺点进行比较，目的在于给需要开发任务调度的程序员提供有价值的参考。
任务调度是指基于给定时间点，给定时间间隔或者给定执行次数自动执行任务。这里由浅入深介绍四种任务调度的 java 实现：
timer
scheduledexecutor
开源工具包 quartz
开源工具包 jcrontab
此外，为结合实现复杂的任务调度，本文还将介绍 calendar 的一些使用方法。
timer
相信大家都已经非常熟悉 java.util.timer 了，它是最简单的一种实现任务调度的方法，下面给出一个具体的例子：
我要评论
package com.ibm.scheduler;
import java.util.timer;
import java.util.timertask;
public class timertest extends timertask {
private string jobname = "";
public timertest(string jobname) {
super();
this.jobname = jobname;
}
@override
public void run() {
system.out.println("execute " + jobname);
}
public static void main(string[] args) {
timer timer = new timer();
long delay1 = 1 * 1000;
long period1 = 1000;
// 从现在开始 1 秒钟之后，每隔 1 秒钟执行一次 job1
timer.schedule(new timertest("job1"), delay1, period1);
long delay2 = 2 * 1000;
long period2 = 2000;
// 从现在开始 2 秒钟之后，每隔 2 秒钟执行一次 job2
timer.schedule(new timertest("job2"), delay2, period2);
}
}
output:
execute job1 execute job1 execute job2 execute job1 execute job1 execute job2
使用 timer 实现任务调度的核心类是 timer 和 timertask。其中 timer 负责设定 timertask 的起始与间隔执行时间。使用者只需要创建一个 timertask 的继承类，实现自己的 run 方法，然后将其丢给 timer 去执行即可。
timer 的设计核心是一个 tasklist 和一个 taskthread。timer 将接收到的任务丢到自己的 tasklist 中，tasklist 按照 task 的最初执行时间进行排序。timerthread 在创建 timer 时会启动成为一个守护线程。这个线程会轮询所有任务，找到一个最近要执行的任务，然后休眠，当到达最近要执行任务的开始时间点，timerthread 被唤醒并执行该任务。之后 timerthread 更新最近一个要执行的任务，继续休眠。
timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。
scheduledexecutor
鉴于 timer 的上述缺陷，java 5 推出了基于线程池设计的 scheduledexecutor。其设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，scheduedexecutor 才会真正启动一个线程，其余时间 scheduledexecutor 都是在轮询任务的状态。
package com.ibm.scheduler;
import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;
public class scheduledexecutortest implements runnable {
private string jobname = "";
public scheduledexecutortest(string jobname) {
super();
this.jobname = jobname;
}
@override
public void run() {
system.out.println("execute " + jobname);
}
public static void main(string[] args) {
scheduledexecutorservice service = executors.newscheduledthreadpool(10);
long initialdelay1 = 1;
long period1 = 1;
// 从现在开始1秒钟之后，每隔1秒钟执行一次job1
service.scheduleatfixedrate(
new scheduledexecutortest("job1"), initialdelay1,
period1, timeunit.seconds);
long initialdelay2 = 1;
long delay2 = 1;
// 从现在开始2秒钟之后，每隔2秒钟执行一次job2
service.schedulewithfixeddelay(
new scheduledexecutortest("job2"), initialdelay2,
delay2, timeunit.seconds);
}
}
output:
execute job2 execute job1 execute job2 execute job1 execute job2 execute job1
清单 2 展示了 scheduledexecutorservice 中两种最常用的调度方法 scheduleatfixedrate 和 schedulewithfixeddelay。scheduleatfixedrate 每次执行时间为上一次任务开始起向后推一个时间间隔，即每次执行时间为 :initialdelay, initialdelay+period, initialdelay+2*period, …；schedulewithfixeddelay 每次执行时间为上一次任务结束起向后推一个时间间隔，即每次执行时间为：initialdelay, initialdelay+executetime+delay, initialdelay+2*executetime+2*delay。由此可见，scheduleatfixedrate 是基于固定时间间隔进行任务调度，schedulewithfixeddelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度。
timer 和 scheduledexecutor 都仅能提供基于开始时间与重复间隔的任务调度，不能胜任更加复杂的调度需求。比如，设置每星期二的 16:38:10 执行任务。该功能使用 timer 和 scheduledexecutor 都不能直接实现，但我们可以借助 calendar 间接实现该功能。
package com.ibm.scheduler;
import java.util.calendar;
import java.util.date;
import java.util.timertask;
import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;
public class scheduledexceutortest2 extends timertask {
private string jobname = "";
public scheduledexceutortest2(string jobname) {
super();
this.jobname = jobname;
}
@override
public void run() {
system.out.println("date = "+new date()+", execute " + jobname);
}
/**
* 计算从当前时间currentdate开始，满足条件dayofweek, hourofday,
* minuteofhour, secondofminite的最近时间
* @return
*/
public calendar getearliestdate(calendar currentdate, int dayofweek,
int hourofday, int minuteofhour, int secondofminite) {
//计算当前时间的week_of_year,day_of_week, hour_of_day, minute,second等各个字段值
int currentweekofyear = currentdate.get(calendar.week_of_year);
int currentdayofweek = currentdate.get(calendar.day_of_week);
int currenthour = currentdate.get(calendar.hour_of_day);
int currentminute = currentdate.get(calendar.minute);
int currentsecond = currentdate.get(calendar.second);
//如果输入条件中的dayofweek小于当前日期的dayofweek,则week_of_year需要推迟一周
boolean weeklater = false;
if (dayofweek < currentdayofweek) {
weeklater = true;
} else if (dayofweek == currentdayofweek) {
//当输入条件与当前日期的dayofweek相等时，如果输入条件中的
//hourofday小于当前日期的
//currenthour，则week_of_year需要推迟一周
if (hourofday < currenthour) {
weeklater = true;
} else if (hourofday == currenthour) {
//当输入条件与当前日期的dayofweek, hourofday相等时，
//如果输入条件中的minuteofhour小于当前日期的
//currentminute，则week_of_year需要推迟一周
if (minuteofhour < currentminute) {
weeklater = true;
} else if (minuteofhour == currentsecond) {
//当输入条件与当前日期的dayofweek, hourofday，
//minuteofhour相等时，如果输入条件中的
//secondofminite小于当前日期的currentsecond，
//则week_of_year需要推迟一周
if (secondofminite < currentsecond) {
weeklater = true;
}
}
}
}
if (weeklater) {
//设置当前日期中的week_of_year为当前周推迟一周
currentdate.set(calendar.week_of_year, currentweekofyear + 1);
}
// 设置当前日期中的day_of_week,hour_of_day,minute,second为输入条件中的值。
currentdate.set(calendar.day_of_week, dayofweek);
currentdate.set(calendar.hour_of_day, hourofday);
currentdate.set(calendar.minute, minuteofhour);
currentdate.set(calendar.second, secondofminite);
return currentdate;
}
public static void main(string[] args) throws exception {
scheduledexceutortest2 test = new scheduledexceutortest2("job1");
//获取当前时间
calendar currentdate = calendar.getinstance();
long currentdatelong = currentdate.gettime().gettime();
system.out.println("current date = " + currentdate.gettime().tostring());
//计算满足条件的最近一次执行时间
calendar earliestdate = test
.getearliestdate(currentdate, 3, 16, 38, 10);
long earliestdatelong = earliestdate.gettime().gettime();
system.out.println("earliest date = "
+ earliestdate.gettime().tostring());
//计算从当前时间到最近一次执行时间的时间间隔
long delay = earliestdatelong - currentdatelong;
//计算执行周期为一星期
long period = 7 * 24 * 60 * 60 * 1000;
scheduledexecutorservice service = executors.newscheduledthreadpool(10);
//从现在开始delay毫秒之后，每隔一星期执行一次job1
service.scheduleatfixedrate(test, delay, period,
timeunit.milliseconds);
}
}
output:
current date = wed feb 02 17:32:01 cst 2011 earliest date = tue feb 8 16:38:10 cst 2011 date = tue feb 8 16:38:10 cst 2011, execute job1 date = tue feb 15 16:38:10 cst 2011, execute job1
清单 3 实现了每星期二 16:38:10 调度任务的功能。其核心在于根据当前时间推算出最近一个星期二 16:38:10 的绝对时间，然后计算与当前时间的时间差，作为调用 scheduledexceutor 函数的参数。计算最近时间要用到 java.util.calendar 的功能。首先需要解释 calendar 的一些设计思想。calendar 有以下几种唯一标识一个日期的组合方式：
year + month + day_of_month
year + month + week_of_month + day_of_week
year + month + day_of_week_in_month + day_of_week
year + day_of_year
year + day_of_week + week_of_year
上述组合分别加上 hour_of_day + minute + second 即为一个完整的时间标识。本例采用了最后一种组合方式。输入为 day_of_week, hour_of_day, minute, second 以及当前日期 , 输出为一个满足 day_of_week, hour_of_day, minute, second 并且距离当前日期最近的未来日期。计算的原则是从输入的 day_of_week 开始比较，如果小于当前日期的 day_of_week，则需要向 week_of_year 进一， 即将当前日期中的 week_of_year 加一并覆盖旧值；如果等于当前的 day_of_week, 则继续比较 hour_of_day；如果大于当前的 day_of_week，则直接调用 java.util.calenda 的 calendar.set(field, value) 函数将当前日期的 day_of_week, hour_of_day, minute, second 赋值为输入值，依次类推，直到比较至 second。读者可以根据输入需求选择不同的组合方式来计算最近执行时间。
可以看出，用上述方法实现该任务调度比较麻烦，这就需要一个更加完善的任务调度框架来解决这些复杂的调度问题。幸运的是，开源工具包 quartz 与 jcrontab 提供了这方面强大的支持。
quartz 可以满足更多更复杂的调度需求，首先让我们看看如何用 quartz 实现每星期二 16:38 的调度安排：
package com.ibm.scheduler;
import java.util.date;
import org.quartz.job;
import org.quartz.jobdetail;
import org.quartz.jobexecutioncontext;
import org.quartz.jobexecutionexception;
import org.quartz.scheduler;
import org.quartz.schedulerfactory;
import org.quartz.trigger;
import org.quartz.helpers.triggerutils;
public class quartztest implements job {
@override
//该方法实现需要执行的任务
public void execute(jobexecutioncontext arg0) throws jobexecutionexception {
system.out.println("generating report - "
+ arg0.getjobdetail().getfullname() + ", type ="
+ arg0.getjobdetail().getjobdatamap().get("type"));
system.out.println(new date().tostring());
}
public static void main(string[] args) {
try {
// 创建一个scheduler
schedulerfactory schedfact =
new org.quartz.impl.stdschedulerfactory();
scheduler sched = schedfact.getscheduler();
sched.start();
// 创建一个jobdetail，指明name，groupname，以及具体的job类名，
//该job负责定义需要执行任务
jobdetail jobdetail = new jobdetail("myjob", "myjobgroup",
quartztest.class);
jobdetail.getjobdatamap().put("type", "full");
// 创建一个每周触发的trigger，指明星期几几点几分执行
trigger trigger = triggerutils.makeweeklytrigger(3, 16, 38);
trigger.setgroup("mytriggergroup");
// 从当前时间的下一秒开始执行
trigger.setstarttime(triggerutils.getevenseconddate(new date()));
// 指明trigger的name
trigger.setname("mytrigger");
// 用scheduler将jobdetail与trigger关联在一起，开始调度任务
sched.schedulejob(jobdetail, trigger);
} catch (exception e) {
e.printstacktrace();
}
}
}
output:
generating report - myjobgroup.myjob, type =full tue feb 8 16:38:00 cst 2011 generating report - myjobgroup.myjob, type =full tue feb 15 16:38:00 cst 2011
清单 4 非常简洁地实现了一个上述复杂的任务调度。quartz 设计的核心类包括 scheduler, job 以及 trigger。其中，job 负责定义需要执行的任务，trigger 负责设置调度策略，scheduler 将二者组装在一起，并触发任务开始执行。
更多关于java相关内容感兴趣的读者可查看本站专题：《java数据结构与算法教程》、《java字符与字符串操作技巧总结》、《java日期与时间操作技巧汇总》、《java操作dom节点技巧总结》和《java缓存操作技巧汇总》
希望本文所述对大家java程序设计有所帮助。
如对本文有疑问， 点击进行留言回复！！
springmvc之ResponseBody响应json数据遇到的错误及解决
uni-app 后台升级 静默升级 uniapp 后台更新 静默更新 在线升级
SpringBoot多Module启动报错Could not transfer metadata
Hibernate项目报错：Cannot call sendError() after the response has been committed
网友评论