1. 基于单线程的定时器——简单介绍 Timer 中的 schedule 与 scheduleAtFixedRate

1.1 前言

• Timer，一般是用来做延时的任务或者循环定时执行的任务。
  使用 Timer 的时候，必须要有一个 TimerTask 去执行任务，这是一个实现了Runnable接口的线程，run 方法里面就是我们自己定义的线程需要做的任务。

1.2 先说 schedule

• 我们简单说4种情况，其实也就两个重载方法：
• ① timer.schedule(timerTask,0);，没用延迟，立即执行task，且只执行一次，线程还在。 代码和效果直接看图
  
• ② timer.schedule(timerTask,5000);，延迟5秒执行task，且只执行一次，线程还在。代码和效果直接看图
  
• ③ timer.schedule(timerTask,0,60000);，0表示没用延迟，立即执行，然后60000表示每隔1分钟执行一次task。代码和效果直接看图
  
• ④ timer.schedule(timerTask,5000,60000);，延迟5秒后执行task,然后每隔1分钟执行一次task，代码和效果直接看图：
  

附代码：

package com.liu.susu.thread.task.timer;

import java.time.LocalDateTime;
import java.util.Timer;
import java.util.TimerTask;

/**
 * @FileName TimeTaskTest1
 * @Description
 * @Author susu
 * @date 2022-03-07
 **/
public class TimerTaskTest1 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask timerTask = new TimerTask() {//TimerTask 是实现 Runnable 接口的一个线程
            @Override
            public void run() {
                System.out.println("task-->hello world!-->"+LocalDateTime.now());
            }
        };
        System.out.println("begin-->"+LocalDateTime.now());

//        timer.schedule(timerTask,0);//没用延迟，立即执行task，且只执行一次，线程还在
//        timer.schedule(timerTask,5000);//延迟5秒执行task,，且只执行一次，线程还在
//        timer.schedule(timerTask,0,60000);//0表示没用延迟，立即执行，然后60000表示每隔1分钟执行一次task
        timer.schedule(timerTask,5000,60000);//延迟5秒后执行task,然后每隔1分钟执行一次task
    }
}

1.3 schedule 与 scheduleAtFixedRate 的区别

• 关于上述介绍的 schedule 的4种调用情况，scheduleAtFixedRate 同样也有，最终效果也是一致的，我们这里就不介绍了，说说它两不一样的地方。什么时候不一样呢？当给他们设置指定开始任务的时间时，它们的区别就有了。
  主要是 public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period) 方法 与 public void schedule(TimerTask task, Date firstTime, long period) 方法的区别。
• 我们先看官网怎么说的：
  
  
• 如果不是很明白看我们下面的效果图：
  
  

小结

• void schedule(TimerTask task, Date firstTime,long period)方法的任务的计划执行时间是从第一次实际执行任务开始计算的。
  如果执行任务的时间没有被延时，那么下一次任务的执行时间参考上一次任务的“开始”时的时间来计算
• scheduleAtFixedRate 会计算首次调用时间，在执行时会先计算出错过的时间内 task 应执行的次数，再去按设定频率去执行。
• 具体原理，还需要大家看源码分析！

附代码

package com.liu.susu.thread.task.timer;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * @FileName TimerTaskTest2
 * @Description
 * @Author susu
 * @date 2022-03-07
 **/
public class TimerTaskTest2 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task-->"+ LocalDateTime.now());
            }
        };
        Date firstDateTime = getFirstDateTime();
        System.out.println("firstDateTime-->"+firstDateTime+"<=====>now-->"+LocalDateTime.now()+"\n");
        timer.schedule(timerTask,firstDateTime,10000);
        timer.scheduleAtFixedRate(timerTask,firstDateTime,10000);
    }
    public static Date getFirstDateTime(){
        String dateStr = "2022-03-07 16:30:34";
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime localDateTime = LocalDateTime.parse(dateStr, dateTimeFormatter);
        Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
        return date;
    }

}

2. 基于多线程的定时器——ScheduledExecutorService

