spring揭秘31-spring任务调度01-spring集成Quartz及JDKTimer定时器

【README】

本文部分内容总结自《spring揭秘》，作者王福强，非常棒的一本书，墙裂推荐；

本文部分内容总结自： https://juejin.cn/post/7158071449314394119

本文代码参见： github-springDiscover-chapter31

---

【1】Quartz任务调度框架

1）Quartz：是一款开源的任务调度框架； 官网介绍参见： quartz-scheduler

• 官网介绍总结（翻译）： quartz是一款功能丰富的开源作业调度库，可以集成几乎任何java应用，从最小的单体应用到最大的电子商务系统。
  quartz能够用于创建简单或复杂的调度以执行数十，数百，数万个作业；这些作业的任务可以被定义为标准的java组件，可以执行你编程让它们做的任何操作。quartz调度器包含许多企业级功能，如支持JTA事务与集群。
• 应用场景： 定时执行业务逻辑（如数据同步，发送短信），每隔一段时间执行业务逻辑（如每隔5秒发送1次心跳）；

2）相对于JDK的Timer之类的简单任务调度程序来说，Quartz拥有丰富的功能，如下：

• 允许批处理任务状态的持久化；
• 批处理任务的远程调度；
• 基于web的监控接口；
• 集群支持； （同一时刻只有一个任务执行；当一个任务宕机之后，其它服务会接管这个任务）
• 插件式的可扩展性；

3）Quartz组件清单 ；

1. Job： 抽象调度任务（作业）；
2. JobDetail：封装job的详细信息，如job名称，组名称，job的class，JobDataMap等；
3. Trigger：触发器，抽象job触发规则（如执行开始时间，结束时间，执行频率）；
4. Scheduler：调度器； 使用Trigger定义的规则执行job；
5. JobBuilder：Job生成器；用于创建Job实例；
6. TriggerBuilder：Trigger生成器；用于创建Trigger实例；
7. JobExecutionContext：Job运行时上下文；
8. JobDataMap： 封装参数键值对，用于Job与JobDetail的数据交互；

4）Quartz基本组件关系如下：

5）使用 quartz任务调度框架，需要引入对应maven依赖，如下：

<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>2.3.2</version>
</dependency>

---

【1.1】Job调度任务

1）quartz中调度任务job定义

public interface Job {void execute(JobExecutionContext var1) throws JobExecutionException;
}

2）调度任务实现job接口；

