概述
在Java环境下创建定时任务有多种方式：
- 使用while循环配合
Thread.sleep()，虽然稍嫌粗陋但也勉强可用 - 使用
Timer和TimerTask - 使用
ScheduledExecutorService - 定时任务框架，如Quartz
在SpringBoot下执行定时任务无非也就这几种方式（主要还是后两种）。只不过SpringBoot做了许多底层的工作，我们只需要做些简单的配置就行了。
通过注解实现定时任务
在SpringBoot中仅通过注解就可以实现常用的定时任务。步骤就两步：
- 在启动类中添加
@EnableScheduling注解
|
1 2 3 4 5 6 7 8 9 |
@EnableScheduling @SpringBootApplication public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } } |
- 在目标方法中添加
@Scheduled注解，同时在@Scheduled注解中添加触发定时任务的元数据。
|
1 2 3 4 |
@Scheduled(fixedRate = 1000) public void job() { System.out.println(Thread.currentThread().getId() + " ----- job1 ----- " + System.currentTimeMillis()); } |
注意： 目标方法需要没有任何参数，并且返回类型为void 。
这里的定时任务元数据是“fixRate=1000”，意思是固定间隔每1000毫秒即执行一次该任务。
再来看几个@Schedule注解的参数：
- fixedRate：设置定时任务执行的时间间隔，该值为当前任务启动时间与下次任务启动时间之差；
- fixedDelay：设置定时任务执行的时间间隔，该值为当前任务结束时间与下次任务启动时间之差；
- cron：通过cron表达式来设置定时任务启动时间，在Cron Generator网站可以直接生成cron表达式。
这样创建的定时任务存在一个问题：如存在多个定时任务，这些任务会同步执行，也就是说所有的定时任务都是在一个线程中执行。
再添几个定时任务来执行下看看：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
@Scheduled(fixedRate = 1000) public void job1() { System.out.println(Thread.currentThread().getId() + " ----- job1 ----- " + System.currentTimeMillis()); } @Scheduled(fixedRate = 1000) public void job2() { System.out.println(Thread.currentThread().getId() + " ----- job2 ----- " + System.currentTimeMillis()); } @Scheduled(fixedRate = 1000) public void job3() { System.out.println(Thread.currentThread().getId() + " ----- job3 ----- " + System.currentTimeMillis()); } |
代码中一共创建了三个定时任务，每个定时任务的执行间隔都是1000毫秒，在任务体中输出了执行任务的线程ID和执行时间。
看下执行结果：
|
1 2 3 4 5 6 7 8 9 |
20 ----- job3 ----- 1573120568263 20 ----- job1 ----- 1573120568263 20 ----- job2 ----- 1573120568263 20 ----- job3 ----- 1573120569264 20 ----- job1 ----- 1573120569264 20 ----- job2 ----- 1573120569264 20 ----- job3 ----- 1573120570263 20 ----- job1 ----- 1573120570263 20 ----- job2 ----- 1573120570263 |
可以看到这三个定时任务的执行有如下的特点：
- 所有的定时任务每次都是在同一个线程上执行;
- 虽然未必是job1第一个开始执行，但是每批任务的执行次序是固定的——这是由fixRate参数决定的
这样的定时任务已经能够覆盖绝大部分的使用场景了，但是它的缺点也很明显：前面的任务执行时间过长必然会影响之后的任务的执行。为了解决这个问题，我们需要异步执行定时任务。接下来的部分我们将主要着眼于如何实现异步执行定时任务。
通过@Async注解实现异步定时任务
最常用的方式是使用@Async注解来实现异步执行定时任务。启用@Async注解的步骤如下：
- 在启动类中添加
@EnableAsync注解：
|
1 2 3 4 5 6 7 8 9 10 |
@EnableAsync @EnableScheduling @SpringBootApplication public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } } |
- 在定时任务方法上添加
@Async注解
|
1 2 3 4 5 |
@Async @Scheduled(fixedRate = 1000) public void job1() { System.out.println(Thread.currentThread().getId() + " ----- job1 ----- " + System.currentTimeMillis()); } |
我们为前面的三个定时任务都加上@Async注解再运行看看：
|
1 2 3 4 5 6 7 8 9 |
25 ----- job1 ----- 1573121781415 24 ----- job3 ----- 1573121781415 26 ----- job2 ----- 1573121781415 30 ----- job3 ----- 1573121782298 31 ----- job1 ----- 1573121782299 32 ----- job2 ----- 1573121782299 25 ----- job2 ----- 1573121783304 35 ----- job3 ----- 1573121783306 36 ----- job1 ----- 1573121783306 |
通过输出信息可以看到每个定时任务都在不同的线程上执行，彼此的执行次序和执行时间也互不影响，说明配置为异步执行已经成功。
通过配置实现异步定时任务
现在我们有必要稍稍深入了解下springboot定时任务的执行机制了。
springboot的定时任务主要涉及到两个接口：TaskScheduler和TaskExecutor。在springboot的默认定时任务实现中，这两个接口的实现类是ThreadPoolTaskScheduler和ThreadPoolTaskExecutor。
ThreadPoolTaskScheduler负责实现任务的定时执行机制，而ThreadPoolTaskExecutor则负责实现任务的异步执行机制。二者中，ThreadPoolTaskScheduler执行栈更偏底层一些。
尽管在职责上有些区别，但是两者在底层上都是依赖java的线程池机制实现的：ThreadPoolTaskScheduler依赖的底层线程池是ScheduledExecutorService，springboot默认为其提供的coreSize是1，所以默认的定时任务都是在一个线程中执行；ThreadPoolTaskExecutor依赖的底层线程池是ThreadPoolExecutor，springboot默认为其提供的corePoolSize是8。
说到这里应该清楚了：我们可以不添加@Async注解，仅通过调整ThreadPoolTaskScheduler依赖的线程池的coreSize也能实现多线程异步执行；同样的，即使添加了@Async注解，将ThreadPoolTaskExecutor依赖的线程池的corePoolSize设置为1，那定时任务还是只能在一个线程上同步执行。看下springboot的相关配置项：
|
1 2 3 4 5 6 7 8 |
spring: task: scheduling: pool: size: 1 execution: pool: core-size: 2 |
其中spring.task.scheduling是ThreadPoolTaskScheduler的线程池配置项，spring.task.execution是ThreadPoolExecutor的线程池配置项。
再稍稍扩展下：@Async注解的value属性就是用来指明使用的TaskExecutor实例的。默认值是空字符串，表示使用的是springboot自启动的TaskExecutor实例。如有需要，也可以使用自定义的TaskExecutor实例，如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
/** * 配置线程池 * @return */ @Bean(name = "scheduledPoolTaskExecutor") public ThreadPoolTaskExecutor getAsyncThreadPoolTaskExecutor() { ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); taskExecutor.setCorePoolSize(20); taskExecutor.setMaxPoolSize(200); taskExecutor.setQueueCapacity(25); taskExecutor.setKeepAliveSeconds(200); taskExecutor.setThreadNamePrefix("my-task-executor-"); // 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者 taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); //调度器shutdown被调用时等待当前被调度的任务完成 taskExecutor.setWaitForTasksToCompleteOnShutdown(true); //等待时长 taskExecutor.setAwaitTerminationSeconds(60); taskExecutor.initialize(); return taskExecutor; } |
此外，还有一种做法是通过提供自定义的TaskScheduler Bean实例来实现异步执行。要提供提供自定义的TaskScheduler 实例，可以直接通过@Bean注解声明创建，也可以在SchedulingConfigurer接口中配置。这些在后面我们会提到。
调用SpringBoot接口实现定时任务
有时候会需要将定时任务的定时元数据写在数据库或其他配置中心以便统一维护。这种情况就不是通过注解能够搞定的了，此时我们需要使用springboot定时任务一些组件来自行编程实现。常用的组件包括TaskScheduler、 Triger接口和SchedulingConfigurer接口。
注意：因为我们用到了springboot的定时任务组件，所以仍然需要在启动类上添加@EnableScheduling注解。
Trigger接口
Trigger接口主要用来设置定时元数据。要通过程序实现定时任务就不能不用到这个接口。这个接口有两个实现类：
PeriodicTrigger用来配置固定时长的定时元数据CronTrigger用来配置cron表达式定时元数据
使用TaskScheduler接口
TaskScheduler接口前面我们提过，这个接口需要配合Trigger接口一起使用来实现定时任务，看个例子：
|
1 2 3 4 5 6 7 8 |
@Autowired private TaskScheduler taskScheduler; public void job() { int fixRate = 10; taskScheduler.schedule(() -> System.out.println(" job4 ----- " + System.currentTimeMillis()), new PeriodicTrigger(fixRate, TimeUnit.SECONDS)); } |
在上面的代码里，我们使用@Autowired注解获取了springbootr容器里默认的TaskScheduler实例，然后通过PeriodicTrigger设置了定时元数据，定时任务的任务体则是一个Runable接口的实现（在这里只是输出一行信息）。
因为默认的TaskScheduler实例的线程池coreSize是1，所以如有多个并发任务，这些任务的执行仍然是同步的。要调整为异步可以在配置文件中配置，也可以通过提供一个自定义的TaskScheduler实例来设置：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
@Bean("taskScheduler") public TaskScheduler taskExecutor() { ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler(); executor.setPoolSize(20); executor.setThreadNamePrefix("my-task-scheduler"); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); //调度器shutdown被调用时等待当前被调度的任务完成 executor.setWaitForTasksToCompleteOnShutdown(true); //等待时长 executor.setAwaitTerminationSeconds(60); return executor; } |
使用SchedulingConfigurer接口
SchedulingConfigurer接口的主要用处是注册基于Trigger接口自定义实现的定时任务。
在实现SchedulingConfigurer接口后，通常还需要使用@Configuration注解（当然启动类上的@EnableScheduling注解也不能少）来声明它实现类。
这个接口唯一的一个方法就是configureTasks，字面意思是配置定时任务。这个方法最重要的参数是一个ScheduledTaskRegistrar定时任务注册类实例，该类有8个方法，允许我们以不同的方式注册定时任务。
简单做了个实现：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
@Configuration public class MyTaskConfigurer implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { taskRegistrar .addCronTask( () -> System.out.println(Thread.currentThread().getId() + " --- job5 ----- " + System.currentTimeMillis()), "0/1 * * * * ?" ); taskRegistrar .addFixedDelayTask( () -> System.out.println(Thread.currentThread().getId() + " --- job6 ----- " + System.currentTimeMillis()), 1000 ); taskRegistrar .addFixedRateTask( () -> System.out.println(Thread.currentThread().getId() + " --- job7 ----- " + System.currentTimeMillis()), 1000 ); } } |
这里我们只使用了三种注册任务的方法，分别尝试注册了fixDelay、fixRate以及cron触发的定时任务。
springboot会自动启动注册的定时任务。看下执行结果：
|
1 2 3 4 5 6 7 8 9 |
22 --- job7 ----- 1573613616349 22 --- job6 ----- 1573613616350 22 --- job5 ----- 1573613617001 22 --- job7 ----- 1573613617352 22 --- job6 ----- 1573613617353 22 --- job5 ----- 1573613618065 22 --- job7 ----- 1573613618350 22 --- job6 ----- 1573613618355 22 --- job5 ----- 1573613619002 |
在执行结果中可以看到这里的任务也是在单一线程同步执行的。要设置为异步执行也简单，因为SchedulingConfigurer接口的另一个作用就是为定时任务提供自定义的TaskScheduler实例。来看下：
|
1 2 3 4 5 6 7 8 |
@Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler(); scheduler.setThreadNamePrefix("my-task-scheduler"); scheduler.setPoolSize(10); scheduler.initialize(); taskRegistrar.setTaskScheduler(scheduler); } |
在这里，我将之前注册的定时任务去掉了，目的是想验证下这里的配置是否对注解实现的定时任务有效。经检验是可行的。当然对在configureTasks方法中配置的定时任务肯定也是有效的。我就不一一贴结果了。
另外，需要注意：如SchedulingConfigurer接口实例已经注入，将无法再获取到springboot默认提供的TaskScheduler接口实例。
通过Quartz实现定时任务
Quartz是一个非常强大的定时任务管理框架。短短的一篇文章未必能介绍清楚Quartz的全部用法。所以这里只是简单地演示下如何在springboot中是如何使用Quartz的。更多的用法建议优先参考Quartz官方文档。
在spring-boot-web 2.0及之后的版本，已经自动集成了quartz，如果不使用spring-boot-web或使用较早的版本的话我们还需要加一些依赖：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<!-- quartz --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> </dependency> <!-- spring集成quartz --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> </dependency> <!-- SchedulerFactoryBean依赖了tx包中的PlatformTransactionManager类,因为quartz的分布式功能是基于数据库完成的 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> </dependency> |
添加完成这些依赖后，springboot服务在启动时也会自启动内部的quartz。事实上springboot已经为我们准备好了几乎全部的quartz的配置。我们要做的只是把自定义的任务填进去。
- 首先我们需要创建一个Job实例，来实现Job的具体行为。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
@Component public class MyQuartzJob extends QuartzJobBean { @Override protected void executeInternal(JobExecutionContext context) { JobDataMap map = context.getMergedJobDataMap(); // 从作业上下文中取出Key String key = map.getString("key"); System.out.println(Thread.currentThread().getId() + " -- job8 ---------------------->>>>" + key); } } |
QuartzJobBean是Spring提供的Quartz Job抽象类。在实现这个类的时候我们可以获取注入到spring中的其他Bean。
- 配置Job
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
@Configuration public class QuartzConfig implements InitializingBean { @Autowired private SchedulerFactoryBean schedulerFactoryBean; @Override public void afterPropertiesSet() throws Exception { config(); } private void config() throws SchedulerException { Scheduler scheduler = schedulerFactoryBean.getScheduler(); JobDetail jobDetail = buildJobDetail(); Trigger trigger = buildJobTrigger(jobDetail); scheduler.scheduleJob(jobDetail, trigger); } private JobDetail buildJobDetail() { // 用来存储交互信息 JobDataMap dataMap = new JobDataMap(); dataMap.put("key", "zhyea.com"); return JobBuilder.newJob(MyQuartzJob.class) .withIdentity(UUID.randomUUID().toString(), "chobit-job") .usingJobData(dataMap) .build(); } private Trigger buildJobTrigger(JobDetail jobDetail) { return TriggerBuilder.newTrigger() .forJob(jobDetail) .withIdentity(jobDetail.getKey().getName(), "chobit-trigger") .withSchedule(CronScheduleBuilder.cronSchedule("0/1 * * * * ?")) .build(); } } |
在创建QuartzConfig类的时候实现了InitializingBean接口，目的是在QuartzConfig实例及依赖类都完成注入后可以立即执行配置组装操作。
这里面有几个关键接口需要说明下：
SchedulerFactoryBean，QuartzScheduler工厂类，springboot自动化配置实现；Scheduer，负责Quartz Job调度，可从工厂类实例获取；JobDetail，执行Quartz Job封装；Trigger，完成Quartz Job启动。
还可以在配置文件中添加Quartz的配置：
|
1 2 3 |
spring: quartz: startupDelay: 180000 #这里是毫秒值 |
这里配置了让Quartz默认延迟启动3分钟。
看下执行结果：
|
1 2 3 4 5 6 |
30 -- job8 ---------------------->>>>zhyea.com 31 -- job8 ---------------------->>>>zhyea.com 32 -- job8 ---------------------->>>>zhyea.com 33 -- job8 ---------------------->>>>zhyea.com 34 -- job8 ---------------------->>>>zhyea.com ... |
好了，就这些内容了。前面用到的程序都上传到了GITHUB，有需要可以参考下。
发表评论