Spring/SpringBoot--定时任务--@Scheduled注解--使用/用法/实例/示例/实战

快来打我* 2022-09-13 04:30 474阅读 0赞

原文网址：[Spring/SpringBoot--定时任务--@Scheduled注解--使用/用法/实例/示例/实战\_IT利刃出鞘的博客-CSDN博客][Spring_SpringBoot--_--_Scheduled_--_IT_-CSDN]

# 简介 #

**执行时间的配置**

在方法上使用@Scheduled注解来设置任务的执行时间，并且使用三种属性配置方式：

<table> 
 <tbody> 
  <tr> 
   <td><strong>项</strong></td> 
   <td><strong>fixedRate</strong></td> 
   <td><strong>fixedDelay</strong></td> 
   <td><strong>cron</strong></td> 
  </tr> 
  <tr> 
   <td>描述</td> 
   <td>每隔多少时间就启动任务，不管该任务是否启动完成</td> 
   <td>每次执行任务完成之后间隔多久再次执行该任务。</td> 
   <td>根据cron表达式执行</td> 
  </tr> 
  <tr> 
   <td>执行时机</td> 
   <td>项目启动时即开始</td> 
   <td>项目启动时即开始</td> 
   <td>根据cron表达式执行</td> 
  </tr> 
 </tbody> 
</table>

initialDelay：指定第一次执行的延时时间。如：@Scheduled(initialDelay = 1000, fixedRate = 3000) ：第一次在延迟1秒后执行，之后按fixedRate的规则每 3 秒执行一次。

**配置文件中指定cron**

假如application.yml中指定：custom.schedule.cron.task1: 0/5 \* \* \* \* \*

代码中可以这么写：@Scheduled(cron = "$\{custom.schedule.cron.task1: 0/10 \* \* \* \* \*\}")

# 基础实例 #

**前提条件**

添加SpringBoot依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

启用定时器（主类添加@EnableScheduling）

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

## **方式1：串行** ##

示例1

@Component
    public class MyTest {
        @Scheduled(cron = "0/5 * * * * *")
        public void scheduled() {
            System.out.println("this is cron");
        }
    }

示例2

@Component
    public class MyTest {
        @Scheduled(cron = "0/5 * * * * *")
        public void scheduled1() {
            System.out.println("this is cron: " + System.currentTimeMillis());
        }
    
        @Scheduled(fixedRate = 5000)
        public void scheduled2(){
            System.out.println("this is fixedRate: " + System.currentTimeMillis());
        }
    
        @Scheduled(fixedDelay = 5000)
        public void scheduled3(){
            System.out.println("this is fixedDelay: " + System.currentTimeMillis());
        }
    }

**执行结果（它们是串行执行的）**

this is cron: 1589472145001
    this is fixedRate: 1589472146341
    this is fixedDelay: 1589472146342
    this is cron: 1589472150002
    this is fixedRate: 1589472151342
    this is fixedDelay: 1589472151343
    this is cron: 1589472155001
    this is fixedRate: 1589472156342
    this is fixedDelay: 1589472156343

## **方式2：并行（多线程）** ##

传统的Spring项目中，我们可以在xml配置文件添加task的配置，而在SpringBoot项目中一般使用config配置类的方式添加配置，所以新建一个AsyncConfig类。

@Configuration
    @EnableAsync         //开启异步事件的支持
    public class AsyncConfig {
         // 此处成员变量应该使用@Value从配置中读取
        private int corePoolSize = 10;
        private int maxPoolSize = 200;
        private int queueCapacity = 10;
        @Bean
        public Executor taskExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setQueueCapacity(queueCapacity);
            executor.initialize();
            return executor;
        }
    }

然后在定时任务的类或者方法上添加@Async 。最后重启项目，每一个任务都是在不同的线程中。

## **方式3：基于接口** ##

**表结构与数据**

开启本地数据库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 * * * * ?');

![20181220161546371.png_ynotemdtimestamp_1545462152300][]

**项目中的application.yml 添加数据源**

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/socks
        username: root
        password: 123456

