springboot使用@Scheduled定时任务详解

使用@Scheduled注解

springboot使用定时任务非常方便，只需要在方法上增加@Scheduled注解即可，同时需要使用@EnableScheduling开启定时任务

1.springboot 启动类添加 @EnableScheduling 注解

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;

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

2.定义一个定时任务

@Scheduled(cron = "*/1 * * * * ?")
    public void test(){
        log.info("任务开始" + Thread.currentThread().getId());
    }

@Schedula相关参数

（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：时区，默认为当前时区

@Scheduled(fixedRate=2000)：上一次开始执行时间点后2秒再次执行；
@Scheduled(fixedDelay=2000)：上一次执行完毕时间点后2秒再次执行；
@Scheduled(initialDelay=1000, fixedDelay=2000)：第一次延迟1秒执行，然后在上一次执行完毕时间点后2秒再次执行；
@Scheduled(cron="* * * * * ?")：按cron规则执行

cron表达式详解

1. cron表达式定义

Cron表达式是一个字符串，是由空格隔开的6或7个域组成，每一个域对应一个含义（秒 分 时 日 月 星期 年）其中年是可选字段。
​​​​在线Cron表达式生成器：http://cron.qqe2.com/
但是，spring的Scheduled值支持6个域的表达式，不能设定年，超过六个则会报错。源码如下：

    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);
	}
	

2.每个域可出现的字符类型和各字符的含义

（1）各域支持的字符类型
秒：可出现", - * /“四个字符，有效范围为0-59的整数
分：可出现”, - * /“四个字符，有效范围为0-59的整数
时：可出现”, - * /“四个字符，有效范围为0-23的整数
日：可出现”, - * / ? L W C"八个字符，有效范围为0-31的整数，表示每月第几日
月：可出现", - * /“四个字符，有效范围为1-12的整数或JAN-DEc
星期：可出现”, - * / ? L C #"四个字符，有效范围为1-7的整数或SUN-SAT两个范围。1表示星期天，2表示星期一， 依次类推

（2）特殊字符含义
* : 表示匹配该域的任意值，比如在秒 *, 就表示每秒都会触发事件。
? : 只能用在每月第几天和星期两个域。表示不指定值，当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“?”；
- : 表示范围，例如在分域使用5-20，表示从5分到20分钟每分钟触发一次
/ : 表示起始时间开始触发，然后每隔固定时间触发一次，例如在分域使用5/20,则意味着5分，25分，45分，分别触发一次.
, : 表示列出枚举值。例如：在分域使用5,20，则意味着在5和20分时触发一次。
L : 表示最后，只能出现在星期和每月第几天域，如果在星期域使用1L,意味着在最后的一个星期日触发。
W : 表示有效工作日(周一到周五),只能出现在每月第几日域，系统将在离指定日期的最近的有效工作日触发事件。注意一点，W的最近寻找不会跨过月份
LW : 这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。
# : 用于确定每个月第几个星期几，只能出现在每月第几天域。例如在1#3，表示某月的第三个星期日。

（3）表达式例子
“0 0 * * * *” 表示每小时0分0秒执行一次
" */10 * * * * *" 表示每10秒执行一次
“0 0 8-10 * * *” 表示每天8，9，10点执行
“0 0/30 8-10 * * *” 表示每天8点到10点，每半小时执行
“0 0 9-17 * * MON-FRI” 表示每周一至周五，9点到17点的0分0秒执行
“0 0 0 25 12 ?” 表示每年圣诞节（12月25日）0时0分0秒执行

多个定时任务多线程处理

sprinboot的@Scheduled默认是单线程处理的，就算写多个定时任务，也是单线程来处理多个定时任务的，一个定时任务处理时间过长，会阻塞其他的定时任务，更改为多线程需增加如下配置，并指定线程池中的线程数

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.concurrent.Executors;

@Configuration
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(5));
    }
}

单个定时任务多线程处理

上面的配置只支持多个定时任务多线程处理，如果想单个定时任务也多线程处理，可以使用@Async注解异步处理方法，同时使用@EnableAsync开启异步处理

    @Scheduled(cron = "*/1 * * * * ?")
    @Async
    public void test(){
        log.info("任务开始" + Thread.currentThread().getId());
    }

缺点：默认实现 SimpleAsyncTaskExecutor 不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程（默认）

所以我们可以自定义线程池管理@Async的线程

/**
 * 自定义线程池
 *
 * 1. SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程（默认）。
 * 2. SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方
 * 3. ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类
 * 4. SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz使用，才需要使用此类
 * 5. ThreadPoolTaskExecutor ：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装
 */
@EnableAsync
@Configuration
public class ThreadPoolTaskConfigure {
    @Bean("user-taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(200);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("user-taskExecutor-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        return executor;
    }
}

使用方法

   @Scheduled(cron = "*/1 * * * * ?")
    @Async(value = "user-taskExecutor")
    public void test(){
        log.info("任务开始" + Thread.currentThread().getId());
    }

corePoolSize：核心线程数，线程池创建时初始化的线程数

maxPoolSize：最大线程数，线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程

queueCapacity：缓冲队列，用来缓冲执行任务的队列

keepAliveSeconds：允许线程的空闲时间(秒)，超过了核心线程数之外的线程，在空闲时间到达之后会被销毁

threadNamePrefix ：线程池名的前缀，设置好了之后可以方便我们定位处理任务所在的线程池

rejectedExecutionHandler：线程池对拒绝任务的处理策略，此处采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在execute方法的调用线程中运行被拒绝的任务；如果执行程序已被关闭，则会丢弃该任务

waitForTasksToCompleteOnShutdown：设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean

awaitTerminationSeconds：设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住

注意
@Async 标注的方法上 不同同时标注 @Transactional 注解，否则失效。可以在@Transactional标注的方法内部调用异步方法