• ScheduledExecutorService 是一个接口，实现类是ScheduledThreadPoolExecutor，是通过 Executors 自动创建线程池的一种方式（newScheduledThreadPool 方式）
• 关于线程池的创建可以看：
  详解Java多线程之线程池.
• 关于 ScheduledThreadPoolExecutor，我们下面就简单说3个方法，完整代码如下：

package com.liu.susu.thread.task.pool;

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @FileName ScheduledThreadPoolTest
 * @Description
 * @Author susu
 * @date 2022-03-07
 **/
public class ScheduledThreadPoolTest {
    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        
        System.out.println("当前时间是-->"+LocalDateTime.now());
        
        //1.schedule--->只延迟执行，且只执行一次（不循环）
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()
                        + "-->" + LocalDateTime.now());
            }
        },5,TimeUnit.SECONDS);//推迟5秒执行

        //2.scheduleAtFixedRate 推迟执行(initialDelay=0，不推迟)，然后周期性循环执行task
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()
                        + "-->" + LocalDateTime.now());
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },5,10,TimeUnit.SECONDS);//推迟5秒执行，然后每10秒执行一次

        //3.scheduleWithFixedDelay 推迟执行(initialDelay=0，不推迟)，然后周期性循环执行task
        executorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()
                        + "-->" + LocalDateTime.now());
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },5,10,TimeUnit.SECONDS);

    }
}

2.1 executorService.schedule

• 创建并执行在给定延迟后启用的单次操作。
• 效果图：
  
• 这个没啥可说的了，上面的内容看了的，这个很好理解的，我们主要说一下 scheduleAtFixedRate 与 scheduleWithFixedDelay 的区别。

2.2 scheduleAtFixedRate 与 scheduleWithFixedDelay 区别

• 来我们，先看官方怎么说的
  
• 这是什么意思呢，我们看看下面的效果就非常明白了

2.2.1 executorService.scheduleAtFixedRate

• 效果图：
  
• 上面大概明白怎么走的了吧，区别到底在哪里，先别急，看完下面的效果就明白了！

2.2.2 executorService.scheduleWithFixedDelay

• 效果图
  
• 现在明白二者的区别了吧

2.2.3 小节

• scheduleAtFixedRate：是以固定频率来执行线程任务，固定频率的含义就是可能设定的固定间隔时间不足以完成线程任务，但是它不管，达到设定的延迟时间了就要开始执行下一次任务了。
• scheduleWithFixedDelay：不管线程任务的执行时间的长短，每次都要把任务执行完成后再延迟固定时间（设置的间隔时间）后再执行下一次的任务。

3. 基于多线程的定时器（SpringBoot）

3.1 提前了解 cron表达式和@Async异步

• 看它之前我们先了解一下 cron 表达式：
  cron表达式的详细介绍（各域说明以及举例说明）.
• 还需要了解几个注解 @Async 、 @EnableAsync、 @Scheduled、@EnableScheduling ，我们下面会用到，对这个几个注解不太了解的话，这两个注解（@Async 、 @EnableAsync ）可以看下面这篇文章：
  SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync）.

3.2 @EnableScheduling 与 @Scheduled

• 关于 @EnableScheduling ：
  在SpringBoot项目中，在启动类或者定时任务类上添加 @EnableScheduling 注解来开启对定时任务的支持。
• 关于 @Scheduled ：
  如果在定时任务类中的方法上添加 @Scheduled 注解，则该方法是声明需要执行的定时任务。
• @Scheduled 注解有几种类型参数，先截图下来，我们下面会简单根据例子介绍
  

3.3 @Scheduled 定时任务例子

• 首先启动类上添加注解 @EnableScheduling ，下面不再提醒了。
  

3.3.1 关于 cron 表达式的

• cron 表达式不是很清楚的，看我们上面提供的链接，此处不做解释了。

3.3.1.1 cron 例1–>单个任务

• 用注解 @Scheduled(cron = "0/5 * * * * ?") （每5秒执行一次），代码很简单，直接截图：
  