public class TomScheduleJob implements Job {@Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {// do sth.System.out.println("MyScheduleJob#当前时间=" + BusiDatetimeUtils.getNowText());}
}

---

【1.2】任务调度触发器Trigger

1）触发器：定义job触发规则；如每隔10分钟执行1次，每天早上7点，9点准时执行1次；

2）触发器Trigger定义如下：

public interface Trigger extends Serializable, Cloneable, Comparable<Trigger> {long serialVersionUID = -3904243490805975570L;int MISFIRE_INSTRUCTION_SMART_POLICY = 0;int MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY = -1;int DEFAULT_PRIORITY = 5;TriggerKey getKey();JobKey getJobKey();String getDescription();String getCalendarName();JobDataMap getJobDataMap();int getPriority();boolean mayFireAgain();Date getStartTime();Date getEndTime();Date getNextFireTime();Date getPreviousFireTime();Date getFireTimeAfter(Date var1);Date getFinalFireTime();int getMisfireInstruction();TriggerBuilder<? extends Trigger> getTriggerBuilder();ScheduleBuilder<? extends Trigger> getScheduleBuilder();boolean equals(Object var1);int compareTo(Trigger var1);
// ... 
}

2）触发器的两种主要实现：

• SimpleTrigger：指定基于时间间隔的调度规则（触发规则）；
• CronTrigger：指定基于cron表达式的调度规则；（包括但不限于时间间隔，还可以指定具体时间执行，触发规则更加灵活 ）

---

【1.3】*Quartz框架执行调度任务代码实践

【1.3.1】硬编码执行Quartz调度任务

【TomQuartzJob】

public class TomQuartzJob implements Job {@Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {// do sth.System.out.println("TomQuartzJob#当前时间=" + BusiDatetimeUtils.getNowText());}
}

【TomQuartzJobMain】

public class TomQuartzJobMain {public static void main(String[] args) throws Exception {executeScheduleJob();}private static void executeScheduleJob() throws ParseException, SchedulerException {// 新建触发器SimpleTriggerImpl simpleTrigger =new SimpleTriggerImpl("tomSimpleTrigger", "tomSimpleTriggerGroup", new Date(), null, SimpleTriggerImpl.REPEAT_INDEFINITELY, 5000); // 每隔5秒执行1次CronTriggerImpl cronTrigger = new CronTriggerImpl("tomSimpleTrigger", "tomSimpleTriggerGroup", "*/5 * * * * ?");// 新建调度器Scheduler scheduler = new StdSchedulerFactory().getScheduler();scheduler.start();// 新建调度任务详情JobDetailImpl tomJobDetail = new JobDetailImpl("tomJobDetail", TomQuartzJob.class);// 新增调度任务（这里是新增，并没有执行，执行由触发器来负责）
//        scheduler.scheduleJob(tomJobDetail, simpleTrigger);scheduler.scheduleJob(tomJobDetail, cronTrigger);}
}

---

【1.3.2】基于生产者模式执行quartz调度任务（推荐）

1）基于生成器模式执行调度任务： 参考 quick-start

【TomTimeRemindJob】

public class TomTimeRemindJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("=========================================");context.getMergedJobDataMap().forEach((k,v)-> System.out.println(k + "=" + v));context.getJobDetail().getJobDataMap().forEach((k,v)-> System.out.println(k + "=" + v));System.out.println("TomTimeRemindJob now=" + BusiDatetimeUtils.getNowText());}
}

【TomTimeRemindJobMain】

public class TomTimeRemindJobMain {public static void main(String[] args) throws SchedulerException {// 创建调度器实例Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();// 开启调度器scheduler.start();// 执行调度作业executeScheduleJob(scheduler);// 关闭调度器
//        scheduler.shutdown();}private static void executeScheduleJob(Scheduler scheduler) throws SchedulerException {// 创建JobDetail，并与TomTimeRemindJob 绑定JobDetail jobDetail = JobBuilder.newJob(TomTimeRemindJob.class).withIdentity("tomJob01", "tomJob01Group").build();// 立即触发作业执行，每5秒重复一次Trigger simpleTrigger = TriggerBuilder.newTrigger().withIdentity("tomTrigger01", "tomTrigger01Group").startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever()).build();// 告诉quartz使用我们的触发器调度作业scheduler.scheduleJob(jobDetail, simpleTrigger);}
}

---

【2】spring集成Quartz

1）通过上述代码【TomTimeRemindJobMain】， 本文发现使用Quartz框架执行调度任务需要依赖以下4个组件（Job， JobDetail， Trigger， Scheduler）：

• Job：调度任务；

• JobDetail： 用于封装job详细信息；

• Trigger：触发器，定义触发规则；

• Scheduler：调度器，根据触发器的规则执行调度任务（作业）；

2）可以想到，spring集成Quartz的底层原理 ：把Job，JobDetail， SimpleTrigger， Scheduler对象创建与依赖关系装配由spring来完成，无需客户端实现； spring采用工厂方法FactoryBean来管理quartz调度任务所需组件；

3）spring集成Quartz需要新增maven依赖，如下：

<dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>6.1.10</version></dependency>

---

【2.1】spring管理quartz组件对象

1）本章节部分内容总结自： spring-quartz-schedule

---

【2.1.1】spring管理quartz的Job

1）spring提供了QuartzJobBean用于抽象调度任务，自定义调度任务需要继承QuartzJobBean并重写executeInternal()方法；

2）QuartzJobBean定义：（注意：quartz的JobDetail封装了Job的class对象，由JobDetail实例化job；所以spring无需注册job）

public abstract class QuartzJobBean implements Job {public QuartzJobBean() {}public final void execute(JobExecutionContext context) throws JobExecutionException {try {BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);MutablePropertyValues pvs = new MutablePropertyValues();pvs.addPropertyValues(context.getScheduler().getContext());pvs.addPropertyValues(context.getMergedJobDataMap());bw.setPropertyValues(pvs, true);} catch (SchedulerException var4) {throw new JobExecutionException(var4);}this.executeInternal(context);}protected abstract void executeInternal(JobExecutionContext context) throws JobExecutionException;
}

【自定义job，继承QuartzJobBean】TomSpringQuartzJobBean

public class TomSpringQuartzJobBean extends QuartzJobBean {@Overrideprotected void executeInternal(JobExecutionContext context) throws JobExecutionException {System.out.println("TomSpringQuartzJobBean #当前时间=" + BusiDatetimeUtils.getNowText());}
}

---

【2.1.2】spring管理quartz的JobDetail

1）在quartz中， job抽象了调度任务，而job的上下文信息由JobDetail封装，Job与JobDetail的数据交互通过JobDataMap实现；

2）spring注册JobDetail有两种方式：

• 方式1： JobDetailFactoryBean 注册JobDetail； （推荐） ；
• 方式2： 通过 MethodInvokingJobDetailFactoryBean 注册JobDetail ； （本文不介绍）

【springquartz.xml】 JobDetailFactoryBean 注册JobDetail

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 通过 JobDetailFactoryBean 注册JobDetail --><bean class="org.springframework.scheduling.quartz.JobDetailFactoryBean"><property name="name" value="tomJob" /><property name="group" value="tomJobGroup" /><property name="jobClass" value="com.tom.springnote.chapter31schedule.springquartz.SpringScheduleJob" /><property name="durability" value="true" /><property name="description" value="tomJobDetail" /><property name="jobDataMap"><map><entry key="message" value="hello world" /><entry key="city" value="chengdu" /></map></property></bean> 
</beans>

---

【2.1.3】spring管理quartz的Trigger

1）trigger触发器：定义了执行调度任务的规则， 如每5秒执行1次；

2）spring也是通过FactoryBean注册Trigger；

• SimpleTriggerFactoryBean （简单触发器）
• CronTriggerFactoryBean； （带有cron表达式的触发器）

【springquartz.xml】 SimpleTriggerFactoryBean 注册Trigger

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 通过 JobDetailFactoryBean 注册JobDetail --><bean id="tomJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean"><property name="name" value="tomJob" /><property name="group" value="tomJobGroup" /><property name="jobClass" value="com.tom.springnote.chapter31schedule.springquartz.SpringScheduleJob" /><property name="durability" value="true" /><property name="description" value="tomJobDetail" /><property name="jobDataMap"><map><entry key="message" value="hello world" /><entry key="city" value="chengdu" /></map></property></bean><!-- 通过 SimpleTriggerFactoryBean 注册触发器 --><bean class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"><property name="name" value="tomTrigger" /><property name="group" value="tomTriggerGroup" /><property name="jobDetail" ref="tomJobDetail" /><property name="repeatInterval" value="5000" /> <!-- 单位毫秒，每5秒执行1次--><property name="repeatCount" value="-1" />  <!-- -1表示永远重复 --></bean><!-- 通过 CronTriggerFactoryBean 注册触发器 --><bean class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"><property name="name" value="tomCronTrigger" /><property name="group" value="tomCronTriggerGroup" /><property name="jobDetail" ref="tomJobDetail" /><property name="cronExpression" ref="*/3 * * * * ?" /> <!-- 每3秒执行1次--></bean></beans>

3）补充： 多个trigger定义的规则可以同时作用于同一个JobDetail （或Job）； 本文认为多个Trigger规则的组合太过复杂（1个trigger对应1个Job足够满足日常业务需求），本文不再深入研究多个trigger组合的情况；有兴趣的同学自行研究；

---

【2.1.4】spirng管理quartz的Scheduler

1）scheduler调度器：使用触发器Trigger定义的规则执行调度任务（job）；

2）spring通过SchedulerFactoryBean注册scheduler；

【springquartz.xml】 SchedulerFactoryBean注册scheduler

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 通过 JobDetailFactoryBean 注册JobDetail --><bean id="tomJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean"><property name="name" value="tomJob" /><property name="group" value="tomJobGroup" /><property name="jobClass" value="com.tom.springnote.chapter31schedule.springquartz.TomSpringQuartzJobBean" /><property name="durability" value="true" /><property name="description" value="tomJobDetail" /><property name="jobDataMap"><map><entry key="message" value="hello world" /><entry key="city" value="chengdu" /></map></property></bean><!-- 通过 SimpleTriggerFactoryBean 注册触发器 --><bean id="tomSimpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"><property name="name" value="tomTrigger" /><property name="group" value="tomTriggerGroup" /><property name="jobDetail" ref="tomJobDetail" /><property name="repeatInterval" value="5000" /> <!-- 单位毫秒，每5秒执行1次--><property name="repeatCount" value="-1" />  <!-- -1表示永远重复 --></bean><!-- 通过 CronTriggerFactoryBean 注册触发器 --><bean id="tomCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"><property name="name" value="tomCronTrigger" /><property name="group" value="tomCronTriggerGroup" /><property name="jobDetail" ref="tomJobDetail" /><property name="cronExpression" ref="*/3 * * * * ?" /> <!-- 每3秒执行1次--></bean><!-- 通过SchedulerFactoryBean注册scheduler --><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"> <!-- 可以装配多个触发器，当然，日常开发1个足够 --><list><ref bean="tomSimpleTrigger" /><ref bean="tomCronTrigger" /></list></property></bean>
</beans>

---

【2.2】spring启动quartz调度器执行调度任务

1）spring容器ApplicationContext启动时，SchedulerFactoryBean所管理的调度器Scheduler跟着自动启动，且Scheduler随着ApplicationContext的关闭而自动关闭；

• 当调度任务的所有对象实例注册到ioc容器后，ApplicationContext启动时，Scheduler也启动，Scheduler立即开始执行调度任务；

【TomSpringQuartzJobBeanMain】

public class TomSpringQuartzJobBeanMain {public static void main(String[] args) {ClassPathXmlApplicationContext springContext = new ClassPathXmlApplicationContext("chapter31schedule/springquartz.xml");((AbstractApplicationContext) springContext).registerShutdownHook();}
}

【执行效果】 2个调度任务在执行（因为有2个触发器，tomSimpleTrigger-每5秒执行1次；tomCronTrigger-每3秒执行1次 ）；

TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:23.623
TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:24.002
TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:27.000
TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:28.505
TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:30.000
TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:33.010
TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:33.501
TomSpringQuartzJobBean #当前时间=2024-10-13 21:42:36.003

---

【3】JDK Timer定时器

【3.1】JDK Timer基础知识回顾

1）Timer定时器组件：

• TimerTask：抽象调度任务；
• Timer：抽象调度器；用于定义任务触发规则并执行调度任务； 类似于肩负了quartz的Scheduler与Trigger职责；
  • 只能配置简单规则，不能配置cron表达式；

2）Timer使用TimerTask抽象调度任务；自定义调度任务需要继承TimerTask；

• 由代码可知： TimerTask本质上是Runnable，即可以提交给线程的任务；

public abstract class TimerTask implements Runnable {// ...    
}

3）部分代码总结自： java-timer-and-timertask

---

【3.2】定时器任务单次执行

【3.2.1】给定延迟时间之后执行单次任务

1）在当前时间等待给定延迟时间之后，执行调度任务；

【OnceTimerTaskExecuteAfterDelayMain】给定延迟时间之后仅执行1次调度任务

public class OnceTimerTaskExecuteAfterDelayMain {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());}};// 通过jdk 定时器执行调度任务Timer timer = new Timer();System.out.println("当前时间=" + BusiDatetimeUtils.getNowText());// 在给定延迟时间(5s)之后执行调度任务，仅执行1次timer.schedule(timerTask, 5000);System.out.println("after timer.schedule()新增调度任务之后");try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}// 取消调度器执行(主线程结束)timer.cancel();System.out.println("主线程结束， 当前时间=" + BusiDatetimeUtils.getNowText());}
} public void schedule(TimerTask task, long delay) { if (delay < 0)throw new IllegalArgumentException("Negative delay.");sched(task, System.currentTimeMillis()+delay, 0); // period=0 表示当前任务仅执行1次 }
private void sched(TimerTask task, long time, long period) { // ... 
}

【解说】period参数：表示2个相邻任务执行的时间间隔（单位毫秒）；

• 若为0，表示仅执行1次 ；
• 若为整数，表示时间间隔；

【执行效果】

当前时间=2024-10-16 20:51:52.281
after timer.schedule()新增调度任务之后
线程id=15 当前时间=2024-10-16 20:51:57.298 
主线程结束， 当前时间=2024-10-16 20:51:57.298

---

【3.2.2】在给定时间点执行单次任务

1）在给定时间点执行调度任务；

【OnceTimerTaskExecuteAtGivenTime】 在给定时间点执行调度任务，仅执行1次

public class OnceTimerTaskExecuteAtGivenTime {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());}};// 通过jdk 定时器执行调度任务Timer timer = new Timer();System.out.println("当前时间=" + BusiDatetimeUtils.getNowText());// 在给定时间点（当前时间加5秒的时间）执行调度任务，仅执行1次timer.schedule(timerTask, BusiDatetimeUtils.timeAfterSecond(5));System.out.println("after timer.schedule()新增调度任务之后");try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {throw new RuntimeException(e);}// 取消调度器执行(主线程结束)timer.cancel();System.out.println("主线程结束， 当前时间=" + BusiDatetimeUtils.getNowText());}
}  
public void schedule(TimerTask task, Date time) {sched(task, time.getTime(), 0); // period=0 表示仅执行1次 }

【执行效果】

当前时间=2024-10-16 20:55:09.981
after timer.schedule()新增调度任务之后
线程id=15 当前时间=2024-10-16 20:55:14.984 
主线程结束， 当前时间=2024-10-16 20:55:14.986

---

【3.3】 定时器任务重复执行

【3.3.1】在给定延迟时间后重复执行

1）使用Timer定时器在给定延迟时间后重复执行调度任务

【RepeatableTimerTaskExecuteAfterDelayMain】

public class RepeatableTimerTaskExecuteAfterDelayMain {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());}};// 通过jdk 定时器执行调度任务Timer timer = new Timer();System.out.println("当前时间=" + BusiDatetimeUtils.getNowText());// 在给定延迟时间(5s)之后执行调度任务，间隔2秒重复执行timer.schedule(timerTask, 5000, 2000);System.out.println("after timer.schedule()新增调度任务之后");try {TimeUnit.SECONDS.sleep(10); // 睡眠10s后关闭定时器，以便调度任务可以重复执行} catch (InterruptedException e) {throw new RuntimeException(e);}// 取消调度器执行(主线程结束)timer.cancel();System.out.println("主线程结束， 当前时间=" + BusiDatetimeUtils.getNowText());}
}

