写点什么

SpringBoot 官方支持任务调度框架,轻量级用起来也挺香!

作者:沉默王二
  • 2022 年 6 月 08 日
  • 本文字数:9471 字

    阅读完需:约 31 分钟

SpringBoot官方支持任务调度框架,轻量级用起来也挺香!

大家好,我是二哥呀。定时任务的应用场景其实蛮常见的,比如说:


  • 数据备份

  • 订单未支付则自动取消

  • 定时爬取数据

  • 定时推送信息

  • 定时发布文章

  • 等等(想不出来了,只能等等来凑,😆,反正只要等的都需要定时,怎么样,这波圆场可以吧)


编程喵🐱实战项目里需要做一个定时发布文章的功能,一开始我想用 Spring Task,于是研究了一番,发现 Spring Task 用起来确实简单,但对于复杂业务却也无能为力。


于是我就把注意力放到了 Quartz 上面,这是一款老而弥坚的开源任务调度框架。



记得我在 14 年开发大宗期货交易平台的时候就用到了它,每天凌晨定时需要统计一波交易数据,生成日报报表,当时配合 Cron 表达式用的。


可惜后来平台稳定了,新的政策出来了,直接把大宗期货交易灭了。于是我发财的机会也随着破灭了。想想都觉得可惜,哈哈哈。



时光荏苒,Quartz 发展到现在,已经可以和 Spring Boot 项目无缝衔接了,今天我们就来实战一把。

Timer

JDK 1.3 就开始支持的一种定时任务的实现方式。内部通过 TaskQueue 的类来存放定时任务,用起来比较简单,但缺陷比较多,比如说一个 Timer 就会起一个线程,任务多了性能就非常差,再比如说如果执行任务期间某个 TimerTask 耗时比较久,就会影响其他任务的调度。


@Slf4jpublic class TimerDemo {    public static void main(String[] args) {        TimerTask task = new TimerTask() {            @Override            public void run() {                log.debug("当前时间{}线程名称{}", DateTime.now(),                        Thread.currentThread().getName());            }        };        log.debug("当前时间{}线程名称{}", DateTime.now(),                Thread.currentThread().getName());        Timer timer = new Timer("TimerDemo");        timer.schedule(task,1000L);    }}
复制代码


代码跑起来后的日志如下所示:


13:11:45.268 [main] DEBUG top.springtask.TimerDemo - 当前时间2022-04-27 13:11:45线程名称main13:11:46.280 [TimerDemo] DEBUG top.springtask.TimerDemo - 当前时间2022-04-27 13:11:46线程名称TimerDemo
复制代码

ScheduledThreadPoolExecutor

JDK 1.5 开始提供的的定时任务,它继承了 ThreadPoolExecutor,实现了 ScheduledExecutorService 接口,所以支持并发场景下的任务执行。同时,优化了 Timer 的缺陷。不过,由于使用了队列来实现定时器,就有出入队列、调整堆等操作,所以定时不是非常非常准确(吹毛求疵)。


@Slf4jpublic class ScheduledThreadPoolExecutorDemo {    public static void main(String[] args) throws InterruptedException {        TimerTask task = new TimerTask() {            @Override            public void run() {                log.debug("当前时间{}线程名称{}", DateTime.now(),                        Thread.currentThread().getName());            }        };
log.debug("当前时间{}线程名称{}", DateTime.now(), Thread.currentThread().getName()); ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3); executorService.scheduleAtFixedRate(task, 1000L,1000L, TimeUnit.MILLISECONDS); Thread.sleep(1000+1000*4); executorService.shutdown(); }}
复制代码


输出结果如下所示:


14:43:41.740 [main] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 当前时间2022-04-27 14:43:41线程名称main14:43:42.752 [pool-1-thread-1] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 当前时间2022-04-27 14:43:42线程名称pool-1-thread-114:43:43.748 [pool-1-thread-1] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 当前时间2022-04-27 14:43:43线程名称pool-1-thread-114:43:44.749 [pool-1-thread-2] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 当前时间2022-04-27 14:43:44线程名称pool-1-thread-214:43:45.749 [pool-1-thread-2] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 当前时间2022-04-27 14:43:45线程名称pool-1-thread-214:43:46.749 [pool-1-thread-2] DEBUG top.springtask.ScheduledThreadPoolExecutorDemo - 当前时间2022-04-27 14:43:46线程名称pool-1-thread-2
复制代码