• 启动项目后，后台自动按cron表达式配置的执行任务，直接看运行效果：
  

（1）简单分析@Schedule默认定时任务的线程

• 观察上面的执行结果，不难发现，Spring 的 Schedule 定时任务默认是单线程的。而且是默认所有定时任务都是在一个线程中执行（下面我们有多任务的例子）！
• 这样的话，我们看到的只是代码层次的定时任务，而实际执行得过程是一个任务的开启需要等上一个任务的结束才行。尤其是当系统中有特别耗时的定时任务和执行频繁的定时任务，执行频繁的任务需要等耗时的任务执行完才能执行，你说这算什么定时任务！
• 会造成严重得后果就是如果我们有多个定时任务，一个卡死，其他全挂，嗯，就这样。
• 问题分析出来了，解决是不是就有了，对，异步多线程！

3.3.1.2 cron 例2–>多个任务（非异步）

• 用异步前，我们不妨来写两个定时任务看看效果，先看两个耗时都短的任务：
  
  很明显如果耗时短还不好观察，任务1是按定时5秒执行一次，任务2也按定时2秒执行一次，没看出来，但是能看出来是单线程的执行两个任务！。
• 再来看一个耗时长，一个频繁执行的定时任务，我们让任务1睡一下就行了。
  
  这样对比效果就很明显了吧，这明显不是我们开发中想要的实现方式，所以考虑异步，请往下…

3.3.1.3 cron 例3–>多个任务（异步@Async）

• 把上面的例子改成异步试试，很简单啥也不用，直接异步方法上加注解 @Async ，启动类加 @EnableAsync 注解即可。
  再说一下，这两个注解不太了解的，看下面文章，此处不做解释了。
  SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync）.
• 修改后的代码如下（在例子3.3.1.2上修改）：
  
• 效果如图：
  
  可以看到在耗时任务1执行的过程中并不影响任务2定时任务的执行，也不影响任务1自己的定时任务，什么意思，意思就是你可以简单理解为同我们上述2.2.1中介绍的 executorService.scheduleAtFixedRate，即以固定频率来执行线程任务，就是在我们任务1中，设定的固定间隔时间5秒，而5秒不足以完成线程任务（需要10秒完成），但是它不管，达到设定的间隔时间5秒后就要开始执行下一次的任务1了（即：开启新的线程来执行）。

3.3.1.4 cron 例4–>多个任务（异步@Async——自定义线程池）

• 3.3.1.3 中，虽然实现了异步，但是 @Async 也存在一个问题，就是默认线程池的问题，这个在这里不做介绍，上面链接的文章里已经说的很清楚，不明白的先了解一下 @Async 。
• 所以，我们用自定义线程池的方式实现异步定时任务
• 代码如下（文字代码上面链接介绍异步的文章里都有，这里截图一下看看，明白逻辑就行了）：
  
  
  
• 效果如下：
  

3.3.1.5 从配置文件读取 cron表达式 以及停掉 cron任务

• 用配置文件的形式，主要方便我们以后更改任务的执行时间等。
• 代码如图：
  
  

（1）cron 例5–>用符号 “ - ”控制停止定时任务

注意.properties 与.yml的区别写法

• ① application.properties 中的 cron 表达式不能用双引号引起，而.yml中可以用双引号引起；
  
  
• ② 在配置文件里配置让线程任务停掉，不是简单的注释掉，而是用减号符号 “-”，需注意的是两中配置文件写法不一样，yml中必须要加双引号（因为 - 在yml中是一个特殊的字符），application.properties 必须不能用双引号，这点需要注意。
  
  

（2）cron 例6–>手动控制定时任务的开启和停止

a. 分析 @EnableScheduling

• 配置之前，我们先来分析一下源码，为什么启动类上加上 @EnableScheduling 注解就开启了对定时任务的支持了呢？好奇是吧，好奇就点呗，点进去看看…
  
  
  你如果感兴趣的话，可以继续往后点，自己欣赏源码也是打发时间的一种方式，哈哈哈哈！
  快烦了吧，说这么多什么意思呢？意思就是你可以不用这个注解 @EnableScheduling 让定时任务跑起来。怎么跑，先听解释：
