几种任务调度的 Java 实现方法与比较

2020-08-24 07:31:49 阅读：291 来源： 互联网

标签：www Java keyword search 几种 https iqiyi 任务调度 com

综观目前的 Web 应用，多数应用都具备任务调度的功能。本文由浅入深介绍了几种任务调度的 Java 实现方法，包括 Timer，Scheduler, Quartz 以及 JCron Tab，并对其优缺点进行比较，目的在于给需要开发任务调度的程序员提供有价值的参考。

前言

任务调度是指基于给定时间点，给定时间间隔或者给定执行次数自动执行任务。本文由浅入深介绍四种任务调度的 Java 实现：

Timer
ScheduledExecutor
开源工具包 Quartz
开源工具包 JCronTab
此外，为结合实现复杂的任务调度，本文还将介绍 Calendar 的一些使用方法。

Timer

相信大家都已经非常熟悉 java.util.Timer 了，它是最简单的一种实现任务调度的方法，下面给出一个具体的例子：

01 package com.ibm.scheduler;
02 import java.util.Timer;
03 import java.util.TimerTask;
04
05 public class TimerTest extends TimerTask {
06
07 private String jobName = "";
08
09 public TimerTest(String jobName) {
10 super();
11 this.jobName = jobName;
12 }
13
14 @Override
15 public void run() {
16 System.out.println("execute " + jobName);
17 }
18
19 public static void main(String[] args) {
20 Timer timer = new Timer();
21 long delay1 = 1 * 1000;
22 long period1 = 1000;
23 // 从现在开始 1 秒钟之后，每隔 1 秒钟执行一次 job1
24 timer.schedule(new TimerTest("job1"), delay1, period1);
25 long delay2 = 2 * 1000;
26 long period2 = 2000;
27 // 从现在开始 2 秒钟之后，每隔 2 秒钟执行一次 job2
28 timer.schedule(new TimerTest("job2"), delay2, period2);
29 }
30 }
31 /**
32 输出结果:
33 execute job1
34 execute job1
35 execute job2
36 execute job1
37 execute job1
38 execute job2
39 */

使用 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 都是在轮询任务的状态。

01 package com.ibm.scheduler;
02 import java.util.concurrent.Executors;
03 import java.util.concurrent.ScheduledExecutorService;
04 import java.util.concurrent.TimeUnit;
05
06 public class ScheduledExecutorTest implements Runnable {
07 private String jobName = "";
08
09 public ScheduledExecutorTest(String jobName) {
10 super();
11 this.jobName = jobName;
12 }
13
14 @Override
15 public void run() {
16 System.out.println("execute " + jobName);
17 }
18
19 public static void main(String[] args) {
20 ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
21
22 long initialDelay1 = 1;
23 long period1 = 1;
24 // 从现在开始1秒钟之后，每隔1秒钟执行一次job1
25 service.scheduleAtFixedRate(
26 new ScheduledExecutorTest("job1"), initialDelay1,
27 period1, TimeUnit.SECONDS);
28
29 long initialDelay2 = 1;
30 long delay2 = 1;
31 // 从现在开始2秒钟之后，每隔2秒钟执行一次job2
32 service.scheduleWithFixedDelay(
33 new ScheduledExecutorTest("job2"), initialDelay2,
34 delay2, TimeUnit.SECONDS);
35 }
36 }
37 /**
38 输出结果:
39 execute job1
40 execute job1
41 execute job2
42 execute job1
43 execute job1
44 execute job2
45 */

上面代码展示了 ScheduledExecutorService 中两种最常用的调度方法 ScheduleAtFixedRate 和 ScheduleWithFixedDelay。ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2period, …；ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2executeTime+2*delay。由此可见，ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度。

用 ScheduledExecutor 和 Calendar 实现复杂任务调度

Timer 和 ScheduledExecutor 都仅能提供基于开始时间与重复间隔的任务调度，不能胜任更加复杂的调度需求。比如，设置每星期二的 16:38:10 执行任务。该功能使用 Timer 和 ScheduledExecutor 都不能直接实现，但我们可以借助 Calendar 间接实现该功能。