Spring Task

Spring Task 是 Spring 提供的轻量级定时任务工具,也就意味着不需要再添加第三方依赖了,相比其他第三方类库更加方便易用。


好像关于 Spring Task,没有其他废话可说了,我们来直接上手。


第一步,新建配置类 SpringTaskConfig,并添加 @EnableScheduling 注解开启 Spring Task。


@Configuration@EnableSchedulingpublic class SpringTaskConfig {}
复制代码


当然了,也可以不新建这个配置类,直接在主类上添加 @EnableScheduling 注解。


@SpringBootApplication@EnableSchedulingpublic class CodingmoreSpringtaskApplication {
public static void main(String[] args) { SpringApplication.run(CodingmoreSpringtaskApplication.class, args); }
}
复制代码


第二步,新建定时任务类 CronTask,使用 @Scheduled 注解注册 Cron 表达式执行定时任务。


@Slf4j@Componentpublic class CronTask {    @Scheduled(cron = "0/1 * * ? * ?")    public void cron() {        log.info("定时执行,时间{}", DateUtil.now());    }}
复制代码


启动服务器端,发现每隔一秒钟会打印一次日志,证明 Spring Task 的 cron 表达式形式已经起效了。



默认情况下,@Scheduled 创建的线程池大小为 1,如果想增加线程池大小的话,可以让 SpringTaskConfig 类实现 SchedulingConfigurer 接口,通过 setPoolSize 增加线程池大小。


@Configuration@EnableSchedulingpublic class SpringTaskConfig implements SchedulingConfigurer {    @Override    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.setPoolSize(10); threadPoolTaskScheduler.setThreadNamePrefix("my-scheduled-task-pool-"); threadPoolTaskScheduler.initialize();
taskRegistrar.setTaskScheduler(threadPoolTaskScheduler); }}
复制代码


服务热部署完成后,会在控制台看到这样的信息:



可以确认自定义线程池大小已经生效了,有的任务用的是线程 led-task-pool-3,有的是线程 led-task-pool-7,跑时间长了,可以发现 led-task-pool-1 到 led-task-pool-10 的都有。



Spring Task 除了支持 Cron 表达式,还有 fixedRate(固定速率执行)、fixedDelay(固定延迟执行)、initialDelay(初始延迟)三种用法。


/** * fixedRate:固定速率执行。每5秒执行一次。 */@Scheduled(fixedRate = 5000)public void reportCurrentTimeWithFixedRate() {    log.info("Current Thread : {}", Thread.currentThread().getName());    log.info("Fixed Rate Task : The time is now {}", DateUtil.now());}
/** * fixedDelay:固定延迟执行。距离上一次调用成功后2秒才执。 */@Scheduled(fixedDelay = 2000)public void reportCurrentTimeWithFixedDelay() { try { TimeUnit.SECONDS.sleep(3); log.info("Fixed Delay Task : The time is now {}",DateUtil.now()); } catch (InterruptedException e) { e.printStackTrace(); }}
/** * initialDelay:初始延迟。任务的第一次执行将延迟5秒,然后将以5秒的固定间隔执行。 */@Scheduled(initialDelay = 5000, fixedRate = 5000)public void reportCurrentTimeWithInitialDelay() { log.info("Fixed Rate Task with Initial Delay : The time is now {}", DateUtil.now());}
复制代码


不过,fixedRate 有个坑,假如某个方法的定时器设定的固定速率是每 5 秒执行一次,这个方法现在要执行下面四个任务,四个任务的耗时是:6s、6s、 2s、 3s,任务会如何执行呢(单线程环境下)?


2022-04-27 15:25:52.400  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:25:522022-04-27 15:25:58.401  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:25:582022-04-27 15:26:00.407  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:26:002022-04-27 15:26:04.318  INFO 4343 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:26:04
复制代码


第一个任务开始的相对时间是第 0 秒,但由于执行了 6 秒,所以原来应该是第 5 秒执行的任务,延迟到第 6 秒才开始执行,第三个任务延迟了 12 秒,原本应该是第 10 秒执行,第三个任务没有延迟,正常 15 秒后执行。


假如我们使用 @EnableAsync 注解开启多线程环境的话,结果会怎么样呢?