• 其实，任务方法上用的 @Scheduled 注解，是被一个叫做 ScheduledAnnotationBeanPostProcessor （上面最后一张截图里出现的）的类所拦截的，所以，根据源码的实现，我们也可以根据配置，决定是否创建这个 bean，如果有这个 bean ，定时任务正常执行，如果没有这个 bean，@Scheduled 就不会被拦截，那么定时任务肯定不会执行了了，嗯，就是这个道理。请往下看怎么实现：

a. 配置文件设置定时任务的开关

• 首先，启动类上的注解 @EnableScheduling 注释掉。
• 然后，配置文件添加开关，如图：
  
• 然后，接下来我们说两种方式控制这个bean的创建
• 方式一：接口 Condition 与注解 Conditional 结合
  
  两种方式说完，我们再测试效果
• 方式二：直接用注解 @ConditionalOnProperty
  
• 来，看一下效果吧，定时任务还是那两个任务
  
  
  ok了，就说这么多吧！

3.3.2 其他类型参数——简单说

• 如果目录里的 1 和 2 都看明白了，关于 @Scheduled 注解的其他参数真的没什么可说的了，比葫芦画瓢的事了，我们就简单举个例子就行了
  

4. springboot动态定时任务的实现

• 非动态，简单开关控制
  关于SpringBoot中定时任务@EnableScheduling的开关设置（针对指定的定时任务可控制）
• 动态读取配置的定时任务
  SpringBoot定时任务的动态配置处理（动态获取数据库配置的定时任务）.

5. 附项目工程代码

• clone代码在下面的链接
  由于省事，没有单独创建项目，代码就写在了之前的一个项目里，本次所有的代码（包括异步）都在如图所示的文件夹里：
  
• Csdn上项目代码：
  Java多线程之定时任务 以及 SpringBoot多线程实现定时任务.
• 码云上项目代码：
  https://gitee.com/liuersusu/springboot_jpa.
• GitHub 上项目代码：
  https://github.com/liuersusu/springboot_jpa.

SpringBoot实现用户定制的定时任务（动态定时任务）

情景

  我们知道SpringBoot能使用@Scheduled注解来进行定时任务的控制，该注解需要配合Cron表达式以及在启动类上添加@EnableScheduling注解才能使用。
  不过我们现在的假定情景并不是程序员设定的定时任务，而是用户可以在我们的网页上定制定时任务，前端将该任务的信息发送到后端后，后端可以将此任务存入数据库并在规定的时间内执行。例如用户可以设定定时任务的执行时间段，执行时刻等，并可以随时新增、删除和改变定时任务。
  接下来我们来使用SpringBoot实现这个假定情景

实现

实体类Cron

  我们需要创建实体类Cron代表定时任务，这里假设Cron有如下属性：执行时刻、任务标题、任务开始的日期、任务截止日期，以及存入数据库所需要的几个基本属性：id（作为主键）、创建时间、更新时间、状态status
  我们用一个BaseEntity来保存基本属性，Cron将继承BaseEntity，使用MyBatisPlus作为ORM框架，Cron的代码如下：

@Data
@EqualsAndHashCode(callSuper = true)
public class Cron extends BaseEntity {

	private static final long serialVersionUID = 1L;

	@NotNull(message = "执行时刻不能为空")
	private LocalTime executeTime;

	@NotBlank(message = "标题不能为空")
	private String title;

	@NotNull(message = "截止日期不能为空")
	private LocalDate deadTime;

