使用@Schedule注解实现定时任务，多线程执行定时任务，Cron表达式详解

使用@Schedule注解实现定时任务

1、首先，在项目启动类上添加 @EnableScheduling 注解，开启对定时任务的支持。@EnableScheduling 注解的作用是发现注解 @Scheduled 的任务并在后台执行该任务。

@SpringBootApplication
@EnableScheduling
public class ScheduledApplication {

	public static void main(String[] args) {
		SpringApplication.run(ScheduledApplication.class, args);
	}

}

2、编写定时任务类和方法，定时任务类通过 Spring IOC 加载，使用 @Component 注解。
3、定时方法使用 @Scheduled注解。下述代码中，fixedRate 是 long 类型，表示任务执行的间隔毫秒数，下面代码中的定时任务每 3 秒执行一次。

@Component
public class ScheduledTask {

    @Scheduled(fixedRate = 3000)
    public void scheduledTask() {
        System.out.println("任务执行时间：" + LocalDateTime.now());
    }

}

4、运行工程，项目启动和运行日志如下，可见每 3 秒打印一次日志执行记录。

Server is running ...
任务执行时间-ScheduledTask：2020-06-23T18:02:14.747
任务执行时间-ScheduledTask：2020-06-23T18:02:17.748
任务执行时间-ScheduledTask：2020-06-23T18:02:20.746
任务执行时间-ScheduledTask：2020-06-23T18:02:23.747

@Scheduled注解

在上面 Demo 中，使用了 @Scheduled(fixedRate = 3000) 注解来定义每过 3 秒执行的任务。对于 @Scheduled 的使用可以总结如下几种方式。

@Scheduled(fixedRate = 3000) 上一次开始执行时间点之后 3 秒再执行（fixedRate
属性：定时任务开始后再次执行定时任务的延时（需等待上次定时任务完成），单位毫秒）。

@Scheduled(fixedDelay = 3000) 上一次执行完毕时间点之后 3 秒再执行（fixedDelay
属性：定时任务执行完成后再次执行定时任务的延时（需等待上次定时任务完成），单位毫秒）。

@Scheduled(initialDelay = 1000, fixedRate = 3000) 第一次延迟1秒后执行，之后按
fixedRate 的规则每 3 秒执行一次（ initialDelay 属性：第一次执行定时任务的延迟时间，需配合 fixedDelay
或者 fixedRate 来使用）。

@Scheduled(cron="0 0 2 1 * ? * ") 通过 cron 表达式定义规则。

关于「Corn表达式」，将在文末介绍。

多线程执行定时任务

import org.slf4j.LoggerFactory;

@Component
public class ScheduledTask {
    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(ScheduledTask.class);

    @Scheduled(cron = "0/5 * * * * *")
    public void scheduled(){
        logger.info("使用cron---任务执行时间：{}  线程名称：{}",LocalDateTime.now(),Thread.currentThread().getName());
    }
    
    @Scheduled(fixedRate = 5000)
    public void scheduled1() {
        logger.info("fixedRate---任务执行时间：{}  线程名称：{}",LocalDateTime.now(),Thread.currentThread().getName());
    }
    @Scheduled(fixedDelay = 5000)
    public void scheduled2() {
        logger.info("fixedDelay---任务执行时间：{}  线程名称：{}",LocalDateTime.now(),Thread.currentThread().getName());
    }
}

程序输出如下。

2020-06-23 23:31:04.447  INFO 34069 : fixedRate---任务执行时间：2020-06-23T23:31:04.447  线程名称：scheduling-1
2020-06-23 23:31:04.494  INFO 34069 : fixedDelay---任务执行时间：2020-06-23T23:31:04.494  线程名称：scheduling-1
2020-06-23 23:31:05.004  INFO 34069 : 使用cron---任务执行时间：2020-06-23T23:31:05.004  线程名称：scheduling-1
2020-06-23 23:31:09.445  INFO 34069 : fixedRate---任务执行时间：2020-06-23T23:31:09.445  线程名称：scheduling-1
2020-06-23 23:31:09.498  INFO 34069 : fixedDelay---任务执行时间：2020-06-23T23:31:09.498  线程名称：scheduling-1
2020-06-23 23:31:10.003  INFO 34069 : 使用cron---任务执行时间：2020-06-23T23:31:10.003  线程名称：scheduling-1
2020-06-23 23:31:14.444  INFO 34069 : fixedRate---任务执行时间：2020-06-23T23:31:14.444  线程名称：scheduling-1
2020-06-23 23:31:14.503  INFO 34069 : fixedDelay---任务执行时间：2020-06-23T23:31:14.503  线程名称：scheduling-1
2020-06-23 23:31:15.002  INFO 34069 : 使用cron---任务执行时间：2020-06-23T23:31:15.002  线程名称：scheduling-1

可以看到，3 个定时任务都已经执行，并且使同一个线程中串行执行。当定时任务增多，如果一个任务卡死，会导致其他任务也无法执行。

因此，需要考虑多线程执行定时任务的情况。

1、创建配置类：在传统的 Spring 项目中，我们可以在 xml 配置文件添加 task 的配置，而在 Spring Boot 项目中一般使用 config 配置类的方式添加配置，所以新建一个 AsyncConfig 类。在配置类中，使用 @EnableAsync 注解开启异步事件的支持。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
@EnableAsync

public class AsyncConfig {

    private int corePoolSize = 10;
    private int maxPoolSize = 200;
    private int queueCapacity = 10;

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}

@Configuration：表明该类是一个配置类
@EnableAsync：开启异步事件的支持

