boot定时任务开启和关闭 spring_Java 定时任务(含Spring定时任务)

最新推荐文章于 2024-07-25 16:26:23 发布
最新推荐文章于 2024-07-25 16:26:23 发布
阅读量1k 收藏 2
点赞数 1
文章标签： boot定时任务开启和关闭 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35997246/article/details/112179011
版权

fac477adb6de077d259a026abaceb2a6.png

1：Timer

Timer 是 JDK 自带的定时任务执行类，无论任何项目都可以直接使用 Timer 来实现定时任务，所以 Timer 的优点就是使用方便，它的实现代码如下：

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class MyTimerTask {
    public static void main(String[] args) {
        // 定义一个任务
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Run timerTask：" + new Date());
            }
        };
        // 计时器
        Timer timer = new Timer();
        // 添加执行任务（延迟 1s，每 3s 执行一次）
        timer.schedule(timerTask, 1000, 3000);
    }
}

执行结果

Run timerTask：Wed Aug 26 13:43:18 CST 2020
Run timerTask：Wed Aug 26 13:43:21 CST 2020
Run timerTask：Wed Aug 26 13:43:24 CST 2020
Run timerTask：Wed Aug 26 13:43:27 CST 2020
Run timerTask：Wed Aug 26 13:43:30 CST 2020
Run timerTask：Wed Aug 26 13:43:33 CST 2020

Timer 缺点分析：

Timer 类实现定时任务虽然方便，但在使用时需要注意以下问题。

（1）任务执行时间长影响其他任务

当一个任务的执行时间过长时，会影响其他任务的调度，如下代码所示：

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;

public class MyTimerTask {
    public static void main(String[] args) {
        // 定义任务 1
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("进入 timerTask 1：" + new Date());
                try {
                    // 休眠 5 秒
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Run timerTask 1：" + new Date());
            }
        };
        // 定义任务 2
        TimerTask timerTask2 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Run timerTask 2：" + new Date());
            }
        };
        // 计时器
        Timer timer = new Timer();
        // 添加执行任务（延迟 1s 执行，每 3s 执行一次）
        timer.schedule(timerTask, 1000, 3000);
        timer.schedule(timerTask2, 1000, 3000);
    }
}

执行结果

进入 timerTask 1：Wed Aug 26 13:57:37 CST 2020
Run timerTask 1：Wed Aug 26 13:57:42 CST 2020
Run timerTask 2：Wed Aug 26 13:57:42 CST 2020  #
进入 timerTask 1：Wed Aug 26 13:57:42 CST 2020
Run timerTask 1：Wed Aug 26 13:57:47 CST 2020
进入 timerTask 1：Wed Aug 26 13:57:47 CST 2020
Run timerTask 1：Wed Aug 26 13:57:52 CST 2020
Run timerTask 2：Wed Aug 26 13:57:52 CST 2020  #

#从上述结果中可以看出，**当任务 1 运行时间超过设定的间隔时间时，任务 2 也会延迟执行。** 原本任务 1 和任务 2 的执行时间间隔都是 3s，但因为任务 1 执行了 5s，因此任务 2 的执行时间间隔也变成了 10s（和原定时间不符）

（2）任务异常影响其他任务

使用 Timer 类实现定时任务时，当一个任务抛出异常，其他任务也会终止运行，如下代码所示：

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class MyTimerTask {
    public static void main(String[] args) {
        // 定义任务 1
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("进入 timerTask 1：" + new Date());
                // 模拟异常
                int num = 8 / 0;
                System.out.println("Run timerTask 1：" + new Date());
            }
        };
        // 定义任务 2
        TimerTask timerTask2 = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Run timerTask 2：" + new Date());
            }
        };
        // 计时器
        Timer timer = new Timer();
        // 添加执行任务（延迟 1s 执行，每 3s 执行一次）
        timer.schedule(timerTask, 1000, 3000);
        timer.schedule(timerTask2, 1000, 3000);
    }
}

执行结果

进入 timerTask 1：Wed Aug 26 13:59:45 CST 2020
Exception in thread "Timer-0" java.lang.ArithmeticException: / by zero
	at com.jiaflu.practice.javaBasic.MyTimerTask$1.run(MyTimerTask.java:16)
	at java.util.TimerThread.mainLoop(Timer.java:555)
	at java.util.TimerThread.run(Timer.java:505)

Timer 小结

  • Timer 类实现定时任务的优点是方便，因为它是 JDK 自定的定时任务，但缺点是任务如果执行时间太长或者是任务执行异常，会影响其他任务调度，所以在生产环境下建议谨慎使用。