	@NotNull(message = "开始日期不能为空")
	private LocalDate startTime;
	
}

  这里需要注意的是lombok的@Data注解相当于@Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode这5个注解的合集。
  其中，@EqualsAndHashCode注解会生成equals(Object other) 和 hashCode()方法。我们重写了equals(Object other) 和 hashCode()方法，就是为了在两个对象的属性相同时equals能返回true，认为它们两个相同。但@EqualsAndHashCode默认仅使用该类中定义的属性且不会调用父类的equals(Object other) 和 hashCode()方法。这是什么意思呢？仅使用该类中的属性，也就是如果该类的两个对象属性相同，即使这两个对象对应父类的属性不同，equals也会认为它们两个对象相同，从而返回true。默认的实现中不使用父类的属性，将会导致问题，比如，有多个类有相同的部分属性，恰好id（数据库主键）在父类中，那么就会存在部分对象在比较时，它们并不相等，却因为lombok自动生成的equals(Object other) 和 hashCode()方法判定为相等，从而导致出错。所以我们在使用@Data时同时需要加上@EqualsAndHashCode(callSuper=true)注解来解决这一问题，加上(callSuper=true)，其生成的equals(Object other) 和 hashCode()方法将调用父类的方法，也就是会考虑父类的属性。
  加上@EqualsAndHashCode(callSuper=true)就符合我们的要求了，这样即使两个Cron对象，它们的属性相同，但它们在父类中对应的主键不同，equals将认为它们是不同的对象，返回false。

  对于前端传参，我们需要进行非空验证，我们在实体类中还加入了@NotNull和@NotBlank注解，并且使用message配置提示语句。这两个注解都来自于javax.validation.constraints包，该包内还有另一个常用注解@NotEmpty，@NotEmpty 用在集合上面，一般用来校验List类型(不能注释枚举类型)，而且长度必须大于0。@NotBlank 用在String上面，一般用来校验String类型不能为空，而且调用trim()后，长度必须大于0。@NotNull 可用在所有类型上，校验是否为非null。这些注解都需要配合@Validated注解使用，从而检验Controller的入参是否符合规范，例如：

public Result save(@Validated @RequestBody Cron cron)

  Cron的父类BaseEntity的代码如下：

@Data
public class BaseEntity implements Serializable {
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;
    private LocalDateTime created;
    private LocalDateTime updated;
    private Integer status;
}

  由于实体类需要在网络中传输，所以BaseEntity需要实现Serializable接口，这里使用MyBatisPlus的@TableId注解进行属性与数据库主键的映射。

Service层：接口CronService以及其实现类CronServiceImpl

  我们需定义接口CronService来实现用户定制定时任务需求。用户能创建、删除、修改定时任务，创建任务即判断当前日期是否为既定的执行日期，若是则启动定时任务。删除任务即判断该任务是否已被启动，若是，则将其停止。修改任务即先停止该任务，再重新启动该任务。我们让CronService继承MyBatisPlus的IService接口，对应的数据库操作直接在Controller层中调用相应方法即可，我们就不需要再在CronService中定义了。于是，我们需要在CronService中定义startCron(Cron cron)、stopCron(Cron cron)、changeCron(Cron cron)三个方法，分别对应用户的创建、删除、修改定时任务操作。

public interface CronService extends IService<Cron> {

	void startCron(Cron cron);

	void stopCron(Cron cron);