**创建定时器**

编写定时任务，这里添加的是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)
                    () -> System.out.println("执行动态定时任务: " + LocalDateTime.now().toLocalTime()),
                    //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);
                    }
            );
        }
    
    }

**启动测试**

启动应用后，查看控制台，打印时间是我们预期的每10秒一次：

![20181220161739406.png_ynotemdtimestamp_1545462152300][]

打开Navicat ，将执行周期修改为每6秒执行一次，如图

![20181220161905131.png_ynotemdtimestamp_1545462152300][]

如果在数据库修改时格式出现错误，则定时任务会停止，即使重新修改正确；此时只能重新启动项目才能恢复。

# 自由开启/关闭/调整 时间 #

上边的实例的定时任务在SprinBoot在启动时就启动，也可以在代码中任意启动/关闭/调整时间。如下：

package com.example.demo.task;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Date;
    import java.util.concurrent.ScheduledFuture;
    
    @RestController
    @Component
    public class TestScheduler {
        @Autowired
        private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    
        private ScheduledFuture<?> future;
    
        @Bean
        public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
            return new ThreadPoolTaskScheduler();
        }
    
        @RequestMapping("/startCron")
        public String startCron() {
    
            future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger("0/5 * * * * *"));
            System.out.println("DynamicTask.startCron()");
            return "startCron";
        }
    
        @RequestMapping("/stopCron")
        public String stopCron() {
    
            if (future != null) {
                future.cancel(true);
            }
            System.out.println("DynamicTask.stopCron()");
            return "stopCron";
        }
    
        @RequestMapping("/changeCron10")
        public String startCron10() {
    
            stopCron();// 先停止，在开启.
            future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger("*/10 * * * * *"));
            System.out.println("DynamicTask.startCron10()");
            return "changeCron10";
        }
    
        private class MyRunnable implements Runnable {
    
            @Override
            public void run() {
                System.out.println("DynamicTask.MyRunnable.run()，" + new Date());
            }
        }
    }

浏览器分别输入：[http://localhost:8080/startCron][http_localhost_8080_startCron]、[http://localhost:8080/stopCron][http_localhost_8080_startCron]

**执行结果**

.   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
     :: Spring Boot ::        (v2.3.0.RELEASE)
    
    2020-05-27 19:48:02.370  INFO 6804 --- [           main] com.example.demo.DemoApplication         : Starting DemoApplication on liu-PC with PID 6804 (E:\work\idea_proj\test-SpringBoot\target\classes started by liu in E:\work\idea_proj\test-SpringBoot)
    2020-05-27 19:48:02.373  INFO 6804 --- [           main] com.example.demo.DemoApplication         : No active profile set, falling back to default profiles: default
    2020-05-27 19:48:03.675  INFO 6804 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
    2020-05-27 19:48:03.684  INFO 6804 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
    2020-05-27 19:48:03.684  INFO 6804 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.35]
    2020-05-27 19:48:03.941  INFO 6804 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
    2020-05-27 19:48:03.941  INFO 6804 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1523 ms
    2020-05-27 19:48:04.001  INFO 6804 --- [           main] o.s.s.c.ThreadPoolTaskScheduler          : Initializing ExecutorService 'threadPoolTaskScheduler'
    2020-05-27 19:48:04.405  INFO 6804 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
    2020-05-27 19:48:04.419  INFO 6804 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 3.328 seconds (JVM running for 8.111)
    2020-05-27 19:48:39.380  INFO 6804 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
    2020-05-27 19:48:39.380  INFO 6804 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
    2020-05-27 19:48:39.405  INFO 6804 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 25 ms
    DynamicTask.startCron()
    DynamicTask.MyRunnable.run()，Wed May 27 19:48:50 CST 2020
    DynamicTask.MyRunnable.run()，Wed May 27 19:48:55 CST 2020
    DynamicTask.MyRunnable.run()，Wed May 27 19:49:00 CST 2020
    DynamicTask.MyRunnable.run()，Wed May 27 19:49:05 CST 2020
    DynamicTask.MyRunnable.run()，Wed May 27 19:49:10 CST 2020
    DynamicTask.stopCron()

