Spring Boot实现定时任务

最新推荐文章于 2024-07-02 10:45:00 发布
最新推荐文章于 2024-07-02 10:45:00 发布
阅读量2.8k 收藏 8
点赞数 2
分类专栏： Java Java 基础 SpringBoot 文章标签： 定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41835612/article/details/83738085
版权
Java 同时被 3 个专栏收录
118 篇文章 6 订阅
订阅专栏
Java 基础
69 篇文章 1 订阅
订阅专栏
SpringBoot
21 篇文章 1 订阅
订阅专栏

在应用开发中，经常都有用到在后台跑定时任务的需求。比如需要在服务后台跑一个定时任务来进行数据清理、数据定时增量同步、定时发送邮件、爬虫定时抓取等等，这种情况下，我们往往需要执行定时任务。在java中定时任务有多种实现方式，比如使用线程、使用Timer、使用ScheduledExecutorService、Spring Task等等。本文会简单讲述一下上述几种方式的实现方法。

1. 使用普通线程Thread

创建一个thread，然后让它在while循环里一直运行着，通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：

public class Task1 {
public static void main(String[] args) {
  // run in a second
  final long timeInterval = 1000;
  Runnable runnable = new Runnable() {
  public void run() {
    while (true) {
      // ------- code for task to run
      System.out.println("Hello !!");
      // ------- ends here
      try {
       Thread.sleep(timeInterval);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      }
    }
  };
  Thread thread = new Thread(runnable);
  thread.start();
  }
}

可以实现间隔一定时间执行任务的需求，但是功能比较单一，不能定时。这种方式比较简单明了，示例代码中就单独展示了。

2. Timer方式

Timer是JDK自带的java.util.Timer包中的工具类，通过调度java.util.TimerTask的方式让程序再某个时间按照某一个频度执行，一般用的较少。Timer调度任务的方法有两种，一个事schedule方法，另一个是scheduleAtFixedRate方法。先看一下Timer类中两个方法的重载方法：

S.N.方法及说明
1.void schedule(TimerTask task, long delay)
将task延迟delay毫秒后执行一次
2.void schedule(TimerTask task, Date time)
将task在time启动执行一次
3.void schedule(TimerTask task, long delay, long period)
将task延迟delay毫秒后启动，之后每隔period毫秒执行一次
4.void schedule(TimerTask task, Date firstTime, long period)
将task在firstTime启动，之后每隔period毫秒执行一次，如果firstTime小于当前时间，则立即执行任务，如果某次任务执行时间大于period，本次任务执行结束，立即执行下一次任务，之后每个任务的周期还是period，整个过程不存在追任务的行为。
5.void scheduleAtFixedRate(TimerTask task, long delay, long period)
将task延迟delay毫秒后启动，之后每隔period毫秒执行一次，使用方法和3一致
6.void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
将task在firstTime启动，之后每隔period毫秒执行一次，与方法4不同的是，如果firstTime小于当前时间，则立即执行任务，之后会存在追任务的过程，比如period为5s，基本上每个任务执行时间是3s，那剩下来的两秒不再等待，直接用来执行任务，知道某个时间点，达到预期任务执行的次数。

2.1 schedule task demo

@Component
public class ScheduleTask {
    @PostConstruct
    public void startScheduleTask(){
        Timer timer = new Timer();
        //耗时2s左右的任务
        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                //获得该任务该次执行的期望开始时间
                System.out.println("expect start time: " + new Date(scheduledExecutionTime()));
                System.out.println("task1 start: " + new Date());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println("task1 end: " + new Date());
            }
        };
        LocalDateTime localDateTime1 = LocalDateTime.now().plusSeconds(-11);
        Date date = Date.from(localDateTime1.atZone(ZoneId.systemDefault()).toInstant());

        System.out.println("now: " + new Date());
        System.out.println("timer start: " + date);
        //设置调度的启动时间为11s前
        timer.schedule(task1, date, 5000);
    }
}

设置任务启动时间为当前时间前的11S，每个任务执行时间为2S。

2.2 schedule task执行过程

now: Wed Sep 05 20:54:10 CST 2018
#设置任务启动时间为11S前
timer start: Wed Sep 05 20:53:59 CST 2018
#首次任务期望执行时间为当前，并不是11S前
expect start time: Wed Sep 05 20:54:10 CST 2018
task1 start: Wed Sep 05 20:54:10 CST 2018
task1 end: Wed Sep 05 20:54:12 CST 2018
#每次任务执行间隔为5S
expect start time: Wed Sep 05 20:54:15 CST 2018
task1 start: Wed Sep 05 20:54:15 CST 2018
task1 end: Wed Sep 05 20:54:17 CST 2018
expect start time: Wed Sep 05 20:54:20 CST 2018
task1 start: Wed Sep 05 20:54:20 CST 2018
task1 end: Wed Sep 05 20:54:22 CST 2018

