转载

SpringBoot定时任务及Cron表达式详解

摘要: 讲解如何使用SpringBoot定时任务，并通过源码说明如何使用多线程处理各定时任务。详细说明cron表达式用法。

一、定时任务概述

后台项目开发中经常会用到定时任务，现在实现定时任务都方式也是多种多样。下面列举几种常见的定时任务实现方式：

1. Quartz：Quartz的使用相当广泛，它是一个功能强大的调度器，当然使用起来也相对麻烦;

2. java.util包里的Timer，它也可以实现定时任务但是功能过于单一所有使用很少。

3. 就是我们今天要介绍的Spring自带的定时任务Schedule，其实可以把它看作是一个简化版的，轻量级的Quartz，使用起来也相对方便很多。

二、实现定时任务

1. 创建定时任务

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.scheduling.annotation.Scheduled; 
import org.springframework.stereotype.Component; 
 
/** 
 * Description: 构建执行定时任务 
 * Designer: jack 
 * Date: 2017/8/10 
 * Version: 1.0.0 
 */ 
@Component 
public class ScheduledTasks { 
 
    private Logger logger = LoggerFactory.getLogger(ScheduledTasks.class); 
 
    private int fixedDelayCount = 1; 
    private int fixedRateCount = 1; 
    private int initialDelayCount = 1; 
    private int cronCount = 1; 
 
    @Scheduled(fixedDelay = 5000)        //fixedDelay = 5000表示当前方法执行完毕5000ms后，Spring scheduling会再次调用该方法 
    public void testFixDelay() { 
        logger.info("===fixedDelay: 第{}次执行方法", fixedDelayCount++); 
    } 
 
    @Scheduled(fixedRate = 5000)        //fixedRate = 5000表示当前方法开始执行5000ms后，Spring scheduling会再次调用该方法 
    public void testFixedRate() { 
        logger.info("===fixedRate: 第{}次执行方法", fixedRateCount++); 
    } 
 
    @Scheduled(initialDelay = 1000, fixedRate = 5000)   //initialDelay = 1000表示延迟1000ms执行第一次任务 
    public void testInitialDelay() { 
        logger.info("===initialDelay: 第{}次执行方法", initialDelayCount++); 
    } 
 
    @Scheduled(cron = "0 0/1 * * * ?")  //cron接受cron表达式，根据cron表达式确定定时规则 
    public void testCron() { 
        logger.info("===initialDelay: 第{}次执行方法", cronCount++); 
    } 
 
}

我们使用@Scheduled来创建定时任务这个注解用来标注一个定时任务方法。通过看@Scheduled源码可以看出它支持多种参数：

(1)cron：cron表达式，指定任务在特定时间执行;

(2)fixedDelay：表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms;

(3)fixedDelayString：与fixedDelay含义一样，只是参数类型变为String;

(4)fixedRate：表示按一定的频率执行任务，参数类型为long，单位ms;

(5)fixedRateString: 与fixedRate的含义一样，只是将参数类型变为String;

(6)initialDelay：表示延迟多久再第一次执行任务，参数类型为long，单位ms;

(7)initialDelayString：与initialDelay的含义一样，只是将参数类型变为String;

(8)zone：时区，默认为当前时区，一般没有用到。

2.开启定时任务

import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 
import org.springframework.scheduling.annotation.EnableScheduling; 
 
/** 
 * Description: 启动类 
 * Designer: jack 
 * Date: 2017/8/10 
 * Version: 1.0.0 
 */ 
@SpringBootApplication 
@EnableScheduling 
public class Application { 
    public static void main(String[] args) { 
        SpringApplication.run(Application.class, args); 
    } 
}

注意这里的 @EnableScheduling 注解，它的作用是发现注解@Scheduled的任务并由后台执行。没有它的话将无法执行定时任务。

引用官方文档原文：

@EnableScheduling ensures that a background task executor is created. Without it, nothing gets scheduled.

3. 执行结果 (单线程)

到此我们就完成了一个简单的定时任务模型，下面执行springBoot观察执行结果。

2017-08-11 12:06:19.738  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===initialDelay: 第1次执行方法 
2017-08-11 12:06:23.739  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===fixedRate: 第2次执行方法 
2017-08-11 12:06:23.739  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===fixedDelay: 第2次执行方法 
2017-08-11 12:06:24.738  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===initialDelay: 第2次执行方法 
2017-08-11 12:06:28.739  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===fixedRate: 第3次执行方法 
2017-08-11 12:06:28.740  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===fixedDelay: 第3次执行方法 
2017-08-11 12:06:29.739  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===initialDelay: 第3次执行方法 
2017-08-11 12:06:33.735  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===fixedRate: 第4次执行方法 
2017-08-11 12:06:33.741  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===fixedDelay: 第4次执行方法 
2017-08-11 12:06:34.738  INFO 52252 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===initialDelay: 第4次执行方法

从控制台输入的结果中我们可以看出所有的定时任务都是在同一个线程池用同一个线程来处理的，那么我们如何来并发的处理各定时任务呢，请继续向下看。

4. 多线程处理定时任务

看到控制台输出的结果，所有的定时任务都是通过一个线程来处理的，我估计是在定时任务的配置中设定了一个SingleThreadScheduledExecutor，于是我看了源码，从ScheduledAnnotationBeanPostProcessor类开始一路找下去。果然，在ScheduledTaskRegistrar(定时任务注册类)中的ScheduleTasks中又这样一段判断：

