SpringBoot创建定时任务暂分为以下4种类型：
根据自身需要灵活使用，欢迎纠错指正补充
一、基于注解(@Scheduled)
这种方式很简单，直接上代码
package com.example.demo2.scheduled;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import java.time.LocalDateTime;
/**
* @program: demo2
* @description: 静态定时任务类，基于@Scheduled注解
* 基于注解@Scheduled默认为单线程，开启多个任务时，任务的执行时机会受上一个任务执行时间的影响。
* @author: guoxu
* @create: 2019-12-04 11:17
*/
@Configuration //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling //2.开启定时任务
public class SaticScheduleTask {
//3.添加定时任务 cron表达式
@Scheduled(cron = "0/5 * * * * ?")
//或直接指定时间间隔，例如5秒
//@Scheduled(fixedRate = 5000)
private void configureTasks() {
System.out.println("执行静态注解方式的定时任务:"+ LocalDateTime.now());
}
}
二、基于接口（SchedulingConfigurer），从数据库中读取指定时间来动态执行定时任务
1. 数据库：创建cron表，字段ID(主键)和CRON(cron表达式)，sql执行语句如下
DROP TABLE IF EXISTS `cron`;
CREATE TABLE `cron` (
`ID` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'cron表达式主键',
`CRON` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'cron表达式',
PRIMARY KEY (`ID`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
-- ----------------------------
-- Records of cron
-- ----------------------------
INSERT INTO `cron` VALUES ('1', '0/10 * * * * ?');
SET FOREIGN_KEY_CHECKS = 1;注：数据源我使用了druid+Nutz，关于数据源配置，网上有很多，不在这里赘述
2. 创建配置类，并实现SchedulingConfigurer接口，重写configureTasks执行定时任务接口
package com.example.demo2.scheduled;
import com.example.demo2.entity.Cron;
import lombok.extern.slf4j.Slf4j;
import org.nutz.dao.Dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronSequenceGenerator;
import org.springframework.scheduling.support.CronTrigger;
import java.time.LocalDateTime;
/**
* @program: demo2
* @description: 根据不同的cron表达式，动态执行定时任务
* 修改数据库cron表达式，可以自动变更时间执行，不用重启项目
* 但如果在数据库修改时格式出现错误，则定时任务会停止，即使重新修改正确；此时只能重新启动项目才能恢复
* @author: guoxu
* @create: 2019-12-04 11:47
*/
@Slf4j
@Configuration
@EnableScheduling //开启定时任务
public class DynamicScheduleTask implements SchedulingConfigurer {
@Autowired
private Dao nutzDao;
/**
* @Description: 执行定时任务
* @Param: [scheduledTaskRegistrar]
* @return: void
* @Author: guoxu
* @Date: 2019/12/4
*/
@Override
public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
scheduledTaskRegistrar.addTriggerTask(
//1.添加任务内容（Runnable)
() -> taskInfo(),
//2.设置执行周期（Trigger）
triggerContext ->{
//从数据库获取执行周期
String cron = getCron("1");
//合法性校验
if (!CronSequenceGenerator.isValidExpression(cron)){
log.error("cron表达式格式错误");
return null;
}
return new CronTrigger(cron).nextExecutionTime(triggerContext);
}
);
//完整写法
/*
//定时任务要执行的方法
Runnable task=new Runnable() {
@Override
public void run() {
System.out.println("changeTask"+new Date());
}
};
//调度实现的时间控制
Trigger trigger=new Trigger() {
@Override
public Date nextExecutionTime(TriggerContext triggerContext) {
String cron = getCron("1");
CronTrigger cronTrigger=new CronTrigger(cron);
return cronTrigger.nextExecutionTime(triggerContext);
}
};
scheduledTaskRegistrar.addTriggerTask(task, trigger);
*/
}
public String getCron(String id){
return nutzDao.fetch(Cron.class, id).getCron();
}
public void taskInfo(){
System.out.println("执行动态定时任务==>"+ LocalDateTime.now());
}
}
三、基于注解设定多线程定时任务(@Async)
package com.example.demo2.scheduled;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* @program: demo2
* @description: 基于注解设定多线程定时任务
* 由于开启了多线程，第一个任务的执行时间也不受其本身执行时间的限制，所以需要注意可能会出现重复操作导致数据异常。
* @author: guoxu
* @create: 2019-12-04 15:25
*/
//@Component注解用于对那些比较中立的类进行注释
//相对与在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释
@Component
@EnableScheduling //开启定时任务
@EnableAsync //开启定时任务
public class MultithreadScheduleTask {
@Async
@Scheduled(fixedDelay = 1000) //间隔1秒
public void first() throws InterruptedException {
System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime());
System.out.println("线程 : " + Thread.currentThread().getName());
//模拟任务执行时间
Thread.sleep(1000 * 5);
}
@Async
@Scheduled(fixedDelay = 2000)
public void second() {
System.out.println("第二个定时任务开始 : " + LocalDateTime.now().toLocalTime());
System.out.println("线程 : " + Thread.currentThread().getName());
}
}
执行结果：
可以看到，两个定时任务启用了异步多线程执行，互不影响
四、手动启动或者终止定时任务，并多线程启动定时任务
package com.example.demo2.scheduled;
import com.example.demo2.entity.Cron;
import org.nutz.dao.Dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalTime;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;
import java.util.stream.Collectors;
/**
* @program: demo2
* @description: 手动启动或者终止定时任务，多线程执行定时任务
* @author: guoxu
* @create: 2019-12-04 17:23
*/
/**
* 利用线程池实现任务调度
* Task任务调度器可以实现任务的调度和删除
* 原理:
* 实现一个类：ThreadPoolTaskScheduler线程池任务调度器，能够开启线程池进行任务调度
* ThreadPoolTaskScheduler.schedule（）方法会创建一个定时计划ScheduleFuture,
* 在这个方法中添加两个参数一个是Runable:线程接口类，和CronTrigger(定时任务触发器)
* 在ScheduleFuture中有一个cancel可以停止定时任务
*
* Scheduled Task是一种轻量级的任务定时调度器，相比于Quartz,减少了很多的配置信息，但是Scheduled Task
* 不适用于服务器集群，引文在服务器集群下会出现任务被多次调度执行的情况，因为集群的节点之间是不会共享任务信息的
* 每个节点的定时任务都会定时执行
*/
@RestController
@RequestMapping("task")
public class ControlTask {
@Autowired
private Dao nutzDao;
@Bean
public ThreadPoolTaskScheduler trPoolTaskScheduler(){
return new ThreadPoolTaskScheduler();
}
//线程池任务调度器
@Autowired
private ThreadPoolTaskScheduler threadPoolTaskScheduler;
//存放正在执行的定时计划ScheduleFuture的Map
private Map<String, ScheduledFuture<?>> taskMap = new HashMap<>();
/**
* 1.定义一个方法实现定时任务的启动
* 2.定义一个方法实现定时任务的终止
*/
/**
* 添加并启动定时任务线程
* @param name
* @return
*/
@RequestMapping("addTask")
public boolean addTask(@RequestParam String name){
// String cron = "*/3 * * * * ?";
String cron = getCron("1");
return add(name, cron);
}
/**
* 停止定时任务线程
* @param name
* @return
*/
@RequestMapping("stopTask")
public boolean stopTask(@RequestParam String name){
return stop(name);
}
/**
* 正在运行的定时任务计划名称
* @return
*/
@RequestMapping("listTask")
public String listTask(){
return taskMap.keySet().stream().map(name -> name).collect(Collectors.joining(","));
}
private boolean add(String name, String cron) {
if(null != taskMap.get(name)) {
return false;
}
ScheduledFuture<?> schedule = threadPoolTaskScheduler.schedule(new TaskRunnable(name), new CronTrigger(cron));
taskMap.put(name, schedule);
return true;
}
private boolean stop(String name) {
if(null == taskMap.get(name)) {
return false;
}
ScheduledFuture<?> scheduledFuture = taskMap.get(name);
scheduledFuture.cancel(true);
taskMap.remove(name);
return true;
}
/**
* 定义定时任务执行的方法
*
*/
public class TaskRunnable implements Runnable {
private String name;
public TaskRunnable(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(name + "---动态定时任务运行---" + LocalTime.now());
}
}
/**
* 获取cron表达式
*/
public String getCron(String id) {
return nutzDao.fetch(Cron.class, id).getCron();
}
}
来源：oschina
链接：https://my.oschina.net/u/4148675/blog/3137474