2022-04-27 15:33:01.385  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:012022-04-27 15:33:07.390  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:072022-04-27 15:33:09.391  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:092022-04-27 15:33:13.295  INFO 4421 --- [led-task-pool-1] c.codingmore.component.PublishPostTask   : Fixed Rate Task : The time is now 2022-04-27 15:33:13
复制代码

关于 Cron 表达式

这里顺带普及一下 Cron 表达式,在定时任务中会经常会遇到。Cron 这个词来源于希腊语 chronos,原意也就是时间。


Cron 表达式是一个含有时间意义的字符串,以 5 个空格隔开,分成 6 个时间元素。举几个例子就一目了然了。



Cron 的语法格式可以总结为:


Seconds Minutes Hours DayofMonth Month DayofWeek


每个时间元素的取值范围,以及可出现的特殊字符如下所示。



特殊字符的含义和示例如下所示。


关于 Quartz

Quartz 是一款功能强大的开源的任务调度框架,在 GitHub 上已经累计有 5k+ 的 star 了。小到单机应用,大到分布式,都可以整合 Quartz。



在使用 Quartz 之前,让我们先来搞清楚 4 个核心概念:


  • Job:任务,要执行的具体内容。

  • JobDetail:任务详情,Job 是它要执行的内容,同时包含了这个任务调度的策略和方案。

  • Trigger:触发器,可以通过 Cron 表达式来指定任务执行的时间。

  • Scheduler:调度器,可以注册多个 JobDetail 和 Trigger,用来调度、暂停和删除任务。

整合 Quartz

Quartz 存储任务的方式有两种,一种是使用内存,另外一种是使用数据库。内存在程序重启后就丢失了,所以我们这次使用数据库的方式来进行任务的持久化。


第一步,在 pom.xml 文件中添加 Quartz 的 starter。


<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-quartz</artifactId>    <version>2.6.7</version></dependency>
复制代码


第二步,在 application.yml 添加 Quartz 相关配置,配置说明直接看注释。


spring:  quartz:    job-store-type: jdbc # 默认为内存 memory 的方式,这里我们使用数据库的形式    wait-for-jobs-to-complete-on-shutdown: true # 关闭时等待任务完成    overwrite-existing-jobs: true # 可以覆盖已有的任务    jdbc:      initialize-schema: never # 是否自动使用 SQL 初始化 Quartz 表结构    properties: # quartz原生配置      org:        quartz:          scheduler:            instanceName: scheduler # 调度器实例名称            instanceId: AUTO # 调度器实例ID自动生成          # JobStore 相关配置          jobStore:            class: org.quartz.impl.jdbcjobstore.JobStoreTX # JobStore 实现类            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate # 使用完全兼容JDBC的驱动            tablePrefix: QRTZ_ # Quartz 表前缀            useProperties: false # 是否将JobDataMap中的属性转为字符串存储          # 线程池相关配置          threadPool:            threadCount: 25 # 线程池大小。默认为 10 。            threadPriority: 5 # 线程优先级            class: org.quartz.simpl.SimpleThreadPool # 指定线程池实现类,对调度器提供固定大小的线程池
复制代码


Quartz 默认使用的是内存的方式来存储任务,为了持久化,我们这里改为 JDBC 的形式,并且指定 spring.quartz.jdbc.initialize-schema=never,这样我们可以手动创建数据表。因为该值的另外两个选项 ALWAYS 和 EMBEDDED 都不太符合我们的要求:


  • ALWAYS:每次都初始化

  • EMBEDDED:只初始化嵌入式数据库,比如说 H2、HSQL


那手动创建数据表的 SQL 语句去哪里找呢?


GitHub 地址:https://github.com/quartz-scheduler/quartz/tree/master/quartz-core/src/main/resources/org/quartz/impl/jdbcjobstore


为了方便小伙伴们下载,我把它放在了本教程的源码里面了:



如果使用 Intellij IDEA 旗舰版的话,首次打开 SQL 文件的时候会提示你指定数据源。在上图中,我配置了本地的 MySQL 数据库,导入成功后可以在数据库中查看到以下数据表:



Quartz 数据库核心表如下:



剩下的就是对 Quartz 的 scheduler、jobStore 和 threadPool 配置。


第三步,创建任务调度的接口 IScheduleService,定义三个方法,分别是通过 Cron 表达式来调度任务、指定时间来调度任务,以及取消任务。


