使用ThreadPoolTaskScheduler实现可关闭的定时任务

需求

项目中需要按照执行时间启动指定时间间隔执行的定时任务，并在不需要时手动关闭。

在经过查找资料后发现ThreadPoolTaskScheduler是最适合的实现方式。

ThreadPoolTaskScheduler简介

包路径:

org.springframework.scheduling.concurrent

默认线程池大小:

        private volatile int poolSize = 1;

主要方法:

schedule(Runnable task, Trigger trigger),在指定时间执行一次定时任务(动态创建指定表达式cron的定时任务)

schedule(Runnable task, Date startTime),在指定时间执行一次定时任务

scheduleAtFixedRate(Runnable task, Date startTime, long period),在指定时间执行定时任务,然后以指定间隔时间执行任务，间隔时间为前一次执行开始到下次任务开始时间

scheduleAtFixedRate(Runnable task, long period),以指定间隔时间执行任务,间隔时间为前一次执行开始到下次任务开始时间

        scheduleWithFixedDelay(Runnable task, Date startTime, long delay),在指定时间执行定时任务,然后以指定间隔时间执行任务,间隔时间为前一次任务完成到下一次开始时间

scheduleWithFixedDelay(Runnable task, long delay),以指定间隔时间执行任务,间隔时间为前一次任务完成到下一次开始时间

代码实现

创建ThreadPoolTaskScheduler配置类

package org.springblade.modules.gzfw.test;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;

/**
 * 创建ThreadPoolTaskScheduler Bean
 */
@Configuration
public class ThreadPoolTaskSchedulerConfig {

    //使用线程安全map来存放线程执行情况, 方便于停止定时任务时使用
    public static ConcurrentHashMap<String, ScheduledFuture> map = new ConcurrentHashMap<String, ScheduledFuture>();

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        //线程池大小
        threadPoolTaskScheduler.setPoolSize(10);
        //线程名称前缀
        threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
        //等待时长
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        //关闭任务线程时是否等待当前被调度的任务完成
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskScheduler;
    }

}

实现逻辑代码service层

package org.springblade.modules.gzfw.test;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.thread.ThreadException;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.concurrent.ScheduledFuture;

/**
 * 测试ThreadPollTaskScheduler业务类
 */
@Service
//引用logger
@Slf4j
//引用后无需写多个@Autowired/@Resource
@AllArgsConstructor
public class ThreadPollTaskSchedulerService {

    // 注入线程池任务调度类
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    /**
     * 使用线程池启动定时任务
     *
     * @param taskName 任务名称
     */
    public void startTask(String taskName) {
        //计算20s后的时间,此计算使用hutool中的DateUtil
        DateTime date = DateUtil.date(System.currentTimeMillis() + 20 * 1000);
        //实现线程方法
        Task task2 = new Task().setTaskName(taskName);
        //放入线程池启动
        ScheduledFuture<?> schedule2 = threadPoolTaskScheduler.scheduleAtFixedRate(task2, date, 5000);
        //保存线程信息,关闭时使用
        ThreadPoolTaskSchedulerConfig.map.put(task2.getTaskName(), schedule2);
    }

    /**
     * 根据任务名称,关闭任务
     *
     * @param taskName
     */
    public void stopThreadPoolTaskScheduler(String taskName) {
        if (ThreadPoolTaskSchedulerConfig.map.containsKey(taskName)) {
            log.info("当前线程是否关闭-->" + ThreadPoolTaskSchedulerConfig.map.get(taskName).isDone());
            ThreadPoolTaskSchedulerConfig.map.get(taskName).cancel(true);
            log.info("当前线程是否关闭-->" + ThreadPoolTaskSchedulerConfig.map.get(taskName).isDone());
            ThreadPoolTaskSchedulerConfig.map.remove(taskName);
        } else {
            throw new ThreadException("要停止的任务不存在");
        }
    }

    /**
     * 定时任务类
     */
    public class Task implements Runnable {

        private String taskName;
        private Date runTime;

        public String getTaskName() {
            return taskName;
        }

        public Task setTaskName(String taskName) {
            this.taskName = taskName;
            return this;
        }

        @Override
        public void run() {
            log.info(this.taskName + "   doSomething!");
        }
    }

}

实现外部访问接口代码controller层

package org.springblade.modules.gzfw.test;

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("gzfwGsqy")
@AllArgsConstructor
@Slf4j
public class ThreadPollTaskSchedulerController {

    private ThreadPollTaskSchedulerService threadPollTaskSchedulerService;

    @PostMapping("/startTask")
    public String startTask(@RequestParam String taskName) {
        threadPollTaskSchedulerService.startTask(taskName);
        log.info("调用启动定时任务" + taskName + "完成");
        return "-----------------------------------";
    }

    @PostMapping("/stopTask")
    public String stopTask(@RequestParam String taskName) {
        threadPollTaskSchedulerService.stopThreadPoolTaskScheduler(taskName);
        log.info("调用关闭定时任务" + taskName + "完成");
        return "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&";
    }

}

测试功能,postman测试

调用启动方法,方法名为test1

调用启动方法,方法名为test2

调用关闭方法,方法名为test1

调用关闭方法,方法名为test2

结论

有效实现需求。功能实现。