Springboot使用ThreadPoolTaskScheduler轻量级多线程定时任务框架
简介： Spring注解定时任务使用不是很灵活，如果想要灵活的配置定时任务，可以使用xxl-job 或者 quartz等定时任务框架，但是过于繁琐，可能成本较大。所以可以使用ThreadPoolTaskScheduler来灵活处理定时任务
ThreadPoolTaskScheduler是什么
ThreadPoolTaskScheduler 是 Spring Framework 中的一部分，主要用于调度任务。它基于线程池，可以处理异步任务和定时任务
主要api
- schedule(Runnable task, Trigger trigger) corn表达式，周期执行
- schedule(Runnable task, Date startTime) 定时执行
- scheduleAtFixedRate(Runnable task, Date startTime, long period)
定时周期间隔时间执行。间隔时间单位 TimeUnit.MILLISECONDS - scheduleAtFixedRate(Runnable task, long period) 间隔时间以固定速率执行。单位毫秒
固定速率执行不会管上次执行的状态如何
在使用前需要配置下ThreadPoolTaskScheduler
@Configuration
public class SchedulingTaskConfig {
@Bean(name = "myThreadPoolTaskScheduler")
public ThreadPoolTaskScheduler threadPoolTaskScheduler(){
ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
taskScheduler.setPoolSize(60);
taskScheduler.setThreadNamePrefix("task-");
taskScheduler.setAwaitTerminationSeconds(3000);
taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
return taskScheduler;
}
}
cron表达式
@Override
public String startTask() {
ScheduledFuture<?> schedule = myThreadPoolTaskScheduler.schedule(new Runnable() {
@Override
public void run() {
System.out.println("1s执行一次");
}
}, new CronTrigger("0/1 * * * * ?"));
定时执行一次
myThreadPoolTaskScheduler.schedule(new Runnable() {
@Override
public void run() {
System.out.println("定时执行3s后开始执行");
}
},new Date(System.currentTimeMillis() + 3000));
在固定时间以固定速率执行
myThreadPoolTaskScheduler.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("定时执行3s后开始执行,固定3s执行一次");
}
},new Date(System.currentTimeMillis() + 3000),3000);
任务取消
private ScheduledFuture<?> schedule ;
@Override
public String startTask() {
schedule = myThreadPoolTaskScheduler.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("定时执行3s后开始执行,固定3s执行一次");
}
}, new Date(System.currentTimeMillis() + 3000), 3000);
return "开启成功";
}
@Override
public String stopTask() {
if (schedule != null){
schedule.cancel(true);
System.out.println("任务取消成功");
return "取消成功";
}
return "取消失败";
}
实现页面控制定时任务开关
将定时任务保存到数据库中，并在页面上实现定时任务的开关，以及更新定时任务时间后重新创建定时任务
数据库实体
@TableName("task")
@Data
public class ScheduleTask {
public interface Update{};
@TableId(type = IdType.AUTO)
@NotNull(message = "任务id不能为空",groups = Update.class)
private Integer id;
@NotBlank(message = "请填写任务执行类")
@TableField("task_clazz")
private String taskClazz;
@NotBlank(message = "请填写任务执行方法")
@TableField("task_method")
private String taskMethod;
@NotBlank(message = "请填写任务执行时间，采用cron格式")
@TableField("cron")
private String cron;
@TableLogic
@TableField("status")
private Integer status;
}
contrloller
@RestController
@RequiredArgsConstructor
public class TaskManagerController {
private final TaskManagerService taskManagerService;
@PostMapping("/addTask")
public Boolean addTask(@RequestBody @Validated ScheduleTask task){
return taskManagerService.addTask(task);
}
@PostMapping("/stopTask/{id}")
public Boolean stopTask(@PathVariable Integer id){
return taskManagerService.stopTask(id);
}
}service
@Service
@Slf4j
@RequiredArgsConstructor
public class TaskManagerServiceImpl implements TaskManagerService {
private final ScheduleTaskMapper scheduleTaskMapper;
private final TaskManager taskManager;
@Override
public Boolean addTask(ScheduleTask task) {
int i = scheduleTaskMapper.insert(task);
if (i > 0){
TaskRunnable taskRunnable = new TaskRunnable(task.getTaskClazz(), task.getTaskMethod());
taskManager.addTask(String.valueOf(task.getId()),taskRunnable,task.getCron());
return true;
}
return false;
}
@Override
public Boolean stopTask(Integer id) {
int i = scheduleTaskMapper.deleteById(id);
if (i> 0){
taskManager.stopTask(String.valueOf(id));
return true;
}
return false;
}
}
TaskRunnable
通过此类获取具体的执行方法
@Slf4j
public class TaskRunnable implements Runnable{
/**
* 定时任务类
*/
private final String clazz;
/**
* 定时任务方法
*/
private final String methodName;
public TaskRunnable(String clazz, String methodName) {
this.clazz = clazz;
this.methodName = methodName;
}
@Override
public void run() {
try {
//获取类
Object bean = SpringContextUtils.getBean(clazz);
//获取方法
Method method = bean.getClass().getDeclaredMethod(methodName);
//设置方法可用
ReflectionUtils.makeAccessible(method);
//执行方法
method.invoke(bean);
} catch (Exception e) {
log.error("获取方法信息报错：{}",e.getMessage());
throw new RuntimeException(e);
}
}
}
任务调度类
@Component
@RequiredArgsConstructor
@Slf4j
public class TaskManager {
private final ThreadPoolTaskScheduler myThreadPoolTaskScheduler;
public static ConcurrentHashMap<String, ScheduledFuture<?>> cache = new ConcurrentHashMap<>();
/**
* 创建定时任务
* @param key 任务key
* @param taskRunnable 当前线程
* @param cron 定时任务cron
*/
public void addTask(String key ,TaskRunnable taskRunnable ,String cron){
//取消任务
this.stopTask(key);
ScheduledFuture<?> schedule = myThreadPoolTaskScheduler.schedule(taskRunnable, new CronTrigger(cron));
if (schedule != null){
cache.put(key,schedule);
log.info("当key为{}的定时任务创建成功",key);
}
}
public void stopTask(String key){
if (cache.get(key) == null){
log.info("当前没有key为{}的定时任务",key);
return;
}
ScheduledFuture<?> scheduledFuture = cache.get(key);
if (scheduledFuture != null){
scheduledFuture.cancel(true);
cache.remove(key);
log.info("当前key为{}的定时任务已取消",key);
}
}
}
工具类
@Component
public class SpringContextUtils implements ApplicationContextAware {
private static ApplicationContext context;
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
SpringContextUtils.context = applicationContext;
}
public static Object getBean(String name){
return context.getBean(name);
}
}方法测试
@Slf4j
@Component(value = "testTask")
public class TestTask {
public void taskMethod(){
log.info(String.format("调用了当前定时任务"));
}
}