【执行效果】

当前时间=2024-10-16 21:01:49.933
after timer.schedule()新增调度任务之后
线程id=15 当前时间=2024-10-16 21:01:54.950 
线程id=15 当前时间=2024-10-16 21:01:56.951 
线程id=15 当前时间=2024-10-16 21:01:58.957 
主线程结束， 当前时间=2024-10-16 21:01:59.946

---

【3.2.2】在给定时间点重复执行

【RepeatableTimerTaskExecuteAtGivenTime】

public class RepeatableTimerTaskExecuteAtGivenTime {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());}};// 通过jdk 定时器执行调度任务Timer timer = new Timer();System.out.println("当前时间=" + BusiDatetimeUtils.getNowText());// 在给定时间点（当前时间加5秒的时间）执行调度任务，间隔2s重复执行timer.schedule(timerTask, BusiDatetimeUtils.timeAfterSecond(5), 2000);System.out.println("after timer.schedule()新增调度任务之后");try {TimeUnit.SECONDS.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}// 取消调度器执行(主线程结束)timer.cancel();System.out.println("主线程结束， 当前时间=" + BusiDatetimeUtils.getNowText());}
}

【执行效果】

当前时间=2024-10-16 21:07:12.258
after timer.schedule()新增调度任务之后
线程id=15 当前时间=2024-10-16 21:07:17.260 
线程id=15 当前时间=2024-10-16 21:07:19.261 
线程id=15 当前时间=2024-10-16 21:07:21.275 
主线程结束， 当前时间=2024-10-16 21:07:22.261