if (this.taskScheduler == null) { 
            this.localExecutor = Executors.newSingleThreadScheduledExecutor(); 
            this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor); 
        }

这就说明如果taskScheduler为空，那么就给定时任务做了一个单线程的线程池，正好在这个类中还有一个设置taskScheduler的方法：

public void setScheduler(Object scheduler) { 
        Assert.notNull(scheduler, "Scheduler object must not be null"); 
        if (scheduler instanceof TaskScheduler) { 
            this.taskScheduler = (TaskScheduler) scheduler; 
        } 
        else if (scheduler instanceof ScheduledExecutorService) { 
            this.taskScheduler = new ConcurrentTaskScheduler(((ScheduledExecutorService) scheduler)); 
        } 
        else { 
            throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass()); 
        } 
    }

这样问题就很简单了，我们只需用调用这个方法显式的设置一个ScheduledExecutorService就可以达到并发的效果了。我们要做的仅仅是实现SchedulingConfigurer接口，重写configureTasks方法就OK了;

import org.springframework.context.annotation.Configuration; 
import org.springframework.scheduling.annotation.SchedulingConfigurer; 
import org.springframework.scheduling.config.ScheduledTaskRegistrar; 
 
import java.util.concurrent.Executors; 
 
/** 
 * Description: 多线程执行定时任务 
 * Designer: jack 
 * Date: 2017/8/10 
 * Version: 1.0.0 
 */ 
@Configuration 
//所有的定时任务都放在一个线程池中，定时任务启动时使用不同都线程。 
public class ScheduleConfig implements SchedulingConfigurer { 
    @Override 
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { 
        //设定一个长度10的定时任务线程池 
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(10)); 
    } 
}

注: 最开始我试图在ScheduledAnnotationBeanPostProcessor类中做文章，因为里面也有一个类似的方法setScheduler()，但是最后失败了，不知道是否可以通过这个类实现定时任务的并发，如果有实现了的也请告诉大家一下方法。

5. 执行结果(并发)

2017-08-11 12:21:16.000  INFO 52284 --- [pool-1-thread-3] com.test.ScheduledTasks                  : ===initialDelay: 第1次执行方法 
2017-08-11 12:21:19.998  INFO 52284 --- [pool-1-thread-4] com.test.ScheduledTasks                  : ===fixedRate: 第2次执行方法 
2017-08-11 12:21:19.998  INFO 52284 --- [pool-1-thread-1] com.test.ScheduledTasks                  : ===fixedDelay: 第2次执行方法 
2017-08-11 12:21:20.999  INFO 52284 --- [pool-1-thread-4] com.test.ScheduledTasks                  : ===initialDelay: 第2次执行方法 
2017-08-11 12:21:25.000  INFO 52284 --- [pool-1-thread-2] com.test.ScheduledTasks                  : ===fixedRate: 第3次执行方法 
2017-08-11 12:21:25.000  INFO 52284 --- [pool-1-thread-6] com.test.ScheduledTasks                  : ===fixedDelay: 第3次执行方法 
2017-08-11 12:21:25.997  INFO 52284 --- [pool-1-thread-3] com.test.ScheduledTasks                  : ===initialDelay: 第3次执行方法 
2017-08-11 12:21:30.000  INFO 52284 --- [pool-1-thread-7] com.test.ScheduledTasks                  : ===fixedRate: 第4次执行方法 
2017-08-11 12:21:30.000  INFO 52284 --- [pool-1-thread-8] com.test.ScheduledTasks                  : ===fixedDelay: 第4次执行方法 
2017-08-11 12:21:31.000  INFO 52284 --- [pool-1-thread-7] com.test.ScheduledTasks                  : ===initialDelay: 第4次执行方法

通过控制台输出的结果看出每个定时任务都是在通过不同的线程来处理了。

三、cron详解

1. cron表达式定义

Cron表达式是一个字符串，是由空格隔开的6或7个域组成，每一个域对应一个含义(秒分时每月第几天月星期年)其中年是可选字段。

但是，此处敲一下黑板，spring的schedule值支持6个域的表达式，也就是不能设定年，如果超过六个则会报错。源码如下：

/** 
     * Parse the given pattern expression. 
     */ 
    private void parse(String expression) throws IllegalArgumentException { 
        String[] fields = StringUtils.tokenizeToStringArray(expression, " "); 
        if (!areValidCronFields(fields)) { 
            throw new IllegalArgumentException(String.format( 
                    "Cron expression must consist of 6 fields (found %d in /"%s/")", fields.length, expression)); 
        } 
        setNumberHits(this.seconds, fields[0], 0, 60); 
        setNumberHits(this.minutes, fields[1], 0, 60); 
        setNumberHits(this.hours, fields[2], 0, 24); 
        setDaysOfMonth(this.daysOfMonth, fields[3]); 
        setMonths(this.months, fields[4]); 
        setDays(this.daysOfWeek, replaceOrdinals(fields[5], "SUN,MON,TUE,WED,THU,FRI,SAT"), 8); 
        if (this.daysOfWeek.get(7)) { 
            // Sunday can be represented as 0 or 7 
            this.daysOfWeek.set(0); 
            this.daysOfWeek.clear(7); 
        } 
    } 
 
    private static boolean areValidCronFields(String[] fields) { 
        return (fields != null && fields.length == 6); 
    }