2：scheduledExecutorService

  • ScheduledExecutorService 也是 JDK 1.5 自带的 API，我们可以使用它来实现定时任务的功能，也就是说 ScheduledExecutorService 可以实现 Timer 类具备的所有功能，并且它可以解决了 Timer 类存在的所有问题。

ScheduledExecutorService 实现定时任务的代码示例如下：

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class MyScheduledExecutorService {
    public static void main(String[] args) {
        // 创建任务队列
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(10); // 10 为线程数量
        // 执行任务
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("Run Schedule：" + new Date());
        }, 1, 3, TimeUnit.SECONDS); // 1s 后开始执行，每 3s 执行一次
    }
}

执行结果

Run Schedule：Wed Aug 26 14:08:07 CST 2020
Run Schedule：Wed Aug 26 14:08:10 CST 2020
Run Schedule：Wed Aug 26 14:08:13 CST 2020
Run Schedule：Wed Aug 26 14:08:16 CST 2020
Run Schedule：Wed Aug 26 14:08:19 CST 2020

可靠性测试:

  • 任务超时测试

ScheduledExecutorService 可以解决 Timer 任务之间相应影响的缺点，首先我们来测试一个任务执行时间过长，会不会对其他任务造成影响，测试代码如下：

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class MyScheduledExecutorService {
    public static void main(String[] args) {
        // 创建任务队列
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(10);
        // 执行任务 1
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("进入 Schedule：" + new Date());
            try {
                // 休眠 5 秒
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Run Schedule：" + new Date());
        }, 1, 3, TimeUnit.SECONDS); // 1s 后开始执行，每 3s 执行一次
        // 执行任务 2
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("Run Schedule2：" + new Date());
        }, 1, 3, TimeUnit.SECONDS); // 1s 后开始执行，每 3s 执行一次
    }
}

执行结果：

进入 Schedule：Wed Aug 26 14:12:38 CST 2020
Run Schedule2：Wed Aug 26 14:12:38 CST 2020
Run Schedule2：Wed Aug 26 14:12:41 CST 2020
Run Schedule：Wed Aug 26 14:12:43 CST 2020
进入 Schedule：Wed Aug 26 14:12:43 CST 2020
Run Schedule2：Wed Aug 26 14:12:44 CST 2020
Run Schedule2：Wed Aug 26 14:12:47 CST 2020

#从上述结果可以看出，当任务 1 执行时间 5s 超过了执行频率 3s 时，并没有影响任务 2 的正常执行，因此使用 ScheduledExecutorService 可以避免任务执行时间过长对其他任务造成的影响。
  • 任务异常测试

接下来来测试一下 ScheduledExecutorService 在一个任务异常时，是否会对其他任务造成影响，测试代码如下：

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class MyScheduledExecutorService {
    public static void main(String[] args) {
        // 创建任务队列
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(10);
        // 执行任务 1
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("进入 Schedule：" + new Date());
            // 模拟异常
            int num = 8 / 0;
            System.out.println("Run Schedule：" + new Date());
        }, 1, 3, TimeUnit.SECONDS); // 1s 后开始执行，每 3s 执行一次
        // 执行任务 2
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("Run Schedule2：" + new Date());
        }, 1, 3, TimeUnit.SECONDS); // 1s 后开始执行，每 3s 执行一次
    }
}

执行结果

Run Schedule2：Wed Aug 26 14:14:37 CST 2020
进入 Schedule：Wed Aug 26 14:14:37 CST 2020
Run Schedule2：Wed Aug 26 14:14:40 CST 2020
Run Schedule2：Wed Aug 26 14:14:43 CST 2020

#从上述结果可以看出，当任务 1 出现异常时，并不会影响任务 2 的执行。

ScheduledExecutorService 小结

  • 在单机生产环境下建议使用 ScheduledExecutorService 来执行定时任务，它是 JDK 1.5 之后自带的 API，因此使用起来也比较方便，并且使用 ScheduledExecutorService 来执行任务，不会造成任务间的相互影响。

3：Spring Task

  • 如果使用的是 Spring 或 Spring Boot 框架，可以直接使用 Spring Framework 自带的定时任务，使用上面两种定时任务的实现方式，很难实现设定了具体时间的定时任务，比如当我们需要每周五来执行某项任务时，但如果使用 Spring Task 就可轻松的实现此需求。

以 Spring Boot 为例，实现定时任务只需两步：

  1. 开启定时任务；
  2. 添加定时任务。

具体实现步骤如下。

  • 开启定时任务