---

【3.3.3】定时器任务重复执行注意点

1） 若一个任务执行耗时大于调度间隔或周期period，则会延迟整个执行链；无论是在延迟时间后还是给定时间点执行 ；

【RepeatableTimerTaskDelayWholeChainAtGivenTime】

public class RepeatableTimerTaskDelayWholeChainAtGivenTime {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());try {TimeUnit.SECONDS.sleep(5); // 模拟单个任务执行耗时5秒} catch (InterruptedException e) {throw new RuntimeException(e);}}};// 通过jdk 定时器执行调度任务Timer timer = new Timer();System.out.println("当前时间=" + BusiDatetimeUtils.getNowText());// 在给定时间点（当前时间加5秒的时间）执行调度任务，间隔2s重复执行timer.schedule(timerTask, BusiDatetimeUtils.timeAfterSecond(1), 2000);System.out.println("after timer.schedule()新增调度任务之后");try {TimeUnit.SECONDS.sleep(30); // 延迟30秒，等待执行重复调度任务} catch (InterruptedException e) {throw new RuntimeException(e);}// 取消调度器执行(主线程结束)timer.cancel(); System.out.println("主线程结束， 当前时间=" + BusiDatetimeUtils.getNowText());}
}

【执行效果】 程序中设置定时器每隔2s执行调度任务，而运行效果是每隔5s执行调度任务； 原因是任务执行睡眠5s模拟了业务逻辑耗时；当上一个任务执行完成后，下一个任务才会执行（即单个任务执行耗时过长会延迟整体任务调度）；