2、在定时任务的类或者方法上添加 @Async 注解，表示是异步事件的定时任务。

@Component
@Async
public class ScheduledTask {
    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(ScheduledTask.class);
    

    @Scheduled(cron = "0/5 * * * * *")
    public void scheduled(){
        logger.info("使用cron  线程名称：{}",Thread.currentThread().getName());
    }
    
    @Scheduled(fixedRate = 5000)
    public void scheduled1() {
        logger.info("fixedRate--- 线程名称：{}",Thread.currentThread().getName());
    }
    @Scheduled(fixedDelay = 5000)
    public void scheduled2() {
        logger.info("fixedDelay  线程名称：{}",Thread.currentThread().getName());
    }
}

3、运行程序，控制台输出如下，可以看到，定时任务是在多个线程中执行的。

2020-06-23 23:45:08.514  INFO 34824 : fixedRate--- 线程名称：taskExecutor-1
2020-06-23 23:45:08.514  INFO 34824 : fixedDelay  线程名称：taskExecutor-2
2020-06-23 23:45:10.005  INFO 34824 : 使用cron  线程名称：taskExecutor-3

2020-06-23 23:45:13.506  INFO 34824 : fixedRate--- 线程名称：taskExecutor-4
2020-06-23 23:45:13.510  INFO 34824 : fixedDelay  线程名称：taskExecutor-5
2020-06-23 23:45:15.005  INFO 34824 : 使用cron  线程名称：taskExecutor-6

2020-06-23 23:45:18.509  INFO 34824 : fixedRate--- 线程名称：taskExecutor-7
2020-06-23 23:45:18.511  INFO 34824 : fixedDelay  线程名称：taskExecutor-8
2020-06-23 23:45:20.005  INFO 34824 : 使用cron  线程名称：taskExecutor-9

2020-06-23 23:45:23.509  INFO 34824 : fixedRate--- 线程名称：taskExecutor-10
2020-06-23 23:45:23.511  INFO 34824 : fixedDelay  线程名称：taskExecutor-1
2020-06-23 23:45:25.005  INFO 34824 : 使用cron  线程名称：taskExecutor-2

2020-06-23 23:45:28.509  INFO 34824 : fixedRate--- 线程名称：taskExecutor-3
2020-06-23 23:45:28.512  INFO 34824 : fixedDelay  线程名称：taskExecutor-4
2020-06-23 23:45:30.005  INFO 34824 : 使用cron  线程名称：taskExecutor-5

2020-06-23 23:45:33.509  INFO 34824 : fixedRate--- 线程名称：taskExecutor-6
2020-06-23 23:45:33.513  INFO 34824 : fixedDelay  线程名称：taskExecutor-7
2020-06-23 23:45:35.005  INFO 34824 : 使用cron  线程名称：taskExecutor-8

...

Cron表达式

cron 表达式是一个字符串，该字符串由 6 个空格分为 7 个域，每一个域代表一个时间含义。 通常定义 “年” 的部分可以省略，实际常用的 Cron 表达式由前 6 部分组成。格式如下：

[秒] [分] [时] [日] [月] [周] [年]

需要说明的是，Cron 表达式中，“周” 是从周日开始计算的。“周” 域上的 1 表示的是周日，7 表示周六。

Cron中的通配符

, ：指的是在两个以上的时间点中都执行。如果在 “分” 这个域中定义为 8,12,35，则表示分别在第8分，第12分，第35分执行该定时任务。

- ：指定在某个域的连续范围。如果在 “时” 这个域中定义 1-6，则表示在 1 到 6 点之每小时都触发一次，等价于 1,2,3,4,5,6。

* ：表示所有值，可解读为 “每”。 如果在 “日” 这个域中设置 *，表示每一天都会触发。

? ：表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如，要在每月的 8 号触发一个操作，但不关心是周几，我们可以这么设置 0 0 0 8 * ?。

/ ：表示触发步进(step)，“/” 前面的值代表初始值( “*” 等同 “0”)，后面的值代表偏移量，在某个域上周期性触发。比如 在 “秒” 上定义 5/10 表示从 第 5 秒开始，每 10 秒执行一次；而在“分” 上则表示从第 5 分钟开始，每 10 分钟执行一次。

L ：表示英文中的 LAST 的意思，只能在 “日” 和 “周” 中使用。在 “日” 中设置，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年), 在 “周” 上表示周六，相当于 “7” 或
“SAT”。如果在 “L” 前加上数字，则表示该数据的最后一个。例如在 “周” 上设置 “7L” 这样的格式，则表示 “本月最后一个周六”。

W ：表示离指定日期的最近那个工作日(周一至周五)触发，只能在 “日” 中使用且只能用在具体的数字之后。若在 “日” 上置 “15W”，表示离每月 15 号最近的那个工作日触发。假如 15 号正好是周六，则找最近的周五(14号)触发；如果 15 号是周未，则找最近的下周一(16号)触发；如果 15 号正好在工作日(周一至周五)，则就在该天触发。如果是 "1W"就只能往本月的下一个最近的工作日推不能跨月往上一个月推。

#： 例如，A#B 表示每月的第 B 个周的周 A（周的计数从周日开始），只能作用于 “周” 上。例如 2#3 表示在每月的第 3 个周二，5#3 表示本月第 3 周的星期四。

注意，L 用在 “周” 这个域上，每周最后一天是周六。“周” 域上的 1 表示的是周日，7 表示周六，即每周计数是从周日开始的。

---

记录文章地址：https://juejin.cn/post/6844904198752960519