springboot结束前不执行指定方法 springboot scheduled不执行

基于注解（静态）

基于注解@Scheduled，默认是单线程，开启多个任务时，任务的执行时机会受到上一个任务执行时间的影响。
例如：方法a和b，a的执行卡住了，即使时间到了b也不会执行，也是串行
//例如：方法a和b可以同时执行，但是方法a的前一次任务和后一次任务串行

@Configuration      //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling   // 2.开启定时任务
public class SaticScheduleTask {
    //3.添加定时任务
    @Scheduled(cron = "0/5 * * * * ?")
    //或直接指定时间间隔，例如：5秒
    //@Scheduled(fixedRate=5000)
    private void configureTasks() {
        System.err.println("执行静态定时任务时间: " + LocalDateTime.now());
    }
}

缺点：当我们调整了执行周期的时候，需要重启应用才能生效，这有点不方便，为了达到实时生效的效果，可以使用接口来完成定时任务。

基于接口（动态）

采用实现SchedulingConfigurer接口的形式来实现动态定时任务

从数据库获取指定时间来动态执行定时任务。

原理

@FunctionalInterface
public interface SchedulingConfigurer {
    void configureTasks(ScheduledTaskRegistrar var1);
}

实现SchedulingConfigurer接口需要重写configureTasks方法。

然后使用ScheduledTaskRegistrar调用addTriggerTask方法。

使用addTriggerTask方法就是增加一个触发任务。

public void addTriggerTask(Runnable task, Trigger trigger) {
        this.addTriggerTask(new TriggerTask(task, trigger));
    }

这个方法的参数有两个：
第一个参数task，简单解释就是我们要执行的定时时间，这个事件要实现Runnable接口，就是创建一个线程。
第二个参数trigger，就是触发器，点进Trigger这个类

public interface Trigger {
    @Nullable
    Date nextExecutionTime(TriggerContext var1);
}

nextExecutionTime就是下一次执行的时间，所以我们可以发现这个Trigger的作用就是控制下一次执行的时间。
Trigger类就是我们实现动态控制定时任务的关键！

另外CronTrigger类实现了Trigger类，
所以我们在这里查询数据库中cron表达式，赋值到这里。这样我们通过修改数据库中的cron表达式，就可以达到动态的控制定时任务的执行了。

1、导入依赖包

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>

    <dependencies>
        <dependency><!--添加Web依赖 -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency><!--添加MySql依赖 -->
             <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency><!--添加Mybatis依赖 配置mybatis的一些初始化的东西-->
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency><!-- 添加mybatis依赖 -->
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <!-- SpringBoot测试类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--	jpa		-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
	</dependencies>

2、添加数据库记录

开启本地数据库mysql，随便打开查询窗口，然后执行脚本内容，如下：

DROP DATABASE IF EXISTS `socks`;
CREATE DATABASE `socks`;
USE `SOCKS`;
DROP TABLE IF EXISTS `cron`;
CREATE TABLE `cron`  (
  `cron_id` varchar(30) NOT NULL PRIMARY KEY,
  `cron` varchar(30) NOT NULL  
);
INSERT INTO `cron` VALUES ('1', '0/5 * * * * ?');

3、创建定时器

数据库准备好数据后，开始编写定时任务，注意这里添加的是TriggerTask，目的是循环读取我们在数据库设置好的执行周期，以及执行相关定时任务的内容，具体代码如下：

@Configuration      //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling   // 2.开启定时任务
public class DynamicScheduleTask implements SchedulingConfigurer {

    @Mapper
    public interface CronMapper {
        @Select("select cron from cron limit 1")
        public String getCron();
    }
     
    @Autowired      //注入mapper
    @SuppressWarnings("all")
    CronMapper cronMapper;
     
    /**
     * 执行定时任务.
     */
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
     
        taskRegistrar.addTriggerTask(
                //1.添加任务内容(Runnable)
                () -> {
	            // 定时任务要执行的内容
	            logger.info("【-----开始执行定时任务-----】");
	            
				/**
				*  中间就是写具体的业务逻辑
				*/
				System.out.println("执行动态定时任务: " + LocalDateTime.now().toLocalTime()),
				
	            // 定时任务结束
	            logger.info("【---------------结束定时任务-------------】");
				
                //2.设置执行周期(Trigger)
                },triggerContext -> {
                    //2.1 从数据库获取执行周期
                    String cron = cronMapper.getCron();
                    //2.2 合法性校验.
                    if (StringUtils.isEmpty(cron)) {
                        // Omitted Code ..
                    }
                    //2.3 返回执行周期(Date)
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                    // 定时任务触发，可修改定时任务的执行周期
            		//CronTrigger trigger = new CronTrigger(cron);
            		//return trigger.nextExecutionTime(triggerContext);

                }
        );
    }

}

注意：如果在修改数据库时出现了错误，则定时任务会停止，即使重新修改正确后，也只能重新启动项目才能恢复。

基于注解设定多线程定时任务

方式一：

//@Component注解用于对那些比较中立的类进行注释；
//相对与在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释
@Component
@EnableScheduling   // 1.开启定时任务
@EnableAsync        // 2.开启多线程
public class MultithreadScheduleTask {
    @Async
    @Scheduled(fixedDelay = 1000)  //间隔1秒
    public void first() throws InterruptedException {
        System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
        System.out.println();
        Thread.sleep(1000 * 10);
    }
 
    @Async
    @Scheduled(fixedDelay = 2000)
    public void second() {
        System.out.println("第二个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
        System.out.println();
    }
}