当前时间=2024-10-16 21:36:40.218
after timer.schedule()新增调度任务之后
线程id=15 当前时间=2024-10-16 21:36:41.222 
线程id=15 当前时间=2024-10-16 21:36:46.236 
线程id=15 当前时间=2024-10-16 21:36:51.247 
线程id=15 当前时间=2024-10-16 21:36:56.258 
线程id=15 当前时间=2024-10-16 21:37:01.272 
线程id=15 当前时间=2024-10-16 21:37:06.285 
主线程结束， 当前时间=2024-10-16 21:37:10.224

---

【3.4】取消调度器与调度任务

1）取消调度器执行的方法：

• 调用 Timer.cancel()方法取消调度器； 若调度器有任务运行，则不结束； 若调度器没有任务运行，则可以结束；

2）取消调度任务的方法：

• 方法1： 在TimerTask内部run方法执行cancel()方法，取消当前调度任务执行；
• 方法2： 在TimerTask内部run()方法中强行终止当前线程执行；

---

【3.4.1】 在run方法里取消调度任务

【CancelRepeatableTimerTaskInsideRun】

public class CancelRepeatableTimerTaskInsideRun {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());cancel(); // 取消当前调度任务 （本来是重复调度，结果仅执行1次）}};// 通过jdk 定时器执行调度任务Timer timer = new Timer();System.out.println("当前时间=" + BusiDatetimeUtils.getNowText());// 在给定时间点（当前时间加5秒的时间）执行调度任务，间隔2s重复执行timer.schedule(timerTask, BusiDatetimeUtils.timeAfterSecond(5), 2000);System.out.println("after timer.schedule()新增调度任务之后");try {TimeUnit.SECONDS.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}// 取消调度器执行(主线程结束)timer.cancel();System.out.println("主线程结束， 当前时间=" + BusiDatetimeUtils.getNowText());}
}