	void changeCron(Cron cron);
}

  我们创建CronService的实现类CronServiceImpl来实现上述3个方法。
  对于每个定时任务，我们肯定是让线程池提供一个线程去执行它，springboot提供了ThreadPoolTaskScheduler，可以很方便地对重复执行的任务进行调度管理；相比于通过java自带的周期性任务线程池ScheduleThreadPoolExecutor，ThreadPoolTaskScheduler支持根据cron表达式创建周期性任务，这正是我们所需要的。其实ThreadPoolTaskScheduler底层也是通过线程池ScheduleThreadPoolExecutor实现的，不过多加了一些支持Cron表达式的代码。ThreadPoolTaskScheduler的核心成员变量是ScheduledExecutorService scheduledExecutor，一个 ExecutorService 可以安排任务在给定的延迟后运行，或者定期执行。ScheduledFuture表示可以取消的延迟结果动作。 通常，ScheduledFuture是使用 ScheduledExecutorService 执行任务的返回结果。

  因此，我们使用ThreadPoolTaskScheduler来启动线程，执行定时任务。但这还不够，我们有很多定时任务，我们必须保存它们的信息，以便查找，因为我们还有停止任务和更新任务操作。于是我们可以创建一个HashMap来保存定时任务的信息，key肯定是cron的id，value为ScheduledExecutorService 执行任务的返回结果ScheduledFuture。我们可以调用ScheduledFuture的cancel方法来终止任务的执行。

  接下来我们来考虑CronService接口3个方法的具体实现。对于startCron方法，我们需要避免它重复启动已经启动的任务，因此我们要先判断该任务是否已经在HashMap中，若不在，我们再去判断当前日期是否在执行日期范围内，若在，我们通过Cron的执行时刻属性构造cron表达式，创建实现了Runnable接口的内部类来实现任务要做的事，调用ThreadPoolTaskScheduler的schedule方法启动该任务，并将该任务存入HashMap中。
  对于stopCron方法，我们通过Cron的id从HashMap中查找其对应的ScheduledFuture，若不为空，则调用其cancel(true)方法停止任务，并将其从HashMap中删除。cancel方法的参数传入true会中断线程停止任务，而传入false则会让线程正常执行至完成。
  changeCron方法的实现很简单，先调用stopCron，再调用startCron即可

  CronServiceImpl的完整代码如下：

@Service
public class CronServiceImpl extends ServiceImpl<CronMapper, Cron> implements CronService {

	private Logger log = LoggerFactory.getLogger(getClass());

	@Autowired
	private ThreadPoolTaskScheduler threadPoolTaskScheduler;

	private Map<Long, ScheduledFuture<?>> futureMap = new HashMap<>();

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

	@Override
	public void startCron(Cron cron) {
		if (futureMap.containsKey(cron.getId())) {
			log.warn("已经存在重复任务，任务id:{}，任务标题：{}，任务提醒时刻：{}，任务开始时间：{}，任务截止时间：{}",
					cron.getId(), cron.getTitle(), cron.getExecuteTime(), cron.getStartTime(), cron.getDeadTime());
			return;
		}
		if (LocalDate.now().isEqual(cron.getStartTime()) || LocalDate.now().isEqual(cron.getDeadTime()) ||
				(LocalDate.now().isAfter(cron.getStartTime()) && LocalDate.now().isBefore(cron.getDeadTime()))) {
			LocalTime executeTime = cron.getExecuteTime();
			String cronExp = StringUtils.join(Integer.valueOf(executeTime.getSecond()).toString(), " ", Integer.valueOf(executeTime.getMinute()).toString()
					, " ", Integer.valueOf(executeTime.getHour()).toString(), " * * ?");
			ScheduledFuture<?> future = threadPoolTaskScheduler.schedule(new MyRunnable(cron), new CronTrigger(cronExp));
			futureMap.put(cron.getId(), future);
			log.info("启动定时任务成功，任务id:{}，任务标题：{}，任务提醒时刻：{}，任务开始时间：{}，任务截止时间：{}",
					cron.getId(), cron.getTitle(), cron.getExecuteTime(), cron.getStartTime(), cron.getDeadTime());
		}
	}

	@Override
	public void stopCron(Cron cron) {
		ScheduledFuture<?> future = futureMap.get(cron.getId());
		if (future != null) {
			future.cancel(true);
			futureMap.remove(cron.getId());
			log.info("关闭定时任务成功，任务id:{}，任务标题：{}，任务提醒时刻：{}，任务开始时间：{}，任务截止时间：{}",
					cron.getId(), cron.getTitle(), cron.getExecuteTime(), cron.getStartTime(), cron.getDeadTime());
		}

	}

	@Override
	public void changeCron(Cron cron) {
		stopCron(cron);// 先停止，在开启.
		startCron(cron);
	}
	
	private class MyRunnable implements Runnable {

		private Cron cron;