2.3 scheduleAtFixedRate task demo

@Component
public class scheduleAtFixedRateTask {
    @PostConstruct
    public void startScheduleAtFixedRateTask() {
        Timer timer = new Timer();
        //耗时2s左右的任务
        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                //获得该任务该次执行的期望开始时间
                System.out.println("expect run time: " + new Date(scheduledExecutionTime()));
                System.out.println("task1 start: " + new Date());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println("task1 end: " + new Date());
            }
        };
        LocalDateTime localDateTime1 = LocalDateTime.now().plusSeconds(-11);
        Date date = Date.from(localDateTime1.atZone(ZoneId.systemDefault()).toInstant());

        System.out.println("now: " + new Date());
        System.out.println("timer start: " + date);
        //设置调度的启动时间为11s前
        timer.scheduleAtFixedRate(task1, date, 5000);
    }
}

设置任务启动时间为当前时间前的11S，每个任务执行时间为2S。

2.4 scheduleAtFixedRate task执行过程

now: Wed Sep 05 20:59:24 CST 2018
#设置任务启动时间为11S前
timer start: Wed Sep 05 20:59:13 CST 2018
#首次任务期望启动时间为11S前
expect run time: Wed Sep 05 20:59:13 CST 2018
task1 start: Wed Sep 05 20:59:24 CST 2018
task1 end: Wed Sep 05 20:59:26 CST 2018
expect run time: Wed Sep 05 20:59:18 CST 2018
#上次任务执行结束并没有接着等3秒，直接进行下一次任务
task1 start: Wed Sep 05 20:59:26 CST 2018
task1 end: Wed Sep 05 20:59:28 CST 2018
expect run time: Wed Sep 05 20:59:23 CST 2018
task1 start: Wed Sep 05 20:59:28 CST 2018
task1 end: Wed Sep 05 20:59:30 CST 2018
expect run time: Wed Sep 05 20:59:28 CST 2018
task1 start: Wed Sep 05 20:59:30 CST 2018
task1 end: Wed Sep 05 20:59:32 CST 2018
#追赶上
expect run time: Wed Sep 05 20:59:33 CST 2018
task1 start: Wed Sep 05 20:59:33 CST 2018
task1 end: Wed Sep 05 20:59:35 CST 2018
expect run time: Wed Sep 05 20:59:38 CST 2018
task1 start: Wed Sep 05 20:59:38 CST 2018
task1 end: Wed Sep 05 20:59:40 CST 2018

注意：在示例代码中，为task类添加了@Component注解，在spring启动时，会进行Bean注册，执行@PostConstruct方法，实现了任务排期。为了展现效果，可以在测试相应task的时候，把其他的task的@Component注解注释掉。

3. ScheduledThreadPoolExecutor

Timer存在一些缺陷，比如Timer运行多个TimeTask时，只要其中有一个因任务报错没有捕获抛出的异常，其它任务便会自动终止运行。jdk5之后出现了一种新的定时器工具ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，但是ScheduledThreadPoolExecutor几个构造方法中只能设置corePoolSize。它作为一个使用corePoolSize线程和一个无界队列的固定大小的线程池，调整maximumPoolSize没有效果。一个线程负责一个schedulexxx方法的执行，corePoolSize小于执行的schedulexxx方法个数时，放入任务队列。

S.N.方法及说明
1.ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
延迟delay个unit单位执行一次command,并返回一个future,该future的get只会是null
2.<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
延迟delay个unit单位执行一次callable,并返回一个future,future可以拿到callable的结果
3.ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
延迟delay个unit单位启动command，之后每period个unit单位执行一次command
4.ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
延迟delay个unit单位启动command，每个任务之间的间隔为delay个unit单位

3.1 ScheduleWithFixedDelayTask demo

@Component
public class ScheduleWithFixedDelayTask {

    @PostConstruct
    public void starkTask(){
        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                //获得该任务该次执行的期望开始时间
                System.out.println("expect start time: " + new Date(scheduledExecutionTime()));
                System.out.println("task1 start: " + new Date());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println("task1 end: " + new Date());
            }
        };

        System.out.println("now: " + new Date());
        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(2);
        executor.scheduleWithFixedDelay(task1, 0, 1000, TimeUnit.MILLISECONDS);
    }
}

3.2 ScheduleWithFixedDelayTask执行过程

