定时任务写法，主要是Spring task方式

三种方式

JDK自带的定时器实现

Quartz定时器实现

Spring task的任务调度

用spring task 比较多，两种方法

一种是静态写法，另一种是动态

静态写法，1、开启一个定时任务@EnableScheduing，2、在类上面注册一个组件@Component，3、@Scheduled配置在具体的定时任务方法上，并且配置时间表达式。

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

@Component
public class Task1 {
    @Scheduled(cron = "0/5 * * * * ? " )
    public void taskTest(){
        System.out.println(new Date());
    }
}

动态的方式，创建一个定时任务扔到线程池里，线程池自带一个ThreadPoolTaskScheduler线程调度，到时间就会自动回执行，执行任务也扔到线程池里

原理相当把触发器时间和线程任务 扔到线程池中，

1、创建一个线程池任务调度bean

2、实现一个线程的接口，用于执行任务

3、创建一个时间触发器trigger

4、任务调度器创建执行任务

@Component
public class TaskUtil {
    //把线程池的任务调度注入进来
    @Autowired
    ThreadPoolTaskScheduler threadPoolTaskScheduler;
    @Bean
    public ThreadPoolTaskScheduler init(){
        return new ThreadPoolTaskScheduler();
    }
    //定义一个时间的表达式
    public void addTask(String cron){
        //表达式的初始化，构造方法的参数就是时间的表达式
        //用触发器的形式new一个表达式出来
        //把触发的任务放到线程的调度里面，把执行的任务也放到线程调度里面
        Trigger trigger = new CronTrigger(cron);
        threadPoolTaskScheduler.schedule(new task2(),trigger);
    }
}

public class Task2 implements Runnable {
    @Override
    public void run() {
        System.out.println(new Date());
    }
}

@RestController
@RequestMapping("/task")
public class TaskController {
    @Autowired
    TaskUtil taskUtil;
    @RequestMapping("/add")
    public void addTask(String cron){
        String s = "0/"+cron+" * * * * ?";
        taskUtil.addTask(s);
    }
}

写法上进一步优化，在新增定时任务时加入标记，然后根据标记取消定时任务

@Data
public class Task2 implements Runnable {
    private String id;
    @Override
    public void run() {
        System.out.println(this.getId());
    }
}

@Component
public class TaskUtil {
    //把线程池的任务调度注入进来

    @Autowired
    ThreadPoolTaskScheduler threadPoolTaskScheduler;
    @Bean
    public ThreadPoolTaskScheduler init(){
        return new ThreadPoolTaskScheduler();
    }

    //定义一个时间的表达式
    //注意使用static 

    private static Map<String,ScheduledFuture<?>> scheduledFutureMap = new HashMap<>();

    public void addTask(String cron,Task2 task2){
        Trigger trigger = new CronTrigger(cron);
        ScheduledFuture<?> scheduledFuture = threadPoolTaskScheduler.schedule(task2,trigger);
        scheduledFutureMap.put(task2.getId(),scheduledFuture);
    }

    public void cancel(String flag){
        ScheduledFuture<?> scheduledFuture = scheduledFutureMap.get(flag);
        scheduledFuture.cancel(true);
    }
    public void modify(String cron,Task2 task2){
        this.cancel(task2.getId());
        this.addTask(cron,task2);
    }
}

@RestController
@RequestMapping("/task")
public class TaskController {
    @Autowired
    TaskUtil taskUtil;
    @RequestMapping("/add")
    public void addTask(String id,String cron){
        String s = "0/"+cron+" * * * * ?";
        Task2 task2 = new Task2();
        task2.setId(id);
        taskUtil.addTask(s,task2);
    }
    @RequestMapping("cancel")
    public void cancelTask(String id){
        taskUtil.cancel(id);
    }
    @RequestMapping("modify")
    public void modifyTask(String id,String cron){
        String s = "0/"+cron+" * * * * ?";
        Task2 task2 = new Task2();
        taskUtil.cancel(id);
        taskUtil.addTask(s,task2);
    }
}