		public MyRunnable(Cron cron) {
			this.cron = cron;
		}

		@Override
		public void run() {
			// 定义任务要做的事，完成任务逻辑

		}
	}
}

  其实我们这样做还没有完成需求，因为在startCron中，只有当前时间在执行时间段内，才会创建线程去执行定时任务，这样是肯定不行的。我们还需要创建一个定时任务管理器，让它每天定时去启动数据库中尚未启动的定时任务，并删除已经过期的定时任务，防止数据积压。

定时任务管理器CronManageTask

  这时我们就需要用@Scheduled注解了，我们定义CronManageTask中的cronManage()方法，加上@Scheduled注解，让它每天定时去启动数据库中尚未启动的定时任务，并停止并删除已经过期的定时任务。
  使用@Scheduled注解需要注意几个点，一是CronManageTask需使用@Component注解，且此类中不能包含其他带任何注解的方法；二是cronManage()方法不能有参数、不能有返回值；三是需添加@EnableScheduling注解到启动类上面。
  违反上述任一点，@Scheduled注解就不会生效

  CronManageTask的代码如下：

@Component
public class CronManageTask {

	private Logger log = LoggerFactory.getLogger(getClass());

	@Autowired
	private CronService cronService;

	@Scheduled(cron = "0 0 3 * * ?")
	public void cronManage() {
		List<Cron> list = cronService.list();
		list.forEach(c -> {
			if (LocalDate.now().isAfter(c.getDeadTime())) {
				cronService.stopCron(c);
				cronService.removeById(c.getId());
				log.info("删除过期定时任务成功，任务id:{}，任务标题：{}，任务提醒时刻：{}，任务开始时间：{}，任务截止时间：{}",
						c.getId(), c.getTitle(), c.getExecuteTime(), c.getStartTime(), c.getDeadTime());
			} else {
				log.info("尝试启动尚未start的定时任务，任务id:{}，任务标题：{}，任务提醒时刻：{}，任务开始时间：{}，任务截止时间：{}",
						c.getId(), c.getTitle(), c.getExecuteTime(), c.getStartTime(), c.getDeadTime());
				cronService.startCron(c);
			}
		});
	}
}

  cron表达式"0 0 3 * * ?"表示每天凌晨3点执行。需要注意的是，@Scheduled注解的cron表达式一般都要定义在配置文件里，方便修改，使用cron = "${xiaolinbao.cron}"，并在application.yml中配置xiaolinbao.cron=0 0 3 * * ?即可。上面的代码偷懒了。

  至此，使用SpringBoot实现动态定时任务的需求就完成了

前面的章节，用户通过绑定手机号的注册为会员，并可以补充完个人信息，比如姓名、生日等信息，拿到用户的生日信息之后，就可以通过会员生日信息进行营销，此处就涉及到定时任务执行营销信息推送的问题。本篇就带你走入微服务下的定时任务的构建问题。

定时任务选型

常见的定时任务的解决方案有以下几种：

右半部分基于 Java 或 Spring 框架即可支持定时任务的开发运行，左侧部分需要引入第三方框架支持。针对不同方案，作个简单介绍

• XXL-JOB 是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。任务调度与任务执行分离，功能很丰富，在多家公司商业产品中已有应用。官方地址：https://www.xuxueli.com/xxl-job/
• Elastic-Job 是一个分布式调度解决方案，由两个相互独立的子项目 Elastic-Job-Lite 和 Elastic-Job-Cloud 组成。Elastic-Job-Lite 定位为轻量级无中心化解决方案，依赖 Zookeeper ，使用 jar 包的形式提供分布式任务的协调服务，之前是当当网 Java 应用框架 ddframe 框架中的一部分，后分离出来独立发展。
• Quartz 算是定时任务领域的老牌框架了，出自 OpenSymphony 开源组织，完全由 Java 编写，提供内存作业存储和数据库作业存储两种方式。在分布式任务调度时，数据库作业存储在服务器关闭或重启时，任务信息都不会丢失，在集群环境有很好的可用性。