now: Wed Sep 05 21:51:36 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
task1 start: Wed Sep 05 21:51:36 CST 2018
task1 end: Wed Sep 05 21:51:38 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
#下一次任务开始时间间隔了1S
task1 start: Wed Sep 05 21:51:39 CST 2018
task1 end: Wed Sep 05 21:51:41 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
task1 start: Wed Sep 05 21:51:42 CST 2018
task1 end: Wed Sep 05 21:51:44 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
task1 start: Wed Sep 05 21:51:45 CST 2018
task1 end: Wed Sep 05 21:51:47 CST 2018

另外可以发现，在ScheduleWithFixedDelayTask中，期望开始时间是不生效的。

3.3 ScheduleAtFixedRateTask demo

@Component
public class ScheduleAtFixedRateTask {
    @PostConstruct
    public void starkTask(){
        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                //获得该任务该次执行的期望开始时间
                System.out.println("expect start time: " + new Date(scheduledExecutionTime()));
                System.out.println("task2 start: " + new Date());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println("task2 end: " + new Date());
            }
        };

        System.out.println("now: " + new Date());
        ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(2);
        executor.scheduleAtFixedRate(task2, 0, 1000, TimeUnit.MILLISECONDS);
    }
}

3.2 ScheduleAtFixedRateTask执行过程

now: Wed Sep 05 21:54:37 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
task2 start: Wed Sep 05 21:54:37 CST 2018
task2 end: Wed Sep 05 21:54:39 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
task2 start: Wed Sep 05 21:54:39 CST 2018
task2 end: Wed Sep 05 21:54:41 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
task2 start: Wed Sep 05 21:54:41 CST 2018
task2 end: Wed Sep 05 21:54:43 CST 2018
expect start time: Thu Jan 01 08:00:00 CST 1970
task2 start: Wed Sep 05 21:54:43 CST 2018
task2 end: Wed Sep 05 21:54:45 CST 2018

4. Spring Task

4.1 任务定义

@Component
@Slf4j
public class SpringTask {
    @Async
    @Scheduled(cron = "0/1 * * * * *")
    public void scheduled1() throws InterruptedException {
        log.info("scheduled1 每1秒执行一次：{}", LocalDateTime.now());
        Thread.sleep(3000);
    }

    @Scheduled(fixedRate = 1000)
    public void scheduled2() throws InterruptedException {
        log.info("scheduled2 每1秒执行一次：{}", LocalDateTime.now());
        Thread.sleep(3000);
    }

    @Scheduled(fixedDelay = 3000)
    public void scheduled3() throws InterruptedException {
        log.info("scheduled3 上次执行完毕后隔3秒继续执行：{}", LocalDateTime.now());
        Thread.sleep(5000);
    }
}

这里讲解一下各个注解的含义：

@Scheduled表名方法为定时任务

  • cron：cron表达式，根据表达式循环执行，@Scheduled(cron = “0/5 * * * * *”)表示任务将在5、10、15、20…这种情况下进行工作，cron表达式可在线生成
  • fixedRate：每隔多久执行一次，@Scheduled(fixedRate = 1000) 假设第一次工作时间为2018-09-06 10:30:01，工作时长为3秒，那么下次任务的时候就是2018-09-06 10:30:04，配置成异步后，只要到了执行时间就会开辟新的线程工作；如果@Scheduled(fixedRate = 3000) 假设第一次工作时间为2018-09-06 10:30:01，工作时长为1秒，那么下次任务的时间依然是2018-09-06 10:30:04
  • fixedDelay：当前任务执行完毕后等待多久继续下次任务，@Scheduled(fixedDelay = 3000) 假设第一次任务工作时间为2018-09-06 10:30:01，工作时长为5秒，那么下次任务的时间就是2018-09-06 10:30:09
  • initialDelay：第一次执行延迟时间，只是做延迟的设定

@Async代表该任务可以进行异步工作，由原本的串行改为并行

4.2 开启线程池

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

    /**
     *默认情况下 TaskScheduler 的 poolSize = 1 多个任务的情况下，如果第一个任务没执行完毕，后续的任务将会进入等待状态
     * @return 线程池
     */
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(10);
        return taskScheduler;
    }
}
  • @EnableScheduling: 表示开启对@Scheduled注解的解析
  • @EnableAsync: 注解表示开启@Async注解的解析，将串行化的任务给并行化。比如@Scheduled(cron = “0/1 * * * * *”)第一次工作时间为2018-09-06 10:30:01，工作周期为3秒；如果不加@Async那么下一次工作时间就是2018-09-06 10:30:04。如果加了@Async下一次工作时间就是2018-09-06 10:30:02

