前言

定时任务 一般会存在 中大型企业级 项目中，为了减少 服务器、数据库 的压力，往往会以 定时任务 的方式去完成某些业务逻辑。

常见的就是 金融服务系统 推送回调，一般支付系统订单在没有收到成功的回调返回内容时会 持续性的回调，这种回调一般都是 定时任务 来完成。

还有就是 报表的生成，我们一般会在客户 访问量小 时完成这个操作，也可以采用 定时任务 来完成。

正文

定时任务的几种方式

Timer

这是

Java

自带的

java.util.Timer

类，这个类允许调度一个名为

java.util.TimerTask

任务。使用这种方式可以让你的程序按照某一个 频度 执行，但不能在 指定时间 运行。现在一般用的较少。

ScheduledExecutorService

JDK

自带的一个类，是基于 线程池 设计的定时任务类，每个 调度任务 都会分配到 线程池 中的一个 线程 去执行。也就是说，任务是 并发执行，互不影响的。

Spring Task

Spring3.0

以后自带的

Task

，支持 多线程 调度，可以将它看成一个 轻量级的

Quartz

，而且使用起来比

Quartz

简单许多，但是适用于 单节点 的 定时任务调度。

Quartz

这是一个 功能比较强大 的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来 稍显复杂。

Quartz

功能强大，可以结合 数据库 做 持久化，进行 分布式 的 任务延时调度。

Cron表达式简介

Cron

表达式是一个字符串，字符串以

5

或

6

个 空格 隔开，分为

6

或

7

个 域，每一个域代表一个含义，

Cron

有如下两种语法格式：

1. Seconds Minutes Hours DayofMonth Month DayofWeek Year

2. Seconds Minutes Hours DayofMonth Month DayofWeek

每个域对应的含义、域值范围和特殊表示符，从左到右依次如下：

如上面的表达式所示:

• \”\”字符: 被用来指定所有的值。如：在分钟的字段域里表示\”每分钟\”。

• \”-\”字符: 被用来指定一个范围。如：\”10-12\” 在小时域意味着 \”10点、11点、12点\”。

• \”,\”字符: 被用来指定另外的值。如：\”MON,WED,FRI\” 在星期域里表示 \”星期一、星期三、星期五\”。

• \”?\”字符: 只在日期域和星期域中使用。它被用来指定\”非明确的值\”。当你需要通过在这两个域中的一个来指定一些东西的时候，它是有用的。看下面的例子你就会明白。

• \”L\”字符: 指定在月或者星期中的某天（最后一天）。即 \”Last\” 的缩写。但是在星期和月中 \”Ｌ\” 表示不同的意思，如：在月子段中 \”L\” 指月份的最后一天 – 1月31日，2月28日。

  如果在星期字段中则简单的表示为 \”7\” 或者 \”SAT\” 字符。

• 如果在星期字段中在某个 value 值得后面，则表示 \”某月的最后一个星期value\”，如 \”6L\” 表示某月的最后一个星期五。

\”W\”字符: 只能用在月份字段中，该字段指定了离指定日期最近的那个星期日。

\”#\”字符: 只能用在星期字段，该字段指定了第几个星期 value 在某月中。

每一个元素都可以显式地规定一个值（如

6

），一个区间（如

9-12

），一个列表（如

9，11，13

）或一个通配符（如

*

）。\”月份中的日期\” 和\”星期中的日期\” 这两个元素是 互斥的，因此应该通过设置一个 问号（

?

）来表明你不想设置的那个字段。下表显示了一些

cron

表达式的 例子 和它们的意义：

环境准备

配置gradle依赖

利用

SpringInitializer

创建一个

gradle

项目

spring-boot-scheduler-task-management

，创建时添加相关依赖。得到的初始

build.gradle

如下：