【执行效果】

当前时间=2024-10-16 21:48:59.496
after timer.schedule()新增调度任务之后
线程id=15 当前时间=2024-10-16 21:49:04.501 
主线程结束， 当前时间=2024-10-16 21:49:09.510

---

【3.5】定时器Timer与调度线程池对比

【3.5.1】调度线程池执行调度任务回顾

【RepeatableTaskExecuteBySchedulerThreadPoolMain】使用调度线程池执行重复任务

public class RepeatableTaskExecuteBySchedulerThreadPoolMain {public static void main(String[] args) {ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1); // 不要这样用，本文仅演示Runnable task = new Runnable() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());}};// 重复任务，间隔2s执行1次scheduledExecutorService.scheduleAtFixedRate(task, 0, 2000, TimeUnit.MILLISECONDS);}
}

【执行效果】

线程id=15 当前时间=2024-10-16 22:03:46.625 
线程id=15 当前时间=2024-10-16 22:03:48.580 
线程id=15 当前时间=2024-10-16 22:03:50.579 
线程id=15 当前时间=2024-10-16 22:03:52.578

【注意】

实际开发过程中，不要使用 Executors.newScheduledThreadPool(1)； 如下面代码所示，该方法初始化的最大线程个数无限大，这是有问题的； 线程个数无限大，会导致cpu时间片被耗尽，切换不到（或无法及时切换到）正常业务逻辑的线程上，导致系统假死 ；