4.3 执行结果

scheduled2 每1秒执行一次：2018-09-06T10:23:54.510
scheduled3 上次执行完毕后隔3秒继续执行：2018-09-06T10:23:54.510
#scheduled1开启异步，每秒执行一次
scheduled1 每1秒执行一次：2018-09-06T10:23:55.014
scheduled1 每1秒执行一次：2018-09-06T10:23:56.002
scheduled1 每1秒执行一次：2018-09-06T10:23:57.001
#Schedule2定义每秒执行一次，但是任务执行时间为3S，没开启异步，所以每隔3S执行一次
scheduled2 每1秒执行一次：2018-09-06T10:23:57.513
scheduled1 每1秒执行一次：2018-09-06T10:23:58.002
scheduled1 每1秒执行一次：2018-09-06T10:23:59.002
scheduled1 每1秒执行一次：2018-09-06T10:24:00.001
scheduled2 每1秒执行一次：2018-09-06T10:24:00.513
scheduled1 每1秒执行一次：2018-09-06T10:24:01
scheduled1 每1秒执行一次：2018-09-06T10:24:02.002
#scheduled3 任务执行时间5S，任务之间间隔3S，总共8S
scheduled3 上次执行完毕后隔3秒继续执行：2018-09-06T10:24:02.513
scheduled1 每1秒执行一次：2018-09-06T10:24:03.001
scheduled2 每1秒执行一次：2018-09-06T10:24:03.513
…………

示例代码：码云 – 卓立 – 定时任务

参考链接：

  1. Java实现定时任务的三种方法
  2. java定时工具的辟谣
  3. 详解java定时任务