@SpringBootApplication
@EnableScheduling // 开启定时任务
public class DemoApplication {
    // do someing
}
  • 添加定时任务

定时任务的添加只需要使用 @Scheduled 注解标注即可，如果有多个定时任务可以创建多个 @Scheduled 注解标注的方法，示例代码如下：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component // 把此类托管给 Spring，不能省略
public class TaskUtils {
    // 添加定时任务
    @Scheduled(cron = "59 59 23 0 0 5") // cron 表达式，每周五 23:59:59 执行
    public void doTask(){
        System.out.println("我是定时任务~");
    }
}

注意：定时任务是自动触发的无需手动干预，也就是说 Spring Boot 启动后会自动加载并执行定时任务。

Cron 表达式

  • Spring Task 的实现需要使用 cron 表达式来声明执行的频率和规则，cron 表达式是由 6 位或者 7 位组成的（最后一位可以省略），每位之间以空格分隔，每位从左到右代表的含义如下：

6f05bd009283059258cd4fc2abc2fe2d.png

其中 * 和 ? 号都表示匹配所有的时间。

3020d9bdb60a3cde0da7ee630e95a202.png

cron 表达式在线生成地址：https://cron.qqe2.com/

来来来看看
关注
Spring Boot中的@Scheduled注解：定时任务的原理与实现
02-21
### Spring Boot中的@Scheduled注解：定时任务的原理与实现 #### 一、引言 在现代软件开发中，定时任务是一种非常常见的需求。无论是数据同步、定期清理缓存还是发送提醒邮件，都需要应用程序能够在特定的时间点...
springboot自带定时器实现定时任务的开启关闭以及动态修改定时规则
热门推荐
zhiweixlw的博客
11-17 3万+
用spring自带任务调度实现 前端修改定时规则，可取消可继续的定时任务实现
SpringBoot 开启关闭自动任务配置
qq_42292373的博客
12-26 1446
文章目录1.需求2.解决方案 1.需求 可以根据自己配置的开关，动态的控制springboot含有@Scheduled的定时任务 2.解决方案 1.删除启动类的 @EnableScheduling 2.利用condition进行条件判断 public class SchedulerCondition implements Condition { @Override public ...
Java使用定时任务开始-结束活动
最新发布
ljw的博客
07-25 332
有一种场景，比如抢购活动，活动的开始肯定不是到点后手动点击开始按钮的，而是通过配置活动开始时间和结束时间，然后开启定时任务，通过定时任务来控制活动的开始和结束。
Spring-Boot 下定时任务通过配置文件控制开关和执行时间
huqiwuhuiju的博客
12-11 4410
配置文件读取cron表达式，启动定时任务 定时任务开关关键点(获取系统配置文件参数后添加：-) @Scheduled(cron = "${cron:-}") 首先配置文件添加@Scheduled注解所需的cron表达式， #系统参数 如果不启用，直接删掉即可 每个5秒 */5 * * * * ? 每日凌晨：0 0 0 * * ? platform.parameters.scheduling.tableDataMigration: */5 * * * * ? 其次，在启动类上添加启用定.
Timer任务定时器如何终止
荷塘月色
10-15 6933
在计时器结束后，我们需要通过public void cancel()来取消这个线程，不然它会一直挂起。如果需要在外面终止计时器，也可以schedule()方法外面调用这个方法。
boot定时任务开启和关闭 spring_动态控制 Spring Boot 中的 @Scheduled 定时任务
weixin_28873283的博客
01-12 5453
1. 概论Spring Boot 中的 @Scheduled 注解为定时任务提供了一种很简单的实现，只需要在注解中加上一些属性，例如 fixedRate、fixedDelay、cron(最常用)等等，并且在启动类上面加上 @EnableScheduling 注解，就可以启动一个定时任务了。但是在某些情况下，并没有这么简单，例如项目部署上线之后，我们可能会修改定时任务的执行时间，并且停止、重启定时任...
详解Spring Boot中使用@Scheduled创建定时任务
08-31
Spring Boot 中使用 @Scheduled 创建定时任务 Spring Boot 框架为我们提供了多种方式来创建定时任务，其中一种方式是使用 @Scheduled 注解。@Scheduled 是 Spring Framework 中的一种注解，用于标记需要定时执行的...
Spring boot定时任务的原理及动态创建详解
08-26
Spring Boot 是一个非常流行的 Java 框架，它提供了许多有用的功能，包括定时任务。定时任务是指在特定的时间点执行特定的任务，例如每天早上的 8 点执行某个任务。Spring Boot 提供了多种方式来实现定时任务，包括...
Spring Boot中实现定时任务应用实践
08-27
Spring Boot提供了两种主要的方式来实现定时任务：使用Spring自带的定时任务调度器（Spring Task）和集成第三方库Quartz。下面我们将深入探讨这两种方法。 首先，Spring Task是Spring框架内置的定时任务解决方案，...
Spring Boot与Kotlin定时任务的示例（Scheduling Tasks）
08-27
【Spring Boot与Kotlin定时任务】在开发基于Spring Boot的应用时，我们经常需要实现定时任务，例如定期发送通知、执行数据同步或者监控系统状态。Kotlin作为现代的 JVM 语言，与Spring Boot结合能轻松创建这类功能。...
springboot 定时任务动态启动和停止
每天进步一点
05-14 7547
这个在网上都有解决方案了，但是网上的给的解决方案夹杂了本身的业务，其实动态启动定时任务只需要关注系统启动时的动态启停，至于要不要入库，取决于自身业务情况，与解决这个问题没啥关系；ok，我来梳理下我这边理解的，我简单的就实现了，当然可以动态加更多的内容，通过这个可以简单进行封装成XXL的job，其实原理都是想通；定时任务对于大多数需求来说，@注解级别就可以了，，，但是有些需要提前用数据库配置的，，也可以通过实现 SchedulingConfigurer 这个也是可以的，配置好后重启即可；还有一些情况是需要根据
Springboot定时任务scheduled自定义开关配置
Leisurelyc的博客
06-29 2729
1. 定义scheduled配置类, 实现SchedulingConfigurer接口 package com.metarnet.kpi.scheduled; import cn.hutool.core.util.ClassLoaderUtil; import com.metarnet.kpi.dictionary.domian.SysDict; import com.metarnet.kpi.dictionary.service.SysDictService; import lombok.ext..
java定时开始和关闭_springboot自带定时器实现定时任务的开启关闭以及定时时间可以配置详解...
weixin_42133415的博客
02-26 3890
一、序言：最近项目需要用到定时任务，需要完成一个定时功能。经过了解，项目中目前实现定时任务，一般有三种选择，一是用Java自带的timer类。稍微看了一下，可以实现大部分的指定频率的任务的调度(timer.schedule())，也可以实现关闭和开启(timer.cancle)。但是用其来实现某天的某个时间或者某月的某一天调度任务有点不方便。二是采用Quartz调度器实现。这是一个功能很强大的开...
boot定时任务开启和关闭 spring_Spring之定时任务实践
weixin_34706684的博客
12-26 527
Java下的定时任务实现有Timer，Spring，QuartZ等，这里我们介绍Spring中定时任务的应用，其通过 @Scheduled 注解即可轻松实现概述Spring 的定时任务可以支持各种形式的定时调度任务。其通过加在定时方法上的 @Scheduled 注解来配置任务执行周期，还需要在SpringBoot1Application启动类上添加 @EnableScheduling 注解来使能定...
SpringBoot动态配置开启关闭定时任务（定时任务单机变集群部署也使用-不引入分布式定时任务框架场景）
海子@幸福人
02-24 2857
SpringBoot动态配置开启关闭定时任务（定时任务单机变集群部署也使用-不引入分布式定时任务框架场景）
最简单的java定时任务@Scheduled注解以及定时任务开关
qq_43907515的博客
06-09 6614
1.如何使用@Scheduled注解 2.如何设置定时任务开关
Java Timer使用介绍
「 虚幻私塾」
11-02 679
由于Timer内部仅维护一个线程来执行所有任务，所以当前一个任务耗时过长，可能会导致后一个任务的执行被延误。出现任务延误的情况下，固定延时 schedule和 固定速率 scheduleAtFixedRate 的区别就在于，schedule会顺延，而scheduleAtFixedRate会把延误任务立马补上。在网上看到几个非常恰当的例子，贴上来加深理解。例1：暑假到了老师给schedule和scheduleAtFixedRate两个同学布置作业。老师要求学生暑假每天写2页，30天后完成作业。
9.java定时器
独孤东方朔的博客
09-05 1243
java的定时器有四种实现方式。
boot定时任务开启和关闭 spring_SpringBoot中定时任务如何使用？
06-01
在 Spring Boot 中开启定时任务非常简单，只需要在应用程序中添加 `@EnableScheduling` 注解即可。然后在需要执行定时任务的方法上添加 `@Scheduled` 注解，并设置对应的时间表达式即可。 下面是一个简单的示例： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值