public ScheduledThreadPoolExecutor(int corePoolSize) {super(corePoolSize, Integer.MAX_VALUE,DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,new DelayedWorkQueue());}

---

【3.5.2】定时器与调度线程池ScheduledExecutorService对比

1）定时器Timer与调度线程池ScheduledExecutorService对比 ：

• 定时器Timer对系统时钟变化非常敏感；而调度线程池不会；
• 定时器Timer只有1个执行线程； 而调度线程池可以配置多个；
• TimerTask内部run方法执行抛出运行时异常，则当前线程被杀死，导致后续任务不执行；而调度线程池中的线程抛出异常，仅运行中的任务被取消，但线程还存在，即其他任务还是可以被执行；

---

2）模拟TimerTask的run方法内部抛出异常

public class RepeatableTimerTaskExecuteThrowException {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.printf("线程id=%s 当前时间=%s \n", Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());throw new RuntimeException("mock runtime exception");}};// 通过jdk 定时器执行调度任务Timer timer = new Timer();System.out.println("当前时间=" + BusiDatetimeUtils.getNowText());// 在给定时间点（当前时间加5秒的时间）执行调度任务，间隔2s重复执行timer.schedule(timerTask, BusiDatetimeUtils.timeAfterSecond(5), 2000);System.out.println("after timer.schedule()新增调度任务之后");try {TimeUnit.SECONDS.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}// 取消调度器执行(主线程结束)timer.cancel();System.out.println("主线程结束， 当前时间=" + BusiDatetimeUtils.getNowText());}
}

【执行效果】 显然，若TimerTask内部run方法抛出运行时异常，则整个定时器执行完成（定时器线程被杀死）

当前时间=2024-10-16 22:12:37.801
after timer.schedule()新增调度任务之后
线程id=15 当前时间=2024-10-16 22:12:42.803 
Exception in thread "Timer-0" java.lang.RuntimeException: mock runtime exceptionat com.tom.springnote.chapter31schedule.origintimer.RepeatableTimerTaskExecuteThrowException$1.run(RepeatableTimerTaskExecuteThrowException.java:22)at java.base/java.util.TimerThread.mainLoop(Timer.java:566)at java.base/java.util.TimerThread.run(Timer.java:516)
主线程结束， 当前时间=2024-10-16 22:12:47.806

---

3）模拟调度线程池ScheduledExecutorService的run方法内部抛出异常

【RepeatableTaskExecuteBySchedulerThreadPoolThrowExceptionMain】

public class RepeatableTaskExecuteBySchedulerThreadPoolThrowExceptionMain {static class BusiTask implements Runnable {private String flag;public BusiTask(String flag) {this.flag = flag;}@Overridepublic void run() {System.out.printf("flag=%s, 线程id=%s 当前时间=%s \n", flag, Thread.currentThread().getId(), BusiDatetimeUtils.getNowText());if (Objects.equals("exception", flag)) {throw new RuntimeException("mock runtime exception");}}}public static void main(String[] args) {ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);// 重复任务，间隔2s执行1次scheduledExecutorService.scheduleAtFixedRate(new BusiTask("exception"), 0, 2000, TimeUnit.MILLISECONDS);try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {throw new RuntimeException(e);}// 第2次添加任务scheduledExecutorService.scheduleAtFixedRate(new BusiTask("zhangsan"), 0, 2000, TimeUnit.MILLISECONDS);}
}

【执行效果】 显然，即便抛出异常， 我们还是可以向调度线程池添加调度任务；

flag=exception, 线程id=15 当前时间=2024-10-16 22:25:34.802 
flag=zhangsan, 线程id=15 当前时间=2024-10-16 22:25:36.750 
flag=zhangsan, 线程id=15 当前时间=2024-10-16 22:25:38.756 
flag=zhangsan, 线程id=15 当前时间=2024-10-16 22:25:40.764 

---