目录
一、SpringBoot定时任务
定时任务概述
创建定时任务
代码开启定时任务
执行结果 （单线程）
多线程处理定时任务
执行结果（并发）
二、Cron详解
Cron表达式是什么
Cron表达式的结构
每个域可出现的字符类型和各字符的含义
各域支持的字符类型
特殊字符含义
表达式例子
举例详解
一、SpringBoot定时任务
定时任务概述
后台项目开发中经常会用到定时任务，现在实现定时任务都方式也是多种多样。下面列举几种常见的定时任务实现方式：
1. Quartz：Quartz的使用相当广泛，它是一个功能强大的调度器，当然使用起来也相对麻烦；
2. java.util包里的Timer，它也可以实现定时任务但是功能过于单一所有使用很少。
3. 今天要介绍的是Spring自带的定时任务Schedule，其实可以把它看作是一个简化版的，轻量级的Quartz，使用起来也相对方便很多。
创建定时任务
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：时区，默认为当前时区，一般没有用到。
代码开启定时任务
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的任务并由后台执行。没有它的话将无法执行定时任务
执行结果 （单线程）
到此我们就完成了一个简单的定时任务模型，下面执行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次执行方法从控制台输入的结果中我们可以看出所有的定时任务都是在同一个线程池用同一个线程来处理的，那么我们如何来并发的处理各定时任务呢？⬇⬇⬇⬇💨💨💨
多线程处理定时任务
看到控制台输出的结果，所有的定时任务都是通过一个线程来处理的，我估计是在定时任务的配置中设定了一个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（），但是最后失败了，不知道是否可以通过这个类实现定时任务的并发，如果有实现了的也请告诉大家一下方法。
执行结果（并发）
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详解
Cron表达式是什么
Cron：计划任务，是任务在约定的时间执行已经计划好的工作，而Cron表达式是一个字符串，字符串以5或6个空格隔开，分为6或7个域，每一个域代表一个含义
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);
}每个域可出现的字符类型和各字符的含义
各域支持的字符类型
- 秒：可出现", - * /"四个字符，有效范围为0-59的整数
- 分：可出现", - * /"四个字符，有效范围为0-59的整数
- 时：可出现", - * /"四个字符，有效范围为0-23的整数
- 每月第几天：可出现", - * / ? L W C"八个字符，有效范围为0-31的整数
- 月：可出现", - * /"四个字符，有效范围为1-12的整数或JAN-DEc
- 星期：可出现", - * / ? L C #"四个字符，有效范围为1-7的整数或SUN-SAT两个范围。1表示星期天，2表示星期一， 依次类推
特殊字符含义
* : 表示匹配该域的任意值，比如在秒*, 就表示每秒都会触发事件。；
? : 只能用在每月第几天和星期两个域。表示不指定值，当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“?”；
- : 表示范围，例如在分域使用5-20，表示从5分到20分钟每分钟触发一次
/ : 表示起始时间开始触发，然后每隔固定时间触发一次，例如在分域使用5/20,则意味着5分，25分，45分，分别触发一次.
, : 表示列出枚举值。例如：在分域使用5,20，则意味着在5和20分时触发一次。
L : 表示最后，只能出现在星期和每月第几天域，如果在星期域使用1L,意味着在最后的一个星期日触发。
W : 表示有效工作日(周一到周五),只能出现在每月第几日域，系统将在离指定日期的最近的有效工作日触发事件。注意一点，W的最近寻找不会跨过月份
LW : 这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。
# : 用于确定每个月第几个星期几，只能出现在每月第几天域。例如在1#3，表示某月的第三个星期日。
表达式例子
| 要求 | 表达式 |
| 每隔3秒钟执行一次 | */3 * * * * ? |
| 每天中午12点执行一次 | 0 0 12 * * ? |
| 每天上午10:30执行一次 | 0 30 10 ? * * 0 30 10 * * ? 0 30 10 * * ? * |
| 2023年的每天上午10:30执行一次 | 0 30 10 * * ? 2023 |
| 每天下午5点到下午5:59每分钟执行一次 | 0 * 17 * * ? |
| 周一到周五每天上午10:15执行 | 0 15 10 ? * 2-6 |
| 每天上午8点，下午1点，4点执行一次 | 0 0 8,13,16 * * ? |
| 每月的第4个星期五上午10:30执行一次 | 0 30 10 ? * 6#4 |
| 每月的最后一个星期五上午10:30执行一次 | 0 30 10 ? * 6L |
举例详解
" ， "
代表指定的星期触发，例如，1,2,5 代表星期天、星期一、星期四触发" - "
" -"
代表指定范围內触发，如1-3 代表从星期日到星期二（国外星期日算第一天），每隔一天触发一次
" * "
代表每个星期都触发
" / "
代表触发步进，"/"前面的值代表初始值("*"等同"1")，后面的值代表偏移量，比如"1/4"或者"*/4"代表从星期天开始触发，每隔4天触发1次；"1-5/2"表达式意味着在[1,5]范围内，每隔2天触发，即星期天、星期二、星期四触发
" L "
有last，最后的意思，表示星期的最后一天触发(这里是周六),"4L"表示一个月的最后一个星期三触发
" # "
"#" 代表具体的周数，"#"前面代表星期，"#"后面代表本月第几周，比如"2#2"表示本月第二周的星期一，"5#3"表示本月第三周的星期四，"4L"是"#"的特殊形式
Cron在线生成工具：在线Cron表达式生成器