001 package com.ibm.scheduler;
002
003 import java.util.Calendar;
004 import java.util.Date;
005 import java.util.TimerTask;
006 import java.util.concurrent.Executors;
007 import java.util.concurrent.ScheduledExecutorService;
008 import java.util.concurrent.TimeUnit;
009
010 public class ScheduledExceutorTest2 extends TimerTask {
011
012 private String jobName = "";
013
014 public ScheduledExceutorTest2(String jobName) {
015 super();
016 this.jobName = jobName;
017 }
018
019 @Override
020 public void run() {
021 System.out.println("Date = "+new Date()+", execute " + jobName);
022 }
023
024 /**
025 * 计算从当前时间currentDate开始，满足条件dayOfWeek, hourOfDay,
026 * minuteOfHour, secondOfMinite的最近时间
027 * @return
028 /
029 public Calendar getEarliestDate(Calendar currentDate, int dayOfWeek,
030 int hourOfDay, int minuteOfHour, int secondOfMinite) {
031 //计算当前时间的WEEK_OF_YEAR,DAY_OF_WEEK, HOUR_OF_DAY, MINUTE,SECOND等各个字段值
032 int currentWeekOfYear = currentDate.get(Calendar.WEEK_OF_YEAR);
033 int currentDayOfWeek = currentDate.get(Calendar.DAY_OF_WEEK);
034 int currentHour = currentDate.get(Calendar.HOUR_OF_DAY);
035 int currentMinute = currentDate.get(Calendar.MINUTE);
036 int currentSecond = currentDate.get(Calendar.SECOND);
037
038 //如果输入条件中的dayOfWeek小于当前日期的dayOfWeek,则WEEK_OF_YEAR需要推迟一周
039 boolean weekLater = false;
040 if (dayOfWeek < currentDayOfWeek) {
041 weekLater = true;
042 } else if (dayOfWeek == currentDayOfWeek) {
043 //当输入条件与当前日期的dayOfWeek相等时，如果输入条件中的
044 //hourOfDay小于当前日期的
045 //currentHour，则WEEK_OF_YEAR需要推迟一周
046 if (hourOfDay < currentHour) {
047 weekLater = true;
048 } else if (hourOfDay == currentHour) {
049 //当输入条件与当前日期的dayOfWeek, hourOfDay相等时，
050 //如果输入条件中的minuteOfHour小于当前日期的
051 //currentMinute，则WEEK_OF_YEAR需要推迟一周
052 if (minuteOfHour < currentMinute) {
053 weekLater = true;
054 } else if (minuteOfHour == currentSecond) {
055 //当输入条件与当前日期的dayOfWeek, hourOfDay，
056 //minuteOfHour相等时，如果输入条件中的
057 //secondOfMinite小于当前日期的currentSecond，
058 //则WEEK_OF_YEAR需要推迟一周
059 if (secondOfMinite < currentSecond) {
060 weekLater = true;
061 }
062 }
063 }
064 }
065 if (weekLater) {
066 //设置当前日期中的WEEK_OF_YEAR为当前周推迟一周
067 currentDate.set(Calendar.WEEK_OF_YEAR, currentWeekOfYear + 1);
068 }
069 // 设置当前日期中的DAY_OF_WEEK,HOUR_OF_DAY,MINUTE,SECOND为输入条件中的值。
070 currentDate.set(Calendar.DAY_OF_WEEK, dayOfWeek);
071 currentDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
072 currentDate.set(Calendar.MINUTE, minuteOfHour);
073 currentDate.set(Calendar.SECOND, secondOfMinite);
074 return currentDate;
075
076 }
077
078 public static void main(String[] args) throws Exception {
079
080 ScheduledExceutorTest2 test = new ScheduledExceutorTest2("job1");
081 //获取当前时间
082 Calendar currentDate = Calendar.getInstance();
083 long currentDateLong = currentDate.getTime().getTime();
084 System.out.println("Current Date = " + currentDate.getTime().toString());
085 //计算满足条件的最近一次执行时间
086 Calendar earliestDate = test
087 .getEarliestDate(currentDate, 3, 16, 38, 10);
088 long earliestDateLong = earliestDate.getTime().getTime();
089 System.out.println("Earliest Date = "
090 + earliestDate.getTime().toString());
091 //计算从当前时间到最近一次执行时间的时间间隔
092 long delay = earliestDateLong - currentDateLong;
093 //计算执行周期为一星期
094 long period = 7 * 24 * 60 * 60 * 1000;
095 ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
096 //从现在开始delay毫秒之后，每隔一星期执行一次job1
097 service.scheduleAtFixedRate(test, delay, period,
098 TimeUnit.MILLISECONDS);
099
100 }
101 }
102 /*
103 输出结果:
104 Current Date = Wed Feb 02 17:32:01 CST 2011
105 Earliest Date = Tue Feb 8 16:38:10 CST 2011
106 Date = Tue Feb 8 16:38:10 CST 2011, execute job1
107 Date = Tue Feb 15 16:38:10 CST 2011, execute job1
108 */

清单 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 可以满足更多更复杂的调度需求，首先让我们看看如何用 Quartz 实现每星期二 16:38 的调度安排：

01 package com.ibm.scheduler;
02 import java.util.Date;
03
04 import org.quartz.Job;
05 import org.quartz.JobDetail;
06 import org.quartz.JobExecutionContext;
07 import org.quartz.JobExecutionException;
08 import org.quartz.Scheduler;
09 import org.quartz.SchedulerFactory;
10 import org.quartz.Trigger;
11 import org.quartz.helpers.TriggerUtils;
12
13 public class QuartzTest implements Job {
14
15 @Override
16 //该方法实现需要执行的任务
17 public void execute(JobExecutionContext arg0) throws JobExecutionException {
18 System.out.println("Generating report - "
19 + arg0.getJobDetail().getFullName() + ", type ="
20 + arg0.getJobDetail().getJobDataMap().get("type"));
21 System.out.println(new Date().toString());
22 }
23 public static void main(String[] args) {
24 try {
25 // 创建一个Scheduler
26 SchedulerFactory schedFact =
27 new org.quartz.impl.StdSchedulerFactory();
28 Scheduler sched = schedFact.getScheduler();
29 sched.start();
30 // 创建一个JobDetail，指明name，groupname，以及具体的Job类名，
31 //该Job负责定义需要执行任务
32 JobDetail jobDetail = new JobDetail("myJob", "myJobGroup",
33 QuartzTest.class);
34 jobDetail.getJobDataMap().put("type", "FULL");
35 // 创建一个每周触发的Trigger，指明星期几几点几分执行
36 Trigger trigger = TriggerUtils.makeWeeklyTrigger(3, 16, 38);
37 trigger.setGroup("myTriggerGroup");
38 // 从当前时间的下一秒开始执行
39 trigger.setStartTime(TriggerUtils.getEvenSecondDate(new Date()));
40 // 指明trigger的name
41 trigger.setName("myTrigger");
42 // 用scheduler将JobDetail与Trigger关联在一起，开始调度任务
43 sched.scheduleJob(jobDetail, trigger);
44
45 } catch (Exception e) {
46 e.printStackTrace();
47 }
48 }
49 }
50 /**
51 输出结果:
52 Generating report - myJobGroup.myJob, type =FULL
53 Tue Feb 8 16:38:00 CST 2011
54 Generating report - myJobGroup.myJob, type =FUL
55 Tue Feb 15 16:38:00 CST 2011
56 */

清单 4 非常简洁地实现了一个上述复杂的任务调度。Quartz 设计的核心类包括 Scheduler, Job 以及 Trigger。其中，Job 负责定义需要执行的任务，Trigger 负责设置调度策略，Scheduler 将二者组装在一起，并触发任务开始执行。

Job

使用者只需要创建一个 Job 的继承类，实现 execute 方法。JobDetail 负责封装 Job 以及 Job 的属性，并将其提供给 Scheduler 作为参数。每次 Scheduler 执行任务时，首先会创建一个 Job 的实例，然后再调用 execute 方法执行。Quartz 没有为 Job 设计带参数的构造函数，因此需要通过额外的 JobDataMap 来存储 Job 的属性。JobDataMap 可以存储任意数量的 Key，Value 对，例如：

1 jobDetail.getJobDataMap().put("myDescription", "my job description");
2 jobDetail.getJobDataMap().put("myValue", 1998);
3 ArrayList list = new ArrayList();
4 list.add("item1");
5 jobDetail.getJobDataMap().put("myArray", list);

JobDataMap 中的数据可以通过下面的方式获取：
01 public class JobDataMapTest implements Job {
02
03 @Override
04 public void execute(JobExecutionContext context)
05 throws JobExecutionException {
06 //从context中获取instName，groupName以及dataMap
07 String instName = context.getJobDetail().getName();
08 String groupName = context.getJobDetail().getGroup();
09 JobDataMap dataMap = context.getJobDetail().getJobDataMap();
10 //从dataMap中获取myDescription，myValue以及myArray
11 String myDescription = dataMap.getString("myDescription");
12 int myValue = dataMap.getInt("myValue");
13 ArrayList myArray = (ArrayListlt;Strin>) dataMap.get("myArray");
14 System.out.println("
15 Instance =" + instName + ", group = " + groupName
16 + ", description = " + myDescription + ", value =" + myValue
17 + ", array item0 = " + myArray.get(0));
18
19 }
20 }
21 /**
22 输出结果：
23 Instance = myJob, group = myJobGroup,
24 description = my job description,
25 value =1998, array item0 = item1
26 */

Trigger

Trigger 的作用是设置调度策略。Quartz 设计了多种类型的 Trigger，其中最常用的是 SimpleTrigger 和 CronTrigger。

SimpleTrigger 适用于在某一特定的时间执行一次，或者在某一特定的时间以某一特定时间间隔执行多次。上述功能决定了 SimpleTrigger 的参数包括 start-time, end-time, repeat count, 以及 repeat interval。

Repeat count 取值为大于或等于零的整数，或者常量 SimpleTrigger.REPEAT_INDEFINITELY。

Repeat interval 取值为大于或等于零的长整型。当 Repeat interval 取值为零并且 Repeat count 取值大于零时，将会触发任务的并发执行。

Start-time 与 dnd-time 取值为 java.util.Date。当同时指定 end-time 与 repeat count 时，优先考虑 end-time。一般地，可以指定 end-time，并设定 repeat count 为 REPEAT_INDEFINITELY。

以下是 SimpleTrigger 的构造方法：

public SimpleTrigger(String name,
String group,
Date startTime,
Date endTime,
int repeatCount,
long repeatInterval)

举例如下：

创建一个立即执行且仅执行一次的 SimpleTrigger：

1 SimpleTrigger trigger=
2 new SimpleTrigger("myTrigger", "myGroup", new Date(), null, 0, 0L);
创建一个半分钟后开始执行，且每隔一分钟重复执行一次的 SimpleTrigger：

1 SimpleTrigger trigger=
2 new SimpleTrigger("myTrigger", "myGroup",
3 new Date(System.currentTimeMillis()+301000), null, 0, 601000);
创建一个 2011 年 6 月 1 日 8:30 开始执行，每隔一小时执行一次，一共执行一百次，一天之后截止的 SimpleTrigger：

01 Calendar calendar = Calendar.getInstance();
02 calendar.set(Calendar.YEAR, 2011);
03 calendar.set(Calendar.MONTH, Calendar.JUNE);
04 calendar.set(Calendar.DAY_OF_MONTH, 1);
05 calendar.set(Calendar.HOUR, 8);
06 calendar.set(Calendar.MINUTE, 30);
07 calendar.set(Calendar.SECOND, 0);
08 calendar.set(Calendar.MILLISECOND, 0);
09 Date startTime = calendar.getTime();
10 Date endTime = new Date (calendar.getTimeInMillis() +2460601000);
11 SimpleTrigger trigger=new SimpleTrigger("myTrigger",
12 "myGroup", startTime, endTime, 100, 6060*1000);
上述最后一个例子中，同时设置了 end-time 与 repeat count，则优先考虑 end-time，总共可以执行二十四次。

CronTrigger 的用途更广，相比基于特定时间间隔进行调度安排的 SimpleTrigger，CronTrigger 主要适用于基于日历的调度安排。例如：每星期二的 16:38:10 执行，每月一号执行，以及更复杂的调度安排等。

CronTrigger 同样需要指定 start-time 和 end-time，其核心在于 Cron 表达式，由七个字段组成：

标签：www,Java,keyword,search,几种,https,iqiyi,任务调度,com
来源： https://www.cnblogs.com/ilpr/p/13551798.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

几种任务调度的 Java 实现方法与比较