# 单线程问题 #

**其他网址**

[【Spring】定时任务@Scheduled之单线程多线程问题\_Mr\_EvanChen的Blog-CSDN博客][Spring_Scheduled_Mr_EvanChen_Blog-CSDN]  
[springboot定时任务线程阻塞踩坑 - 森林木马 - 博客园][springboot_ - _ -]  
[springboot Scheduled定时器 单线程多线程实现\_NokeNoke的博客-CSDN博客\_springboot多线程实现][springboot Scheduled_ _NokeNoke_-CSDN_springboot]

## **简介** ##

@Scheduled默认是单线程执行的，如果前一个任务执行时间过长，则后一个任务会被延迟，示例如下：

**测试类**

package com.example.tmp;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    @Slf4j
    @Component
    public class MyTest {
        @Scheduled(cron = "0/1 * * * * ?")
        public void task1() {
            log.info("task1");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        @Scheduled(cron = "0/1 * * * * ?")
        public void task2() {
            log.info("task2");
        }
    }

**启动类**

package com.example;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableScheduling;
    
    @EnableScheduling
    @SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
    }

执行结果：（前一个任务执行完，才会执行下一个任务）

2021-06-09 23:20:26.006  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task1
    2021-06-09 23:20:31.021  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task2
    2021-06-09 23:20:32.007  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task1
    2021-06-09 23:20:37.020  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task2
    2021-06-09 23:20:38.015  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task1
    2021-06-09 23:20:43.017  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task2
    2021-06-09 23:20:44.013  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task1
    2021-06-09 23:20:49.027  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task2
    2021-06-09 23:20:50.014  INFO 2488 --- [   scheduling-1] com.example.tmp.MyTest                   : task1

## 解决方案 ##

**方案1：配置定时任务线程池的个数**

修改application.yml

spring.task.scheduling.pool.size = 10

或者：

@Configuration
    public class ScheduleConfig implements SchedulingConfigurer {
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
            taskRegistrar.setScheduler(Executors.newScheduledThreadPool(50));
        }
    }

**方案2：自定义定时任务的线程池**

package com.example.tmp;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.TaskScheduler;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
    
    @Configuration
    public class ScheduleConfig {
     
        /**
         * 此处方法名为Bean的名字，方法名无需固定
         * 因为是按TaskScheduler接口自动注入
         */
        @Bean
        public TaskScheduler taskScheduler(){
            // Spring提供的定时任务线程池类
            ThreadPoolTaskScheduler taskScheduler=new ThreadPoolTaskScheduler();
            //设定最大可用的线程数目
            taskScheduler.setPoolSize(10);
            return taskScheduler;
        }
    }

**不正确的方案：异步**

不要这么用：启动类加@EnableAsync，Scheduled加@Async

原因：@Async的使用场景和这个不同，用在这里并不合适，虽然也会实现多线程，但是会产生任务重复执行的问题，也会使 fixedDelay策略失效。

[Spring_SpringBoot--_--_Scheduled_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120515872
[20181220161546371.png_ynotemdtimestamp_1545462152300]: /images/20220828/b2cfe03c73384eb9a61c8271e4408c9e.png
[20181220161739406.png_ynotemdtimestamp_1545462152300]: /images/20220828/e4684eb35e0c4568911990b6d3bda5d6.png
[20181220161905131.png_ynotemdtimestamp_1545462152300]: /images/20220828/b6561ce02c204349a06da3c345115b60.png
[http_localhost_8080_startCron]: http://localhost:8080/stopCron
[Spring_Scheduled_Mr_EvanChen_Blog-CSDN]: https://blog.csdn.net/Mr_EvanChen/article/details/103408290
[springboot_ - _ -]: https://www.cnblogs.com/owenma/p/13080426.html
[springboot Scheduled_ _NokeNoke_-CSDN_springboot]: https://blog.csdn.net/NokeNoke/article/details/81362257