# TaskDemo

**Repository Path**: BsoftGitee/task-demo

## Basic Information

- **Project Name**: TaskDemo
- **Description**: SpringBoot 中利用 ThreadPoolTaskScheduler 实现定时任务
- **Primary Language**: Java
- **License**: AFL-3.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-03-06
- **Last Updated**: 2025-03-06

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README


*SpringBoot 中利用  **ThreadPoolTaskScheduler**  实现定时任务的深度解析**
在日常java开发中,尤其是基于Spring Boot框架的项目中,定时任务的实现是不可或缺的功能之一。

今天，我们将深入讨论如何在SpringBoot中借助 ThreadPoolTaskScheduler 来实现高效的灵活的定时任务管理

ThreadPoolTaskScheduler 是Spring框架的一个强大的工具 ，它实现了TaskScheduler 接口，能够方便地用于调度的管理定时任务

ThreadPoolTaskScheduler 简介

`ThreadPoolTaskScheduler`位于 `org.springframework.scheduling.concurrent`包中，是Spring任务调度体系中的一个关键组件。

它提供了多种方法来调度任务，包括但不限于在指定时间执行一次、按照固定频率执行、以及基于Cron表达式的复杂调度策略。

ThreadPoolTaskScheduler 的核心方法

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

二 `schedule(Runnable task, Trigger trigger)`：使用动态创建的Cron表达式来触发定时任务。

三 `scheduleAtFixedRate(Runnable task, long period)`：按照固定的频率执行任务，间隔时间是从前一次任务开始到下一次任务开始。

四  `scheduleWithFixedDelay(Runnable task, long delay)`：在前一次任务完成后，延迟指定的时间再执行下一次任务。

实现步骤与代码示例

接下来，我们将通过具体的代码示例来展示如何在Spring Boot项目中集成和使用`ThreadPoolTaskScheduler`。

第一步：配置 ThreadPoolTaskScheduler Bean

首先，我们需要在Spring容器中配置一个`ThreadPoolTaskScheduler`的Bean，并设置一些关键属性，如线程池大小、线程名称前缀等。

```java
@Configuration
public class ScheduleConfig {
    //用于存放定时任务的 ScheduleFuture 对象
    public static ConcurrentHashMap<String, ScheduledFuture<?>> cache = new ConcurrentHashMap<>();
    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler(){
        ThreadPoolTaskScheduler scheduler= new ThreadPoolTaskScheduler();
        //设置线程池大小 避免单线程导致的问题
        scheduler.setPoolSize(10);
        //设置线程名称前缀 便于日志跟踪
        scheduler.setThreadNamePrefix("taskExecutor---");
        //设置关闭的等待时间
        scheduler.setAwaitTerminationSeconds(60);
        //设置关闭时是否等待任务完成
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        return scheduler;
    }
}

```

第二步：创建控制器接口

为了测试定时任务的启动和停止，我们需要创建一个控制器类，提供启动、停止单个任务和停止所有任务的接口。

```java
@RestController
public class TestController {

    @Autowired
    private DynamicTask dynamicTask;

    @RequestMapping("/start")
    public void startTask() {
        dynamicTask.startCron();

    }

    @RequestMapping("/stopById")
    public void stopById(@RequestParam String taskId) {
        dynamicTask.stop(taskId);
    }

    @RequestMapping("/stopAll")
    public void stopAll() {
        dynamicTask.stopAll();
    }

}
```

第三步：实现定时任务的核心逻辑

在`DynamicTask`类中，我们实现了定时任务的启动、停止和停止所有任务的核心逻辑。

通过`ThreadPoolTaskScheduler`来调度任务，并使用`ConcurrentHashMap`来缓存每个任务的`ScheduledFuture`对象，以便后续能够方便地停止任务。

```java
@Slf4j
@Component
public class DynamicTask {
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    //启动所有的定时任务
    public  void startCron(){
        log.info(JSON.toJSONString(getTasks()));
        if (!getTasks().isEmpty()){
            getTasks().forEach(task->{
                ScheduledFuture<?> scheduledFuture = threadPoolTaskScheduler.schedule(task,new CronTrigger(task.getCron()));
                assert scheduledFuture != null;
                ScheduleConfig.cache.put(task.getName(),scheduledFuture);
            });
        }

    }
    //停止指定id的定时任务
     public void stop(String taskId){
        ScheduledFuture<?> scheduledFuture = ScheduleConfig.cache.get(taskId);
        if (scheduledFuture !=null && !scheduledFuture.isCancelled()){
            scheduledFuture.cancel(true);
            ScheduleConfig.cache.remove(taskId);

        }
     }
     //停止所有定时任务
    public void stopAll(){
        ScheduleConfig.cache.values().forEach(scheduledFuture -> {
            if (!scheduledFuture.isCancelled()){
                scheduledFuture.cancel(true);
            }
        });
        ScheduleConfig.cache.clear();
    }
    //获取所有的需要调度的任务列表
      private List<CuntomizeTask> getTasks(){
        //模拟数据
        return Arrays.asList(
                new CuntomizeTask("任务一","0/2 * * * * ?"),
                new CuntomizeTask("任务二","0/3 * * * * ?")
        );
      }

    //自定义任务类 实现Runnable接口
    private class CuntomizeTask implements Runnable{
     private String name;

     private String cron;

     public CuntomizeTask(String name,String cron){
         this.name = name;
         this.cron = cron;

     }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getCron() {
            return cron;
        }

        public void setCron(String cron) {
            this.cron = cron;
        }

        @Override
        public void run() {
            log.info("当前任务名称:{}",name);
        }
    }


}
```



测试与验证

最后，我们启动Spring Boot应用，并通过浏览器或Postman等工具访问提供的接口来测试定时任务的启动、停止和停止所有功能。

*   • 访问`http://localhost:80/start`，观察控制台输出，应该能够看到交替执行的任务日志。
*   • 访问`http://localhost:80/stopById?taskId=任务`二，观察控制台输出，任务二的执行日志应该停止。
*   • 访问`http://localhost:80/stopAll`，观察控制台输出，所有任务的执行日志都应该停止。

通过上述步骤，我们成功地在Spring Boot项目中集成了`ThreadPoolTaskScheduler`，并实现了灵活高效的定时任务管理。