public interface IScheduleService {    /**     * 通过 Cron 表达式来调度任务     */    String scheduleJob(Class<? extends Job> jobBeanClass, String cron, String data);
/** * 指定时间来调度任务 */ String scheduleFixTimeJob(Class<? extends Job> jobBeanClass, Date startTime, String data);
/** * 取消定时任务 */ Boolean cancelScheduleJob(String jobName);}
复制代码


第四步,创建任务调度业务实现类 ScheduleServiceImpl,通过 Scheduler、CronTrigger、JobDetail 的 API 来实现对应的方法。


@Slf4j@Servicepublic class ScheduleServiceImpl implements IScheduleService {    private String defaultGroup = "default_group";
@Autowired private Scheduler scheduler; @Override public String scheduleJob(Class<? extends Job> jobBeanClass, String cron, String data) { String jobName = UUID.fastUUID().toString(); JobDetail jobDetail = JobBuilder.newJob(jobBeanClass) .withIdentity(jobName, defaultGroup) .usingJobData("data", data) .build(); //创建触发器,指定任务执行时间 CronTrigger cronTrigger = TriggerBuilder.newTrigger() .withIdentity(jobName, defaultGroup) .withSchedule(CronScheduleBuilder.cronSchedule(cron)) .build(); // 调度器进行任务调度 try { scheduler.scheduleJob(jobDetail, cronTrigger); } catch (SchedulerException e) { log.error("任务调度执行失败{}", e.getMessage()); } return jobName; }
@Override public String scheduleFixTimeJob(Class<? extends Job> jobBeanClass, Date startTime, String data) { //日期转CRON表达式 String startCron = String.format("%d %d %d %d %d ? %d", DateUtil.second(startTime), DateUtil.minute(startTime), DateUtil.hour(startTime, true), DateUtil.dayOfMonth(startTime), DateUtil.month(startTime) + 1, DateUtil.year(startTime)); return scheduleJob(jobBeanClass, startCron, data); }
@Override public Boolean cancelScheduleJob(String jobName) { boolean success = false; try { // 暂停触发器 scheduler.pauseTrigger(new TriggerKey(jobName, defaultGroup)); // 移除触发器中的任务 scheduler.unscheduleJob(new TriggerKey(jobName, defaultGroup)); // 删除任务 scheduler.deleteJob(new JobKey(jobName, defaultGroup)); success = true; } catch (SchedulerException e) { log.error("任务取消失败{}", e.getMessage()); } return success; }}
复制代码


第五步,定义好要执行的任务,继承 QuartzJobBean 类,实现 executeInternal 方法,这里只定义一个定时发布文章的任务。


@Slf4j@Componentpublic class PublishPostJob extends QuartzJobBean {    @Autowired    private IScheduleService scheduleService;    @Autowired    private IPostsService postsService;
@Override protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException { Trigger trigger = jobExecutionContext.getTrigger(); JobDetail jobDetail = jobExecutionContext.getJobDetail(); JobDataMap jobDataMap = jobDetail.getJobDataMap(); Long data = jobDataMap.getLong("data"); log.debug("定时发布文章操作:{}",data);
// 获取文章的 ID后获取文章,更新文章为发布的状态,还有发布的时间 boolean success = postsService.updatePostByScheduler(data);
//完成后删除触发器和任务 if (success) { log.debug("定时任务执行成功,开始清除定时任务"); scheduleService.cancelScheduleJob(trigger.getKey().getName()); } }}
复制代码


第六步,发布文章的接口里 PostsServiceImpl 添加定时发布的任务调度方法。


@Servicepublic class PostsServiceImpl extends ServiceImpl<PostsMapper, Posts> implements IPostsService {
private void handleScheduledAfter(Posts posts) { // 文章已经保存为草稿了,并且拿到了文章 ID // 调用定时任务 String jobName = scheduleService.scheduleFixTimeJob(PublishPostJob.class, posts.getPostDate(), posts.getPostsId().toString()); LOGGER.debug("定时任务{}开始执行", jobName); }
}
复制代码


好,我们现在启动服务,通过 Swagger 来测试一下,注意设置文章的定时发布时间。



查看 Quartz 的数据表 qrtz_cron_triggers,发现任务已经添加进来了。



qrtz_job_details 表里也可以查看具体的任务详情。



文章定时发布的时间到了之后,在日志里也可以看到 Quartz 的执行日志。



再次查看 Quartz 数据表 qrtz_cron_triggers 和 qrtz_job_details 的时候,也会发现定时任务已经清除了。


整体上来说,Spring Boot 整合 Quartz 还是非常丝滑的,配置少,步骤清晰,比 Spring Task 更强大,既能针对内存也能持久化,所以大家在遇到定时任务的时候完全可以尝试一把。


完整的功能在编程喵实战项目中已经实现了,可以把编程喵导入到本地尝试一下。

业务梳理

简单来梳理一下编程喵定时发布文章的业务。


1)用户在发布文章的时候可以选择定时发布,如果选择定时发布,那么就要设置定时发布的时间,暂时规定至少十分钟以后可以定时。


2)当管理端用户选择了定时发布,那么在保存文章的时候,文章状态要先设置为草稿状态,对前端用户是不可见的状态。


3)保存文章的时候通知 Quartz,我有一个任务,你需要在某个规定的时间去执行。


scheduleService.scheduleFixTimeJob(PublishPostJob.class, posts.getPostDate(), posts.getPostsId().toString());
复制代码


4)Quartz 收到这个通知后,就会在数据库中写入任务,具体的任务是到指定时间把文章从草稿的状态转为发布状态,这时候,前端用户就可以看得见文章了。


// 获取文章的 ID后获取文章,更新文章为发布的状态,还有发布的时间boolean success = postsService.updatePostByScheduler(data);
复制代码


同时,将任务清除。


// 暂停触发器scheduler.pauseTrigger(new TriggerKey(jobName, defaultGroup));// 移除触发器中的任务scheduler.unscheduleJob(new TriggerKey(jobName, defaultGroup));// 删除任务scheduler.deleteJob(new JobKey(jobName, defaultGroup));
复制代码


整个过程就完成了。Quartz 是如何实现定时发布文章的呢?其实也是通过 Cron 表达式。


CronTrigger cronTrigger = TriggerBuilder.newTrigger()                .withIdentity(jobName, defaultGroup)                .withSchedule(CronScheduleBuilder.cronSchedule(cron))                .build();
复制代码


也就是当我们传入一个指定时间后,通过计算,计算出 Cron 表达式。


String startCron = String.format("%d %d %d %d %d ? %d",                DateUtil.second(startTime),                DateUtil.minute(startTime),                DateUtil.hour(startTime, true),                DateUtil.dayOfMonth(startTime),                DateUtil.month(startTime) + 1,                DateUtil.year(startTime));
复制代码


在 Quartz 中,有两类线程:Scheduler 调度线程和任务执行线程。


  • 任务执行线程:Quartz 不会在主线程(QuartzSchedulerThread)中处理用户的 Job。Quartz 把线程管理的职责委托给 ThreadPool,一般的设置使用 SimpleThreadPool。SimpleThreadPool 创建了一定数量的 WorkerThread 实例来使得 Job 能够在线程中进行处理。WorkerThread 是定义在 SimpleThreadPool 类中的内部类,它实质上就是一个线程。

  • QuartzSchedulerThread 调度主线程:QuartzScheduler 被创建时创建一个 QuartzSchedulerThread 实例。

源码路径


本文已收录到 GitHub 上星标 2.4k+ 的开源专栏《Java 程序员进阶之路》,据说每一个优秀的 Java 程序员都喜欢她,风趣幽默、通俗易懂。内容包括 Java 基础、Java 并发编程、Java 虚拟机、Java 企业级开发、Java 面试等核心知识点。学 Java,就认准 Java 程序员进阶之路😄。


https://github.com/itwanger/toBeBetterJavaer


star 了这个仓库就等于你拥有了成为了一名优秀 Java 工程师的潜力。该开源仓库最近又上 GitHub trending 榜单了,看来是大家都非常认可呀!



没有什么使我停留——除了目的,纵然岸旁有玫瑰、有绿荫、有宁静的港湾,我是不系之舟



发布于: 刚刚阅读数: 5
用户头像

沉默王二

关注

《Web全栈开发进阶之路》作者 2018.07.31 加入

一枚沉默但有趣的程序员

评论

发布
暂无评论
SpringBoot官方支持任务调度框架,轻量级用起来也挺香!_Java_沉默王二_InfoQ写作社区