卓立~
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ScheduledThreadPoolExecutor定时线程池不执行原因分析
05-08 3314
ScheduledThreadPoolExecutor线程不执行
Android scheduleWithFixedDelay延迟混乱
shineforZnine
03-17 817
出于timer的性能考虑，在使用viewPager+scheduleWithFixedDelay来实现自动循环滚动轮播图的时候，发现一个问题。当Activity进入onPause生命周期后，出现了轮播图延迟混乱的情况。 通过跟踪代码发现，在生命周期进入pause后，ScheduledExecutorService并没有shutdown掉，而当activity有 更新数据或重新启动executor
Spring Boot 创建定时任务
最新发布
八戒的博客
07-02 2129
通过本文的介绍和示例代码，我们了解了如何在Spring Boot中创建和管理定时任务。Spring Boot的@Scheduled注解和TaskScheduler接口为定时任务提供了强大的支持，使得开发者能够轻松实现各种定时任务的需求。无论是简单的固定间隔任务，还是复杂的Cron表达式任务，Spring Boot都能提供简洁优雅的解决方案。在实际应用中，我们可能需要更复杂的定时任务管理功能，例如动态修改任务的执行时间、任务状态监控等。定时任务是指在预定的时间间隔或特定的时间点自动执行的任务。
SpringBoot开启异步多线程
清泉影月
09-01 5891
SpringBoot 的异步多线程需要从 java 的多线程基础说起，可以参考java 多线程实现的三种方式区别。SpringBoot 在此基础上进行了多次封装，所以使用起来非常方便。
Spring 定时任务调度 TaskScheduler 和 Quartz
学长抄作业（codeying）博客codeying.top
03-25 1319
文章目录1.@Scheduled 1.@Scheduled /** * 定时任务 * cron表达式 */ @Component @EnableScheduling // 1.开启定时任务 @EnableAsync // 2.开启多线程 public class MultithreadScheduleTask { @Async //允许并发 @Scheduled(fixedDelay = 1000) //间隔1秒 public void first()
一个Java细节！
weixin_33775582的博客
03-05 143
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring boot基于ScheduledFuture实现定时任务
08-19
"Spring boot基于ScheduledFuture实现定时任务" 本文主要介绍了Spring boot基于ScheduledFuture实现定时任务的方法，通过示例代码对大家的学习或者工作具有一定的参考学习价值。 知识点一：ScheduledFuture 在...
Spring Boot中实现定时任务应用实践
08-27
在Spring Boot中，实现定时任务是一项常见的需求，它允许开发者安排特定任务在预设的时间点自动执行。Spring Boot提供了两种主要的方式来实现定时任务：使用Spring自带的定时任务调度器（Spring Task）和集成第三方...
Spring Boot定时任务的使用实例代码
08-30
在Spring Boot框架中，定时任务的实现主要依赖于Spring的`@EnableScheduling`注解和`@Scheduled`注解。这两个注解使得开发者能够方便地在Spring Boot应用中创建和管理周期性的任务。以下是对这两个核心概念的详细...
详解Spring Boot 定时任务的实现方法
08-30
Spring Boot 定时任务的实现方法 在 Spring Boot 中实现定时任务是一件相对简单的事情。Spring Boot 提供了一个非常方便的接口来实现定时任务，只需要在需要定时执行的函数前加上 @Scheduled 注解，就可以将其转换...
Spring Boot如何实现定时任务的动态增删启停详解
08-18
Spring Boot 实现定时任务的动态增删启停详解 在 Spring Boot 项目中，实现定时任务的动态增删启停是非常重要的。传统的方法是使用 Quartz 框架，但是这种方法需要依赖其它框架，可能会导致项目的臃肿和复杂。因此...
SpringBoot 中实现定时任务的几种方式
m0_71777195的博客
05-24 6062
这种方式很简单，主要就是先@EnableScheduling开启定时任务功能，然后在相应的方法上添加@Scheduled()中间写上相应的cron表达式即可。示例如下：schedule.ScheduleTask: Cron表达式参数参考：建议：直接在线生成Cron表达式比较方便：www.matools.com/cron/@Scheduled：除了支持灵活的参数表达式cron之外，还支持 fixedDelay，fixedRate，initialDelay 这些延时性的操作。启动测试就实现了基本的定时任务功
线程与进程
李晨璐的博客
01-17 525
目录 什么是进程： C#如何操作进程： 什么是线程： 解决的问题： 单线程的问题： 线程10个应用（创建，结束，终止，控制，跨线程访问，并发，线程池） 多线程的应用场景： 什么是进程： 是windows系统中的一个基本概念，他包含着一个运行程序所需要的资源。进程之间是相对独立的，一个进程无法直接访问另一个进程的数据（除非利用分布式计算方式），一个进程运行的失败也不会影响其他进程的...
不废话：拒绝kill-9，让SpringBoot优雅停机！
Java圈全能架构师的博客
10-09 1773
先来一段简单的代码，如下： @RestController public class DemoController { @GetMapping("/demo") public String demo() throws InterruptedException { // 模拟业务耗时处理流程 Thread.sleep(20 * 1000L); return "hello"; } } 当我们流量请求到此接口执行业务逻辑的时候，若服务端此时执行关机 （kill），spring bo
SpringBoot之异步调用（ThreadPoolTaskExecutor类）
songy小白的博客
07-24 420
springboot的异步调用，@Async注解
任务（springboot学习14）
m0_55972160的博客
09-01 820
异步任务 定时任务 邮件发送（常用，springboot官方） 一、异步任务 1、创建一个springboot项目，勾选web启动器依赖 2、新建一个业务 但是数据处理会线程休眠3秒，休眠期间页面会无显示 @Service//由spring托管的业务 public class AsyncService { public void hello(){ try { Thread.sleep(3000); } catch (Interru
理解ScheduledExecutorService中scheduleAtFixedRate和scheduleWithFixedDelay的区别
weixin_30908941的博客
04-28 326
scheduleAtFixedRate 每间隔一段时间执行，分为两种情况： 当前任务执行时间小于间隔时间，每次到点即执行； /** * 任务执行时间（8s）小于间隔时间(10s) */ public class ScheduleTest { static ScheduledExecutorService scheduler = Executors.newScheduledThread...
@Scheduled 定时任务不生效原因
热门推荐
Z__Sheng的博客
08-31 1万+
@Scheduled定时任务 不生效原因及解决办法1.问题描述2.问题复现3.问题解决 1.问题描述 在我们系统设计过程中，需要用到定时器，这时候我们用到了spring的Scheduled。系统逻辑为在每天的23:00:00（ @Scheduled(cron = “0 0 23 * * ?”) ）定时检测系统数据，并进行备份。用到的是cron表达式，自己测试定时器都是正常运行，可是一到测试那边定时器起作用，到了时间点一点变化都没有。 给大家安利一个在线网站，用于定时任务配置https://cron.qqe2
ScheduledExecutorService 定时任务，scheduleAtFixedRate和scheduleWithFixedDelay区别
mayi92的博客
10-01 5369
ScheduledExecutorService 定时任务，scheduleAtFixedRate和scheduleWithFixedDelay区别
spring boot实现定时任务
06-10
Spring Boot提供了很好的支持来实现定时任务。你可以使用Spring Boot内置的@Scheduled注解来实现定时任务。下面是一个简单的示例： 首先，在你的Spring Boot应用程序中添加@EnableScheduling注解： ```java @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值