buildscript {    ext {        springBootVersion = \'2.0.3.RELEASE\'    }    repositories {        mavenCentral()    }    dependencies {        classpath(\"org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}\")    }}apply plugin: \'java\'apply plugin: \'eclipse\'apply plugin: \'org.springframework.boot\'apply plugin: \'io.spring.dependency-management\'group = \'io.ostenant.springboot.sample\'version = \'0.0.1-SNAPSHOT\'sourceCompatibility = 1.8repositories {    mavenCentral()}dependencies {    compile(\'org.springframework.boot:spring-boot-starter\')    compile(\'org.springframework.boot:spring-boot-starter-web\')    testCompile(\'org.springframework.boot:spring-boot-starter-test\')}

在

SpringBoot

入口类上配置

@EnableScheduling

注解开启

Spring

自带的定时处理功能。

@SpringBootApplication@EnableSchedulingpublic class Application {    public static void main(String[] args) {        SpringApplication.run(Application.class, args);    }}

配置Timer任务

这个

API

目前在项目中很少用，直接给出示例代码。具体的介绍可以查看

API

。

Timer

的内部只有 一个线程，如果有 多个任务 的话就会 顺序执行，这样任务的 延迟时间 和 循环时间 就会出现问题。

TimerService.java

public class TimerService {    private static final Logger LOGGER = LoggerFactory.getLogger(TimerService.class);    private AtomicLong counter = new AtomicLong();    public void schedule() {        TimerTask timerTask = new TimerTask() {            @Override            public void run() {                long count = counter.incrementAndGet();                LOGGER.info(\"Schedule timerTask {} times\", count);            }        };        Timer timer = new Timer();        timer.schedule(timerTask, 1000L, 10 * 1000L;    }}

上面的代码定义了一个

TimerTask

，在

TimerTask

中累加 执行次数，并通过

slf4j

进行打印 (自带执行时间)。然后通过

Timer

调度工具类调度

TimerTask

任务，设置 初始化延迟时间 为

1s

，定时执行间隔 为

10s

，测试代码如下：

public static void main(String[] args) {    TimerService timerService = new TimerService();    timerService.schedule();}

观察测试结果，能够发现

TimerTask

配置的任务每隔

10s

被执行了一次，执行线程默认都是

Timer-0

这个线程。

17:48:18.731 [Timer-0] INFO io.ostenant.springboot.sample.timer.TimerService - Schedule timerTask 1 times17:48:28.730 [Timer-0] INFO io.ostenant.springboot.sample.timer.TimerService - Schedule timerTask 2 times17:48:38.736 [Timer-0] INFO io.ostenant.springboot.sample.timer.TimerService - Schedule timerTask 3 times17:48:48.738 [Timer-0] INFO io.ostenant.springboot.sample.timer.TimerService - Schedule timerTask 4 times17:48:58.743 [Timer-0] INFO io.ostenant.springboot.sample.timer.TimerService - Schedule timerTask 5 times

配置ScheduledExecutorService任务

ScheduledExecutorService

是 延时执行 的线程池，对于 多线程 环境下的定时任务，推荐用

ScheduledExecutorService

代替

Timer

定时器。

创建一个线程数量为

4

的 任务线程池，同一时刻并向它提交

4

个定时任务，用于测试延时任务的 并发处理。执行

ScheduledExecutorService

的

scheduleWithFixedDelay()

方法，设置任务线程池的 初始任务延迟时间 为

2

秒，并在上一次 执行完毕时间点 之后

10

秒再执行下一次任务。

public void scheduleWithFixedDelay() {    ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(4);    for (int i = 0; i < 4; i++) {        scheduledExecutor.scheduleWithFixedDelay(() -> {            try {                TimeUnit.MILLISECONDS.sleep(10 * 1000L);            } catch (InterruptedException e) {                LOGGER.error(\"Interrupted exception\", e);            }            long count = counter.incrementAndGet();            LOGGER.info(\"Schedule executor {} times with fixed delay\", count);        }, 2000L, 10 * 1000L, TimeUnit.MILLISECONDS);    }    LOGGER.info(\"Start to schedule\");}

测试结果如下，我们可以发现每隔

20

秒的时间间隔，就会有

4

个定时任务同时执行。因为在任务线程池初始化时，我们同时向线程池提交了

4

个任务，这 四个任务 会完全利用线程池中的

4

个线程进行任务执行。

20

秒是怎么来的？首先每个任务的 时间间隔 设置为

10

秒。其次因为采用的是

withFixedDelay

策略，即当前任务执行的 结束时间，作为下次延时任务的 开始计时节点，并且每个任务在执行过程中睡眠了

10

秒的时间，累计起来就是

20

秒的时间。

19:42:02.444 [main] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Start to schedule19:42:14.449 [pool-1-thread-1] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 3 times with fixed delay19:42:14.449 [pool-1-thread-2] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 1 times with fixed delay19:42:14.449 [pool-1-thread-3] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 2 times with fixed delay19:42:14.449 [pool-1-thread-4] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 4 times with fixed delay19:42:34.458 [pool-1-thread-4] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 7 times with fixed delay19:42:34.458 [pool-1-thread-3] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 5 times with fixed delay19:42:34.458 [pool-1-thread-2] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 8 times with fixed delay19:42:34.458 [pool-1-thread-1] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 6 times with fixed delay

创建一个线程数量为

4

的 任务线程池，同一时刻并向它提交

4

个定时任务，用于测试延时任务的 并发处理。每个任务分别执行

ScheduledExecutorService

的

scheduleAtFixedRate()

方法，设置任务线程池的 初始任务延迟时间 为

2

秒，并在上一次 开始执行时间点 之后

10

秒再执行下一次任务。

public void scheduleAtFixedRate() {    ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(4);    for (int i = 0; i < 4; i++) {        scheduledExecutor.scheduleAtFixedRate(() -> {            long count = counter.incrementAndGet();            LOGGER.info(\"Schedule executor {} times at fixed rate\", count);        }, 2000L, 10 * 1000L, TimeUnit.MILLISECONDS);    }    LOGGER.info(\"Start to schedule\");}

测试结果如下，我们可以发现每隔

10

秒的时间间隔，就会有

4

个定时任务同时执行，因为在任务线程池初始化时，我们同时向线程池提交了

4

个任务，这 四个任务 会完全利用线程池中的

4

个线程进行任务执行。

19:31:46.837 [main] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Start to schedule19:31:48.840 [pool-1-thread-1] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 1 times at fixed rate19:31:48.840 [pool-1-thread-3] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 3 times at fixed rate19:31:48.840 [pool-1-thread-2] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 2 times at fixed rate19:31:48.840 [pool-1-thread-4] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 4 times at fixed rate19:31:58.839 [pool-1-thread-2] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 6 times at fixed rate19:31:58.840 [pool-1-thread-4] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 8 times at fixed rate19:31:58.839 [pool-1-thread-3] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 7 times at fixed rate19:31:58.839 [pool-1-thread-1] INFO io.ostenant.springboot.sample.executor.ScheduledExecutorsService - Schedule executor 5 times at fixed rate

配置Spring Task任务

Spring

提供了

@Scheduled

注解来实现 定时任务，

@Scheduled

参数可以接受 两种 定时的设置，一种是我们常用的 格林时间表达式

cron=\"*/10 * * * * *\"

，另一种是

fixedRate=10*1000L

，两种都表示每隔

10

秒执行一次目标任务。

参数说明：

• @Scheduled(fixedRate = 10 * 1000L)：上一次 开始执行时间点 之后 

  10

   秒再执行。

@Scheduled(fixedRate = 10 * 1000L)public void scheduleAtFixedRate() throws Exception {    long count = counter.incrementAndGet();    LOGGER.info(\"Schedule executor {} times at fixed rate\", count);}

• @Scheduled(fixedDelay = 10 * 1000L)：上一次 执行完毕时间点 之后 

  10

   秒再执行。

@Scheduled(fixedDelay = 10 * 1000L)public void scheduleWithFixedDelay() throws Exception {    try {        TimeUnit.MILLISECONDS.sleep(10 * 1000L);    } catch (InterruptedException e) {        LOGGER.error(\"Interrupted exception\", e);    }    long count = counter.incrementAndGet();    LOGGER.info(\"Schedule executor {} times with fixed delay\", count);}

• @Scheduled(initialDelay = 2000L, fixedRate = 10 * 1000L)：第一次延迟 

  2

   秒后执行，之后按 

  fixedRate

   的规则每 

  10

   秒执行一次。

@Scheduled(initialDelay = 2000L, fixedDelay = 10 * 1000L)public void scheduleWithinitialDelayAndFixedDelay() throws Exception {    try {        TimeUnit.MILLISECONDS.sleep(10 * 1000L);    } catch (InterruptedException e) {        LOGGER.error(\"Interrupted exception\", e);    }    long count = counter.incrementAndGet();    LOGGER.info(\"Schedule executor {} times with fixed delay\", count);}

• @Scheduled(cron = \”0/10 * * * * *\”)：根据 

  cron

   表达式定义，每隔 

  10

   秒执行一次。

@Scheduled(cron = \"0/10 * * * * *\")public void scheduleWithCronExpression() throws Exception {    long count = counter.incrementAndGet();    LOGGER.info(\"Schedule executor {} times with \", count);}

完整的代码如下：

SpringTaskService.java

@Componentpublic class SpringTaskService {    private static final Logger LOGGER = LoggerFactory.getLogger(SpringTaskService.class);    private AtomicLong counter = new AtomicLong();    @Scheduled(fixedDelay = 10 * 1000L)    public void scheduleWithFixedDelay() throws Exception {        try {            TimeUnit.MILLISECONDS.sleep(10 * 1000L);        } catch (InterruptedException e) {            LOGGER.error(\"Interrupted exception\", e);        }        long count = counter.incrementAndGet();        LOGGER.info(\"Schedule executor {} times with fixed delay\", count);    }    @Scheduled(initialDelay = 2000L, fixedDelay = 10 * 1000L)    public void scheduleWithinitialDelayAndFixedDelay() throws Exception {        try {            TimeUnit.MILLISECONDS.sleep(10 * 1000L);        } catch (InterruptedException e) {            LOGGER.error(\"Interrupted exception\", e);        }        long count = counter.incrementAndGet();        LOGGER.info(\"Schedule executor {} times with fixed delay\", count);    }    @Scheduled(fixedRate = 10 * 1000L)    public void scheduleAtFixedRate() throws Exception {        long count = counter.incrementAndGet();        LOGGER.info(\"Schedule executor {} times at fixed rate\", count);    }    @Scheduled(cron = \"0/10 * * * * *\")    public void scheduleWithCronExpression() throws Exception {        long count = counter.incrementAndGet();        LOGGER.info(\"Schedule executor {} times with \", count);    }}

查看日志，任务每

20

秒的时间间隔执行一次。每次定时任务在上次 执行完毕时间点 之后

10

秒再执行，在任务中设置 睡眠时间 为

10

秒。这里只验证了 @Scheduled(initialDelay = 2000L, fixedDelay = 10 * 1000L)。

2018-06-25 18:00:53.051  INFO 5190 --- [pool-1-thread-1] i.o.s.sample.spring.SpringTaskService    : Schedule executor 1 times with fixed delay2018-06-25 18:01:13.056  INFO 5190 --- [pool-1-thread-1] i.o.s.sample.spring.SpringTaskService    : Schedule executor 2 times with fixed delay2018-06-25 18:01:33.061  INFO 5190 --- [pool-1-thread-1] i.o.s.sample.spring.SpringTaskService    : Schedule executor 3 times with fixed delay2018-06-25 18:01:53.071  INFO 5190 --- [pool-1-thread-1] i.o.s.sample.spring.SpringTaskService    : Schedule executor 4 times with fixed delay2018-06-25 18:02:13.079  INFO 5190 --- [pool-1-thread-1] i.o.s.sample.spring.SpringTaskService    : Schedule executor 5 times with fixed delay

配置任务线程池

上述配置都是基于 单线程 的任务调度，如何引入 多线程 提高 延时任务的 并发处理 能力？

SpringBoot

提供了一个

SchedulingConfigurer

配置接口。我们通过

ScheduleConfig

配置文件实现

ScheduleConfiguration

接口，并重写

configureTasks()

方法，向

ScheduledTaskRegistrar

注册一个

ThreadPoolTaskScheduler

任务线程对象即可。

@Configurationpublic class ScheduleConfiguration implements SchedulingConfigurer {    private static final Logger LOGGER = LoggerFactory.getLogger(ScheduleConfiguration.class);    @Override    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {        taskRegistrar.setTaskScheduler(taskScheduler());    }    @Bean    public ThreadPoolTaskScheduler taskScheduler() {        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();        taskScheduler.setPoolSize(4);        taskScheduler.setWaitForTasksToCompleteOnShutdown(true);        taskScheduler.setThreadNamePrefix(\"schedule\");        taskScheduler.setRemoveOnCancelPolicy(true);        taskScheduler.setErrorHandler(t -> LOGGER.error(\"Error occurs\", t));        return taskScheduler;    }}

启动

SpringBoot

引用，上面

SpringTaskService

配置的

4

个定时任务会同时生效。

2018-06-20 20:37:50.746  INFO 8142 --- [      schedule1] i.o.s.sample.spring.SpringTaskService    : Schedule executor 1 times at fixed rate2018-06-20 20:38:00.001  INFO 8142 --- [      schedule3] i.o.s.sample.spring.SpringTaskService    : Schedule executor 2 times with 2018-06-20 20:38:00.751  INFO 8142 --- [      schedule1] i.o.s.sample.spring.SpringTaskService    : Schedule executor 3 times at fixed rate2018-06-20 20:38:02.748  INFO 8142 --- [      schedule2] i.o.s.sample.spring.SpringTaskService    : Schedule executor 4 times with fixed delay2018-06-20 20:38:10.005  INFO 8142 --- [      schedule4] i.o.s.sample.spring.SpringTaskService    : Schedule executor 5 times with 2018-06-20 20:38:10.747  INFO 8142 --- [      schedule3] i.o.s.sample.spring.SpringTaskService    : Schedule executor 6 times at fixed rate2018-06-20 20:38:20.002  INFO 8142 --- [      schedule2] i.o.s.sample.spring.SpringTaskService    : Schedule executor 7 times with 2018-06-20 20:38:20.747  INFO 8142 --- [      schedule4] i.o.s.sample.spring.SpringTaskService    : Schedule executor 8 times at fixed rate

观察日志，线程名前缀 为

schedule

，可以发现

SpringTask

将

@Scheduled

注解配置的

4

个任务，分发给我们配置的

ThreadPoolTaskScheduler

中的

4

个线程并发执行。

小结

本文介绍了基于单节点的定时任务调度及实现，包括

JDK

原生的

Timer

和

ScheduledExecutorService

，以及

Spring3.0

以后自带的基于注解的

SpringTask

任务调度方式。除此之外，重点阐述了基于 固定延时、固定频率和

cron

表达式 的不同之处，并对

ScheduledExecutorService

和

SpringScheduler

的 线程池并发处理 进行了测试。

欢迎关注技术公众号： 零壹技术栈

本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。