精华内容
下载资源
问答
  • java定时任务如何测试
    千次阅读
    2021-03-16 11:17:23

    1 packagecom.hfepc.job.dataCollection.test;2

    3 importjava.util.Date;4 importjava.util.List;5 importjava.util.Map;6 importjava.util.Timer;7 importjava.util.TimerTask;8 importjava.util.concurrent.CountDownLatch;9

    10 importjavax.annotation.Resource;11

    12 importorg.junit.Test;13 importorg.junit.runner.RunWith;14 importorg.pentaho.di.job.Job;15 importorg.slf4j.Logger;16 importorg.slf4j.LoggerFactory;17 importorg.springframework.test.context.ActiveProfiles;18 importorg.springframework.test.context.ContextConfiguration;19 importorg.springframework.test.context.transaction.TransactionConfiguration;20 importorg.springframework.transaction.annotation.Transactional;21

    22 importcom.hfepc.service.dataCollection.IDataCollectionService;23 importcom.hfepc.service.zkinsp.MySpringJUnit4ClassRunner;24

    25 @SuppressWarnings("unused")26 @RunWith(MySpringJUnit4ClassRunner.class)27 @ContextConfiguration(locations = { "classpath*:spring-context.xml",28 "classpath*:spring-servlet.xml", "classpath*:cxf-client.xml"})29 @ActiveProfiles("development")30 @Transactional31 @TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = false)32 public class DataCollectionTest extendsJob {33

    34 private final Logger log =LoggerFactory35 .getLogger(DataCollectionTest.class);36

    37 @Resource(name = "IDataCollectionService")38 privateIDataCollectionService IDataCollectionService;39

    40 private final int i = 3;41 /*

    42 * 线程计数器43 * 将线程数量初始化44 * 每执行完成一条线程,调用countDown()使计数器减145 * 主线程调用方法await()使其等待,当计数器为0时才被执行46 */

    47 private final CountDownLatch latch = newCountDownLatch(i);48

    49 @Test50 public voidcreateTest() {51 Timer timer;52 timer = newTimer();53 timer.schedule(new TimerTaskTest03(), 0, 60000);54 //三个参数55 //第一个执行内容:内容是定时任务的执行内容,通过实现抽象类来完成这个动作56 //第二个参数内容:是在第多少时间之后开始执行定时任务内容,该参数不能小于057 //第三个参数内容:是在两个任务之间的执行时间间隔,该参数不能小于等于0

    58 try{59 latch.await(); //主线程等待

    60 } catch(InterruptedException e) {61 e.printStackTrace();62 }70

    91 private class TimerTaskTest03 extendsTimerTask {92

    93 @Override94 public voidrun() {95 Date date1 = new Date(this.scheduledExecutionTime());96 String date = DateUtils.format(DateUtils.getCurDate(),97 "yyyy/MM/dd");99 log.error("本次执行该线程的时间为:" +date1);100 log.info("时间:" +date);101 String sql = "SELECT A.[Date] AS 'date_sta',A.barcode1 AS 'barcode1_sta',A.barcode2 AS 'barcode2_sta',A.HeightNum1Range AS 'HeightNum1Range',A.HeightNum2Range AS 'HeightNum2Range',A.HeightNum3Range AS 'HeightNum3Range',A.HeightData AS 'HeightData',A.HeightDL AS 'HeightDL',A.Num AS 'Num',A.CCDFlag AS 'CCDFlag',A.barcode3 AS 'barcode3',A.PressData AS 'PressData',B.SpurtData AS 'SpurtData',B.[Date] AS 'date_glu',B.CCDODRange AS 'CCDODRange',B.CCDODValue AS 'CCDODValue',B.CCDODFlag AS 'CCDODFlag',B.CCDConcentricityRange AS 'CCDConcentricityRange',B.CCDConcentricityValue AS 'CCDConcentricityValue',B.CCDConcentricityFlag AS 'CCDConcentricityFlag',B.barcode2 AS 'barcode2_glu',B.Static AS 'Static',B.SheetIron AS 'SheetIron',B.VerticalityFlag AS 'VerticalityFlag',B.TorsionData AS 'TorsionData' FROM[dbo].[StaticComponentsProductionData] A LEFT JOIN [dbo].[GlueDispenserProductionData] B ON A.barcode1 = B.barcode1 WHERE A.[Date] LIKE '"

    102 + date + "%'";103 List> rows =IDataCollectionService104 .readSQLData(sql);105 log.info("返回标签:" +rows.size());106 log.info("返回标签:" + (String) rows.get(0).get("barcode2_sta"));

    108 }109 }110

    111 }

    更多相关内容
  • 1. SpringBoot 自定义线程池以及多线程间的异步调用(@Async、@EnableAsync) 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
  • java基础教程介绍定时任务在实际的开发日子匆匆穿过我而行,奔向海洋。定时任务在实际的开发中特别常见,比如电商平台 30 分钟后自动取消未支付的订单,以及凌晨的数据汇总和备份等,都需要借助定时任务来实现,那么...

    java基础教程介绍定时任务在实际的开发

    ac0f99d16a23c5bc7c4ff4980e906ad3.png

    日子匆匆穿过我而行,奔向海洋。

    定时任务在实际的开发中特别常见,比如电商平台 30 分钟后自动取消未支付的订单,以及凌晨的数据汇总和备份等,都需要借助定时任务来实现,那么我们本文就来看一下定时任务最简单的几种实现方式。

    TOP 1:Timer

    Timer 是 JDK 自带的定时任务执行类,无论任何项目都可以直接使用 Timer 来实现定时任务,所以 Timer 的优点就是使用方便,它的实现代码如下: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:Mon Aug 17 21:29:25 CST 2020

    Run timerTask:Mon Aug 17 21:29:28 CST 2020

    Run timerTask:Mon Aug 17 21:29:31 CST 2020

    Timer 缺点分析

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

    问题 1:任务执行时间长影响其他任务

    当一个任务的执行时间过长时,会影响其他任务的调度,如下代码所示: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:Mon Aug 17 21:44:08 CST 2020

    Run timerTask 1:Mon Aug 17 21:44:13 CST 2020

    Run timerTask 2:Mon Aug 17 21:44:13 CST 2020

    进入 timerTask 1:Mon Aug 17 21:44:13 CST 2020

    Run timerTask 1:Mon Aug 17 21:44:18 CST 2020

    进入 timerTask 1:Mon Aug 17 21:44:18 CST 2020

    Run timerTask 1:Mon Aug 17 21:44:23 CST 2020

    Run timerTask 2:Mon Aug 17 21:44:23 CST 2020

    进入 timerTask 1:Mon Aug 17 21:44:23 CST 2020

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

    问题 2:任务异常影响其他任务

    使用 Timer 类实现定时任务时,当一个任务抛出异常,其他任务也会终止运行,如下代码所示: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:Mon Aug 17 22:02:37 CST 2020

    Exception in thread "Timer-0" java.lang.ArithmeticException: / by zero

    at com.example.MyTimerTask$1.run(MyTimerTask.java:21)

    at java.util.TimerThread.mainLoop(Timer.java:555)

    at java.util.TimerThread.run(Timer.java:505)

    Process finished with exit code 0

    Timer 小结

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

    TOP 2:ScheduledExecutorService

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

    ScheduledExecutorService 实现定时任务的代码示例如下: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:Mon Aug 17 21:44:23 CST 2020

    Run Schedule:Mon Aug 17 21:44:26 CST 2020

    Run Schedule:Mon Aug 17 21:44:29 CST 2020

    ScheduledExecutorService 可靠性测试

    ① 任务超时执行测试

    ScheduledExecutorService 可以解决 Timer 任务之间相应影响的缺点,首先我们来测试一个任务执行时间过长,会不会对其他任务造成影响,测试代码如下: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 执行一次

    }

    }

    程序执行结果如下:Run Schedule2:Mon Aug 17 11:27:55 CST 2020

    进入 Schedule:Mon Aug 17 11:27:55 CST 2020

    Run Schedule2:Mon Aug 17 11:27:58 CST 2020

    Run Schedule:Mon Aug 17 11:28:00 CST 2020

    进入 Schedule:Mon Aug 17 11:28:00 CST 2020

    Run Schedule2:Mon Aug 17 11:28:01 CST 2020

    Run Schedule2:Mon Aug 17 11:28:04 CST 2020

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

    ② 任务异常测试

    接下来我们来测试一下 ScheduledExecutorService 在一个任务异常时,是否会对其他任务造成影响,测试代码如下: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 执行一次

    }

    }

    程序执行结果如下:进入 Schedule:Mon Aug 17 22:17:37 CST 2020

    Run Schedule2:Mon Aug 17 22:17:37 CST 2020

    Run Schedule2:Mon Aug 17 22:17:40 CST 2020

    Run Schedule2:Mon Aug 17 22:17:43 CST 2020

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

    ScheduledExecutorService 小结

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

    TOP 3:Spring Task

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

    以 Spring Boot 为例,实现定时任务只需两步:开启定时任务;

    添加定时任务。

    具体实现步骤如下。

    ① 开启定时任务

    开启定时任务只需要在 Spring Boot 的启动类上声明 @EnableScheduling 即可,实现代码如下:@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 位组成的(最后一位可以省略),每位之间以空格分隔,每位从左到右代表的含义如下:

    a97c206f56385571c2f1b0f571e90bc7.png

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

    ead907b78c43917677353455abb3e804.png

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

    展开全文
  • 自留demo,java定时任务quartz的基本实现,对应博客https://blog.csdn.net/jing12062011/article/details/82758536
  • java定时任务,每天定时执行任务,每天到这个时间点都会执行
  • 定时任务测试样例

    2018-06-04 16:00:31
    一个测试工具,定时任务相关的。采用 springboot和quartz结合的方式,实现前台控制后台的定时任务。可以新增/删除/修改/启动/暂停/查询后台定时任务
  • java 定时任务及jar包

    2017-07-20 10:22:03
    定时启动任务 或者项目启动时启动
  • 在web开发中我们经常需要定时完成一些功能比如定义统计报表啊统计用户排名等等利用spring就可以轻松地做到这些任务下面我就以定时发送邮件来来展示如何利用spring定时发送邮件以及spring对JavaMail的简化 ...
  • java定时任务,每天定时执行任务.java定时任务,每天定时执行任务.
  • java定时任务

    2018-10-23 08:45:35
    java代码实现的定时任务
  • Java定时任务调度框架

    千次阅读 2022-04-14 13:08:49
    Java定时任务调度框架1. 定时任务调度概述1.1 业务场景概述1.2 任务调度场景1.3 调度任务分类2. 定时任务调度详解2.1 Timer2.2 ScheduledExecutorService2.3 SpringTask2.4 Quartz2.5 xxl-job2.6 elastic-job 1. ...

    1. 定时任务调度概述

    1.1 业务场景概述

    日常开发中定时任务使用场景很多,比如支付系统每天凌晨定时清算对账;未支付订单超时回收;商品定时上下架等等。定时任务框架选择有很多,面对不同的业务场景可以选择不同的定时任务框架,比如操作系统自带的定时任务Linux的crontab,Windows的任务计划等,在某些相对简单的场景下也是可以使用的,这里就不在详细探讨,本文主要讲述Java框架下的定时任务框架。

    1.2 任务调度场景

    时间驱动/事件驱动:内部系统一般可以通过时间来驱动,但涉及到外部系统,则只能使用时间驱动。如怕取外部网站价格,每小时爬一次。

    批量处理/逐条处理:批量处理堆积的数据更加高效,在不需要实时性的情况下比消息中间件更有优势。而且有的业务逻辑只能批量处理。如移动每个月结算我们的话费。

    实时性/非实时性:消息中间件能够做到实时处理数据,但是有些情况下并不需要实时,比如:vip升级。

    系统内部/系统解耦:定时任务调度一般是在系统内部,而消息中间件可用于两个系统间。

    1.3 调度任务分类

    1.单机定时任务
    timer:是一个定时器类,通过该类可以为指定的定时任务进行配置。TimerTask类是一个定时任务类,该类实现了Runnable接口,缺点异常未检查会中止线程。

    ScheduledExecutorService:相对延迟或者周期作为定时任务调度,缺点没有绝对的日期或者时间。

    springTask:配置简单功能较多,如果系统使用单机的话可以优先考虑spring定时器。

    2.分布式定时任务
    Quartz:Java事实上的定时任务标准。但Quartz关注点在于定时任务而非数据,并无一套根据数据处理而定制化的流程。虽然Quartz可以基于数据库实现作业的高可用,但缺少分布式并行调度的功能。
    Quartz官方网址:http://www.quartz-scheduler.org/
    Quartz官方文档:http://www.quartz-scheduler.org/documentation/
    Quartz原码地址:https://github.com/quartz-scheduler/quartz

    xxl-job:是大众点评员工徐雪里于2015年发布的分布式任务调度平台,是一个轻量级分布式任务调度框架,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。产品功能丰富,开箱即用。
    xxl-job 社区地址: https://www.xuxueli.com/xxl-job/
    xxl-job github地址:https://github.com/xuxueli/xxl-job/
    xxl-job gitee地址: https://gitee.com/xuxueli0323/xxl-job

    elastic-job:当当开源的弹性分布式任务调度系统,目前赠送给Apache开源基金会。
    ElasticJob 是一个分布式调度解决方案,由 2 个相互独立的子项目 ElasticJob-Lite 和 ElasticJob-Cloud 组成。
    ElasticJob-Lite 定位为轻量级无中心化解决方案,使用jar的形式提供分布式任务的协调服务;
    ElasticJob-Cloud 使用 Mesos 的解决方案,额外提供资源治理、应用分发以及进程隔离等服务。
    ElasticJob 的各个产品使用统一的作业 API,开发者仅需要一次开发,即可随意部署。
    elastic-job文档地址:https://shardingsphere.apache.org/elasticjob/index_zh.html

    SchedulerX:分布式任务调度SchedulerX是阿里巴巴自研的基于Akka架构的分布式任务调度平台,兼容开源XXL-JOB、ElasticJob,支持Cron定时、一次性任务、任务编排、分布式执行批量任务等功能,具备高可用、可视化、可运维、低延时等能力。
    SchedulerX文档地址:https://help.aliyun.com/document_detail/148185.html

    Saturn:Saturn (任务调度系统)是唯品会开源的一个分布式任务调度平台,取代传统的Linux Cron/Spring Batch Job的方式,做到全域统一配置,统一监控,任务高可用以及分片并发处理。Saturn是在当当开源的Elastic Job基础上,结合各方需求和我们的实践见解改良而成。
    Saturn gitee文档地址:https://gitee.com/vipshop/Saturn?utm_source=alading&utm_campaign=repo
    Saturn github文档地址:https://github.com/vipshop/Saturn

    2. 定时任务调度详解

    2.1 Timer

    Timer类是jdk专门提供的定时器工具,用来在后台线程计划执行指定任务,在java.util包下,要跟TimerTask一起配合使用。TimerTask单机单线程加锁阻塞执行的,Timer类其实是一个任务调度器,它里面包含了一个TimerThread线程,在这个线程中无限循环从TaskQueue中获取TimerTask(该类实现了Runnable接口),调用其run方法,就能异步执行定时任务。我们需要继承TimerTask类,实现它的run方法,在该方法中加上自己的业务逻辑。

    使用方式
    先实例化一个Timer类,然后调用它的schedule方法,在该方法中实例化TimerTask类,业务逻辑写在run方法中。schedule方法最后的两次参数分别表示:延迟时间 和 间隔时间,单位是毫秒。上面例子中,设置的定时任务是每隔1秒执行一次,延迟2秒执行。

    主要方法
    schedule(TimerTask task, Date time), 指定任务task在指定时间time执行
    schedule(TimerTask task, long delay), 指定任务task在指定延迟delay后执行
    schedule(TimerTask task, Date firstTime,long period),指定任务task在指定时间firstTime执行后,进行重复固定延迟频率peroid的执行
    schedule(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后,进行重复固定延迟频率peroid的执行
    scheduleAtFixedRate(TimerTask task,Date firstTime,long period), 指定任务task在指定时间firstTime执行后,进行重复固定延迟频率peroid的执行
    scheduleAtFixedRate(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后,进行重复固定延迟频率peroid的执行

    存在问题
    1.由于Timer是单线程执行任务,如果其中一个任务耗时非常长,会影响其他任务的执行。
    2.如果TimerTask抛出RuntimeException,Timer会停止所有任务的运行。

    优缺点
    优点:非常方便实现多个周期性的定时任务,并且支持延迟执行,还支持在指定时间之后支持,功能还算强大。

    缺点:如果其中一个任务耗时非常长,会影响其他任务的执行。并且如果TimerTask抛出RuntimeException,Timer会停止所有任务的运行,所以阿里巴巴开发者规范中不建议使用它。

    操作验证

        /**
         * TimerTask
         */
        private void timerTaskTest() {
            java.util.TimerTask timerTask = new java.util.TimerTask() {
                @Override
                public void run() {
                    System.out.println("【JavaTask】"+Thread.currentThread().getName() + ",TimerTask," + DateUtil.date());
                }
            };
            Timer timer = new Timer();
            timer.schedule(timerTask, 10, 3000);
        }
    

    2.2 ScheduledExecutorService

    ScheduledExecutorService是JDK1.5+版本引进的定时任务,该类位于java.util.concurrent并发包下。相当于多线程版本的Timer,ScheduledExecutorService是基于多线程的,设计的初衷是为了解决Timer单线程执行,多个任务之间会互相影响的问题。

    主要方法
    schedule(Runnable command,long delay,TimeUnit unit),带延迟时间的调度,只执行一次,调度之后可通过Future.get()阻塞直至任务执行完毕。
    schedule(Callable callable,long delay,TimeUnit unit),带延迟时间的调度,只执行一次,调度之后可通过Future.get()阻塞直至任务执行完毕,并且可以获取执行结果。
    scheduleAtFixedRate,表示以固定频率执行的任务,如果当前任务耗时较多,超过定时周期period,则当前任务结束后会立即执行。
    scheduleWithFixedDelay,表示以固定延时执行任务,延时是相对当前任务结束为起点计算开始时间。

    使用方式
    调用ScheduledExecutorService类的scheduleAtFixedRate方法实现周期性任务,每隔1秒钟执行一次,每次延迟1秒再执行。这种定时任务是阿里巴巴开发者规范中用来替代Timer类的方案,对于多线程执行周期性任务,是个不错的选择。

    优缺点
    优点:基于多线程的定时任务,多个任务之间不会相关影响,支持周期性的执行任务,并且带延迟功能。
    缺点:不支持一些较复杂的定时规则。

    操作验证

        /**
         * ScheduledExecutorService
         */
        private void ScheduledExecutorTest() {
            //为了方便测试这里使用线程池工具创建线程池,建议手动创建线程池,避免内存溢出
            ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
    
            //按照固定频率执行,每隔5秒跑一次
            ses.scheduleAtFixedRate(() -> System.out.println("【JavaTask】ScheduledExecutorService-1," + DateUtil.date()), 0, 5, TimeUnit.SECONDS);
    
            //按照固定延时执行,上次执行完后隔3秒再跑
            ses.scheduleWithFixedDelay(() -> System.out.println("【JavaTask】ScheduledExecutorService-2," + DateUtil.date()), 0, 3, TimeUnit.SECONDS);
        }
    

    2.3 SpringTask

    spring task是spring3以上版本自带的定时任务,实现定时任务的功能时,需要引入spring-context包,目前它支持:xml 和 注解 两种方式。由于xml方式太古老了,我们以springboot项目中注解方式为例。

    主要方法
    @EnableScheduling 开启调度
    @Scheduled(cron = “10 * * * * ?”) cron 表达式
    @Scheduled(fixedRate = 5000) 循环调用
    @Scheduled(fixedDelay = 3000) 循环延迟调用

    cron规则
    spring4以上的版本中,cron表达式包含6个参数:[秒] [分] [时] [日期] [月] [星期]

    支持几个常用的特殊符号:
        *:表示任何时间触发任务
        ,:表示指定的时间触发任务
        -:表示一段时间内触发任务
        /:表示从哪一个时刻开始,每隔多长时间触发一次任务。
        ?:表示用于月中的天和周中的天两个子表达式,表示不指定值。
    
    cron表达式参数具体含义:
        秒,取值范围:0-59,支持*、,、-、/。
        分,取值范围:0-59,支持*、,、-、/。
        时,取值范围:0-23,支持*、,、-、/。
        日期,取值范围:1-31,支持*、,、-、/。比秒多了?,表示如果指定的星期触发了,则配置的日期变成无效。
        月,取值范围:1-12,支持*、,、-、/。
        星期,取值范围:1~7,1代表星期天,6代表星期六,其他的以此类推。支持*、,、-、/、?。比秒多了?,表示如果指定的日期触发了,则配置的星期变成无效。
    
    常见cron表达式使用举例:
        0 0 0 1 * ?  每月1号零点执行
        0 0 2 * * ?  每天凌晨2点执行
        0 0 2 * * ?  每天凌晨2点执行
        0 0/5 11 * * ? 每天11点-11点55分,每隔5分钟执行一次
        0 0 18 ? * WED 每周三下午6点执行
    

    使用方式
    spring task先通过ScheduledAnnotationBeanPostProcessor类的processScheduled方法,解析和收集Scheduled注解中的参数,包含:cron表达式。然后在ScheduledTaskRegistrar类的afterPropertiesSet方法中,默认初始化一个单线程的ThreadPoolExecutor执行任务。

    优缺点
    优点:spring框架自带的定时功能,springboot做了非常好的封装,开启和定义定时任务非常容易,支持复杂的cron表达式,可以满足绝大多数单机版的业务场景。单个任务时,当前次的调度完成后,再执行下一次任务调度。
    缺点:默认单线程,如果前面的任务执行时间太长,对后面任务的执行有影响。不支持集群方式部署,不能做数据存储型定时任务。

    操作验证

    package com.zrj.flowable.job;
    
    import cn.hutool.core.date.DateUtil;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    /**
     * SpringTask
     * 项目启动,定时任务同时启动开始运行
     *
     * @author zrj
     * @since 2022/4/13
     **/
    @Component
    @EnableScheduling
    public class ScheduledSpringTask {
    
        /**
         * 每分钟的第10秒跑一次
         * <p>
         * 配置文件配置:@ Scheduled(cron = "${sue.spring.task.cron}")
         * 直接代码表达式:@ Scheduled(cron = "10 * * * * ?")
         */
        @Scheduled(cron = "10 * * * * ?")
        public void cronTask() throws InterruptedException {
            System.out.println("【SpringTask】" + Thread.currentThread().getName() + ",cronTask," + DateUtil.date());
        }
    
        /**
         * 每隔5秒跑一次
         */
        @Scheduled(fixedRate = 5000)
        public void fixedRateTask() throws InterruptedException {
            System.out.println("【SpringTask】" + Thread.currentThread().getName() + ",fixedRateTask," + DateUtil.date());
        }
    
        /**
         * 上次跑完隔3秒再跑
         */
        @Scheduled(fixedDelay = 3000)
        public void fixedDelayTask() throws InterruptedException {
            System.out.println("【SpringTask】" + Thread.currentThread().getName() + ",fixedDelayTask," + DateUtil.date());
        }
    }
    
    

    2.4 Quartz

    quartz是OpenSymphony开源组织在Job scheduling领域的开源项目,是由java开发的一个开源的任务日程管理系统。Quartz是一套轻量级的任务调度框架,只需要定义了 Job(任务),Trigger(触发器)和 Scheduler(调度器),即可实现一个定时调度能力。支持基于数据库的集群模式,可以做到任务幂等执行。
    Quartz 支持任务幂等执行,其实理论上还是抢 DB 锁。quartz 表QRTZ_LOCKS 就是 Quartz 集群实现同步机制的行锁表。其中有 5 条记录,代表 5 把锁,分别用于实现多个 Quartz Node 对 Job、Trigger、Calendar 访问的同步控制。

    主要方法
    Scheduler 代表调度容器,一个调度容器中可以注册多个JobDetail和Trigger。
    Job 代表工作,即要执行的具体内容。
    JobDetail 代表具体的可执行的调度程序,Job是这个可执行程调度程序所要执行的内容。
    JobBuilder 用于定义或构建JobDetail实例。
    Trigger 代表调度触发器,决定什么时候去调。
    TriggerBuilder 用于定义或构建触发器。
    JobStore 用于存储作业和任务调度期间的状态。

    使用方式
    spring quartz跟spring task的cron表达式规则基本一致,只是spring4以上的版本去掉了后面的年,而quartz的CronTrigger的年是非必填的,这里我就不做过多介绍了。

    优缺点
    优点:默认是多线程异步执行,单个任务时,在上一个调度未完成时,下一个调度时间到时,会另起一个线程开始新的调度,多个任务之间互不影响。支持复杂的cron表达式,它能被集群实例化,支持分布式部署。
    缺点:相对于spring task实现定时任务成本更高,需要手动配置QuartzJobBean、JobDetail和Trigger等。需要引入了第三方的quartz包,有一定的学习成本。不支持并行调度,不支持失败处理策略和动态分片的策略等。

    操作验证
    引入依赖

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

    Quartz执行任务

    package com.zrj.flowable.job;
    
    import org.quartz.JobDataMap;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.springframework.scheduling.quartz.QuartzJobBean;
    
    /**
     * Quartz执行任务
     *
     * @author zrj
     * @since 2022/4/13
     **/
    public class ScheduledQuartzTask extends QuartzJobBean {
        @Override
        protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
            String taskName = (String) jobDataMap.get("taskName");
            String userName = (String) jobDataMap.get("userName");
            System.out.println("【ScheduledQuartzTask】taskName=" + taskName + ",userName=" + userName);
        }
    }
    
    

    Quartz配置

    package com.zrj.flowable.job;
    
    import org.quartz.*;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * Quartz配置
     *
     * @author zrj
     * @since 2022/4/13
     **/
    @Configuration
    public class ScheduledQuartzConfig {
        @Value("${sue.spring.quartz.cron:*/5 * * * * ?}")
        private String testCron;
    
        /**
         * 创建定时任务
         */
        @Bean
        public JobDetail quartzTestDetail() {
            JobDetail jobDetail = JobBuilder.newJob(ScheduledQuartzTask.class)
                    .withIdentity("scheduledQuartzTask", "QUARTZ_TASK_TEST")
                    .usingJobData("userName", "Jerry")
                    .usingJobData("taskName", "ScheduledQuartzTask")
                    .storeDurably()
                    .build();
            return jobDetail;
        }
    
        /**
         * 创建触发器
         */
        @Bean
        public Trigger quartzTestJobTrigger() {
            //每隔5秒执行一次
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(testCron);
    
            //创建触发器
            Trigger trigger = TriggerBuilder.newTrigger()
                    .forJob(quartzTestDetail())
                    .withIdentity("quartzTestJobTrigger", "QUARTZ_TASK_JOB_TRIGGER")
                    .withSchedule(cronScheduleBuilder)
                    .build();
            return trigger;
        }
    
    }
    
    

    2.5 xxl-job

    XXL-JOB是一个分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线,开箱即用。xxl-job框架对quartz进行了扩展,使用mysql数据库存储数据,并且内置jetty作为RPC服务调用。主要包括调度中心和执行器,调度中心用于配置调度任务,执行器一般集成于项目,通过rpc注册到注册中心,注册中心通过配置参数实现定时调用。

    另外在xxl-job对外提供的rest接口可以通过后台直接实现任务配置,业务开发中通常有一种场景,就是本身不知道何时触发执行调度任务,这时候大多采用定时周期性扫描判断是否需要执行,比如每三分钟扫一次表判断商品是否过期,然后触发下架操作,这种方式虽然与业务解耦,但是对服务器损耗比较大,浪费大量的服务资源,尤其是对实时性要求比较高的场景,还有一种解决方案是根据商品的过期时间通过xxl-job后台提供的接口创建一条执行任务,到时间自动执行相关操作,这种情况可避免不知何时触达调度而循环扫描浪费资源的情况,但是如果商品数据量巨大,创建任务量特别大的情景不如第一种更适合,两种思路,具体使用一定结合具体的业务场景使用。

    主要模块
    调度中心:需要搭建调度中心项目。
    执行器:需要集成执行器客户端。

    使用方式
    官方文档极为详细,这里就不再赘述。
    官方文档地址:https://www.xuxueli.com/xxl-job/
    源码仓库地址 github:https://github.com/xuxueli/xxl-job
    源码仓库地址 gitee:http://gitee.com/xuxueli0323/xxl-job

    XXL-JOBv2.0架构图
    在这里插入图片描述
    优缺点
    优点:有界面管理定时任务,支持弹性扩容缩容、动态分片、故障转移、失败报警等功能。它的功能非常强大,很多大厂在用,可以满足绝大多数业务场景。
    缺点:和quartz一样,通过数据库分布式锁,来控制任务不能重复执行。在任务非常多的情况下,有一些性能问题。

    操作验证
    执行之前,需要完成xxl-admin管理后台部署和mysql脚本执行等这些前期准备工作。

    相关依赖

    <dependency>
       <groupId>com.xuxueli</groupId>
       <artifactId>xxl-job-core</artifactId>
    </dependency>
    

    applicationContext.properties文件中配置参数

    xxl.job.admin.address: http://localhost:8088/xxl-job-admin/
    xxl.job.executor.appname: xxl-job-executor-sample
    xxl.job.executor.port: 8888
    xxl.job.executor.logpath: /data/applogs/xxl-job/
    

    HelloJobHandler

    @JobHandler(value = "helloJobHandler")
    @Component
    public class HelloJobHandler extends IJobHandler {
    
        @Override
        public ReturnT<String> execute(String param) {
            System.out.println("XXL-JOB, Hello World.");
            return SUCCESS;
        }
    }
    

    2.6 elastic-job

    elastic-job是当当网开发的弹性分布式任务调度系统,功能丰富强大,采用zookeeper实现分布式协调,实现任务高可用以及分片。它是专门为高并发和复杂业务场景开发。

    ElasticJob 是面向互联网生态和海量任务的分布式调度解决方案,由两个相互独立的子项目 ElasticJob-Lite 和 ElasticJob-Cloud 组成。 它通过弹性调度、资源管控、以及作业治理的功能,打造一个适用于互联网场景的分布式调度解决方案,并通过开放的架构设计,提供多元化的作业生态。 它的各个产品使用统一的作业 API,开发者仅需一次开发,即可随意部署。
    ElasticJob 已于 2020 年 5 月 28 日成为 Apache ShardingSphere 的子项目。elastic-job在2.x之后,出了两个产品线:Elastic-Job-Lite和Elastic-Job-Cloud,而我们一般使用Elastic-Job-Lite就能够满足需求。Elastic-Job-Lite定位为轻量级无中心化解决方案,使用jar包的形式提供分布式任务的协调服务,外部仅依赖于Zookeeper。

    ElasticJob 官网地址:https://shardingsphere.apache.org/elasticjob/index_zh.html

    功能列表
    1.弹性调度
    支持任务在分布式场景下的分片和高可用
    能够水平扩展任务的吞吐量和执行效率
    任务处理能力随资源配备弹性伸缩

    2.资源分配
    在适合的时间将适合的资源分配给任务并使其生效
    相同任务聚合至相同的执行器统一处理
    动态调配追加资源至新分配的任务

    3.作业治理
    失效转移
    错过作业重新执行
    自诊断修复

    4.作业依赖(TODO)
    基于有向无环图(DAG)的作业间依赖
    基于有向无环图(DAG)的作业分片间依赖

    5.作业开放生态
    可扩展的作业类型统一接口
    丰富的作业类型库,如数据流、脚本、HTTP、文件、大数据等
    易于对接业务作业,能够与 Spring 依赖注入无缝整合

    6.可视化管控端
    作业管控端
    作业执行历史数据追踪
    注册中心管理

    使用方式
    ElasticJob-Lite定位为轻量级无中心化解决方案,使用 jar 的形式提供分布式任务的协调服务。
    在这里插入图片描述
    优缺点
    优点:支持分布式调度协调,支持分片,适合高并发,和一些业务相对来说较复杂的场景。
    缺点:依赖过重,需要依赖于zookeeper,实现定时任务相对于xxl-job要复杂一些,要对分片规则非常熟悉。

    操作验证
    相关依赖

    <dependency>
        <groupId>com.dangdang</groupId>
        <artifactId>elastic-job-lite-core</artifactId>
    </dependency>
    <dependency>
        <groupId>com.dangdang</groupId>
        <artifactId>elastic-job-lite-spring</artifactId>
    </dependency>
    

    配置zookeeper

    @Configuration
    @ConditionalOnExpression("'${zk.serverList}'.length() > 0")
    public class ZKConfig {
        @Bean
        public ZookeeperRegistryCenter registry(@Value("${zk.serverList}") String serverList,
                                                 @Value("${zk.namespace}") String namespace) {
            return new ZookeeperRegistryCenter(new ZookeeperConfiguration(serverList, namespace));
        }
    
    }
    

    实现SimpleJob接口

    public class TestJob implements SimpleJob {
    
        @Override
        public void execute(ShardingContext shardingContext){
            System.out.println("ShardingTotalCount:"+shardingContext.getShardingTotalCount());
            System.out.println("ShardingItem:"+shardingContext.getShardingItem());
        }
    }
    

    JobConfig配置任务

    @Configuration
    public class JobConfig {
        @Value("${sue.spring.elatisc.cron}")
        private String testCron;
        @Value("${sue.spring.elatisc.itemParameters}")
        private  String shardingItemParameters;
        @Value("${sue.spring.elatisc.jobParameters}")
        private String jobParameters =;
        @Value("${sue.spring.elatisc.shardingTotalCount}")
        private int shardingTotalCount;
        
        @Autowired
        private ZookeeperRegistryCenter registryCenter;
    
        @Bean
        public SimpleJob testJob() {
            return new TestJob();
        }
    
        @Bean
        public JobScheduler simpleJobScheduler(final SimpleJob simpleJob) {
            return new SpringJobScheduler(simpleJob, registryCenter, getConfiguration(simpleJob.getClass(),
                    cron, shardingTotalCount, shardingItemParameters, jobParameters));
        }
    
        private geConfiguration getConfiguration(Class<? extends SimpleJob> jobClass,String cron,int shardingTotalCount,String shardingItemParameters,String jobParameters) {
            JobCoreConfiguration simpleCoreConfig = JobCoreConfiguration.newBuilder(jobClass.getName(), testCron, shardingTotalCount).
                    shardingItemParameters(shardingItemParameters).jobParameter(jobParameters).build();
            SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(simpleCoreConfig, jobClass.getCanonicalName());
            LiteJobConfiguration jobConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).overwrite(true).build();
            return jobConfig;
        }
    }
    

    applicationContext.properties文件中配置参数

    spring.application.name=elasticjobDemo
    zk.serverList=localhost:2181
    zk.namespace=elasticjobDemo
    sue.spring.elatisc.cron=0/5 * * * * ?
    sue.spring.elatisc.itemParameters=0=A,1=B,2=C,3=D
    sue.spring.elatisc.jobParameters=test
    sue.spring.elatisc.shardingTotalCount=4
    
    展开全文
  • Java实现定时任务

    万次阅读 2022-04-06 23:11:54
    这种方式的定时任务主要用到两个类,Timer 和 TimerTask,使用起来比较简单。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。 TimerTask是一个抽象类,new的时候实现自己的 run 方法,然后将其丢给 Timer 去...

    1 使用java.util.Timer

    这种方式的定时任务主要用到两个类,Timer 和 TimerTask,使用起来比较简单。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。 TimerTask是一个抽象类,new的时候实现自己的 run 方法,然后将其丢给 Timer 去执行即可。
    代码示例:

    import java.time.LocalDateTime;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class Schedule {
        public static void main(String[] args) {
            TimerTask timerTask = new TimerTask() {
                @Override
                public void run() {
                    System.out.println("当前线程:" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
                }
            };
            // 在指定延迟0毫秒后开始,随后地执行以2000毫秒间隔执行timerTask 
            new Timer().schedule(timerTask, 0L, 2000L);
            System.out.println("当前线程:" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
        }
    }
    

    在这里插入图片描述
    缺点:

    • Timer 的背后只有一个线程,不管有多少个任务,都只有一个工作线程串行执行,效率低下
    • 受限于单线程,如果第一个任务逻辑上死循环了,后续的任务一个都得不到执行
    • 依然是由于单线程,任一任务抛出异常后,整个 Timer 就会结束,后续任务全部都无法执行

    2 使用ScheduledExecutorService

    ScheduledExecutorService 即是 Timer 的替代者,JDK 1.5 并发包引入,是基于线程池设计的定时任务类。每个调度任务都会分配到线程池中的某一个线程去执行,任务就是并发调度执行的,任务之间互不影响

    Java 5.0引入了java.util.concurrent包,其中的并发实用程序之一是ScheduledThreadPoolExecutor ,它是一个线程池,用于以给定的速率或延迟重复执行任务。它实际上是Timer/TimerTask组合的更通用替代品,因为它允许多个服务线程,接受各种时间单位,并且不需要子类TimerTask (只需实现Runnable)。使用一个线程配置ScheduledThreadPoolExecutor使其等效于Timer 。

    代码示例:

    import java.time.LocalDateTime;
    import java.util.concurrent.*;
    
    public class Schedule {
        public static void main(String[] args) {
            // 创建一个ScheduledThreadPoolExecutor线程池,核心线程数为5
            ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(5);
            // 创建Runnable打印当前线程和当前时间
            Runnable r = () -> System.out.println("当前线程:" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
            /**
             * schedule:只执行一次调度
             * scheduleAtFixedRate:一开始就计算间隔时间,如果任务超过间隔时间,那么就直接开始下一个任务
             * scheduleWithFixedDelay:任务无论执行多久,都要等待上一轮任务完成之后再间隔指定时间,然后才开始下一个任务
             */
             // 在指定1秒延迟后执行r,之后每两秒执行一次
            scheduledExecutorService.scheduleAtFixedRate(r, 1, 2, TimeUnit.SECONDS);
        }
    }
    

    在这里插入图片描述

    3 使用Spring Task

    Spring Task 底层是基于 JDK 的 ScheduledThreadPoolExecutor 线程池来实现的。直接通过Spring 提供的 @Scheduled 注解即可定义定时任务,非常方便。

    以Spring Boot来作为示例,步骤为

    1. 在启动类所在包下创建Schedule 类(在没有配置@ComponentScan的情况下,Spring Boot只会默认扫描启动类所在包的spring组件)
    2. 在该类上添加@Component和@EnableScheduling注解
    3. 在方法上添加@Scheduled注解,该注解主要参数如下
    String cron() default "";  // 支持cron表达式
    
    long fixedDelay() default -1;  // 在最后一次调用结束和下一次调用开始之间的时间间隔,以毫秒为单位
    String fixedDelayString() default "";  // 同上,类似ScheduledExecutorService的scheduleWithFixedDelay
    
    long fixedRate() default -1;  // 在调用之前的时间间隔,以毫秒为单位
    String fixedRateString() default "";  // 同上,类似ScheduledExecutorService的scheduleAtFixedRate
    
    long initialDelay() default -1;  // 在第一次执行fixedRate()或fixedDelay()任务之前要延迟的毫秒数
    String initialDelayString() default "";  // 同上
    

    代码示例:

    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    import java.time.LocalDateTime;
    
    @Component
    @EnableScheduling
    public class Schedule {
        @Scheduled(fixedRate = 2000L)
        public void task() {
            System.out.println("当前线程:" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
        }
    }
    

    在这里插入图片描述

    • 优点: 简单,轻量,支持 Cron 表达式
    • 缺点 :默认只支持单机,是单线程的,并且提供的功能比较单一

    可以通过@EnableAsync和 @Async开启多线程

    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    import java.time.LocalDateTime;
    
    @Component
    @EnableAsync  // 开启异步多线程
    @EnableScheduling
    public class Schedule {
    
        @Async
        @Scheduled(fixedRate = 2000L)
        public void task() {
            System.out.println("当前线程:" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
        }
    }
    

    在这里插入图片描述

    使用@EnableAsync注解后,默认情况下,Spring将搜索关联的线程池定义:上下文中的唯一org.springframework.core.task.TaskExecutor
    的bean,或者名为“taskExecutor”的java.util.concurrent.Executor
    的bean。如果两者都无法解析,则将使用org.springframework.core.task.SimpleAsyncTaskExecutor来处理异步方法调用。

    在这里插入图片描述

    TaskExecutor实现为每个任务启动一个新线程,异步执行它。 支持通过“concurrencyLimit”bean 属性限制并发线程。默认情况下,并发线程数是无限的,所以使用默认的线程池有导致内存溢出的风险

    注意:刚才的运行结果看起来是线程复用的,而实际上此实现不重用线程应尽量实现一个线程池TaskExecutor ,特别是用于执行大量短期任务。不要使用默认的SimpleAsyncTaskExecutor。

    import org.springframework.context.annotation.Bean;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.stereotype.Component;
    
    import java.time.LocalDateTime;
    import java.util.concurrent.Executor;
    
    @Component
    @EnableAsync
    @EnableScheduling
    public class Schedule {
    
        @Async
        @Scheduled(fixedRate = 2000L)
        public void task() {
            System.out.println("当前线程:" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
        }
    
    
        @Bean("taskExecutor")
        public Executor taskExecutor() {
            ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
            taskExecutor.setCorePoolSize(10);
            taskExecutor.setMaxPoolSize(50);
            taskExecutor.setQueueCapacity(200);
            taskExecutor.setKeepAliveSeconds(60);
            taskExecutor.setThreadNamePrefix("自定义-");
            taskExecutor.setAwaitTerminationSeconds(60);
            return taskExecutor;
        }
    }
    

    在这里插入图片描述

    上面提到的一些定时任务的解决方案都是在单机下执行的,适用于比较简单的定时任务场景比如每天凌晨备份一次数据。如果我们需要一些高级特性比如支持任务在分布式场景下的分片和高可用的话,我们就需要用到分布式任务调度框架了,比如Quartz、Elastic-Job、XXL-JOB、PowerJob,本文就不再详细进行介绍了,感兴趣的可以自行查阅相关资料。

    展开全文
  • Java 定时任务表达式

    千次阅读 2021-11-02 17:23:17
    日常开发中,经常会遇到业务数据需要自动处理,这时定时任务就是个很好的方案。 在这里记录下经常使用到的定时任务的Cron(任务执行的频率),后续遇到会持续更新,欢迎大家在评论区提出日常中遇到的各种表达式 ...
  • Java 定时任务-最简单的3种实现方法

    千次阅读 多人点赞 2022-03-07 16:01:27
    一、Timer ...Timer是JAVA自带的定时任务类,实现如下: publicclassMyTimerTask{ publicstaticvoidmain(String[]args){ //定义一个任务 TimerTasktimerTask=newTimerTask(){ @Override publicv...
  • 现象2:跟换定时任务实现方式,使用@Scheduled,同意的现象依然出现了,定时任务跑到一定频率突然不动 解决思路: 1.程序未抛出异常,某个时期却突然不在执行,怀疑线程阻塞了 2.查询jvm线程状态(jstackjava...
  • Java定时任务调度详解

    千次阅读 2021-04-07 08:32:07
    前言在实际项目开发中,除了Web应用、SOA服务外,还有一类不可缺少的,那就是定时任务调度。定时任务的场景可以说非常广泛,比如某些视频网站,购买会员后,每天会给会员送成长值,每月会给会员送一些电影券;比如在...
  • Java定时任务的三种实现方式

    万次阅读 2021-03-22 17:52:09
    前言现代的应用程序早已不是以前的那些由简单的增删改查拼凑而成的程序了,高复杂性早已是标配,而任务的定时...java 系统中主要有三种方式来实现定时任务:Timer和TimerTaskScheduledExecutorService三方框架 Quar...
  • Java定时任务实现的几种方式

    千次阅读 2021-03-09 15:32:21
    在开发测试工具的应用后台,需要定时任务做日志处理,或者数据清理,包括做些复杂的业务计算逻辑,在选择定时任务的时候,怎么能够快速实现,并且选择一种更适合自己的方式呢?我这里把定时任务的实现收集整理了一些...
  • JAVA定时任务调度

    2016-10-24 13:44:55
    JAVA定时任务调度
  • java 定时任务写法

    2012-11-20 14:55:48
    后台JAVA定时任务写法,可在夜间批处理执行业务处理
  • java 定时任务 cron

    千次阅读 2021-07-26 23:58:19
    Cron表达式是一个字符串,常用于java定时任务,字符串以5或6个空格隔开,分为6或7个属性,每一个属性代表一个含义,Cron有如下两种语法格式(一般使用第二种)
  • 1.如何使用@Scheduled注解 2.如何设置定时任务开关
  • java定时任务 cron

    2022-03-02 14:26:15
    我用来操作数据库定时任务 今天刚学会!!! 也是第一次写csdn ヾ(◍°∇°◍)ノ゙!!!一开始不懂, 就是不知道从何下手 流程: 1.启动类上加注解: @EnableScheduling 2.去类里 注入要用到的service 并且加上注解 ...
  • Java多线程之定时任务 以及 SpringBoot多线程实现定时任务、以及分享动态实现定时任务 1. 基于单线程的定时器——简单介绍 Timer 中的 schedule 与 scheduleAtFixedRate 2. 基于多线程的定时器——...
  • Java使用定时任务

    千次阅读 2021-03-23 16:52:25
    Java定时任务的四种实现方式 (1)JDK 自带的定时器实现 (2)Quartz 定时器实现 (3)Spring Task相关的任务调度 -JDK自带:JDK自带的Timer以及JDK1.5+ 新增的ScheduledExecutorService; -...
  • 定时任务(java)

    2017-08-30 10:26:58
    Java语言 适用于定时执行任务场景
  • Java如何实现定时任务

    千次阅读 2022-03-26 21:01:32
    我是看视频入门Java的,那时候学Java基础API的时候,看的视频也带有讲定时功能(JDK原生就支持),我记得视频讲师写了Timer来讲解定时任务。 当时并不知道定时任务有什么实际作用,所以在初学阶段的我,从来没使用...
  • java 定时任务的执行时间表示-

    千次阅读 2021-03-11 10:57:18
    天天上午10点,下午2点,4点java0 0/30 9-17 * * ? 朝九晚五工做时间内每半小时缓存0 0 12 ? * WED 表示每一个星期三中午12点code"0 0 12 * * ?" 天天中午12点触发rem"0 15 10 ? * *" 天天上午10:15触发get"0 15 10...
  • java定时任务接口ScheduledExecutorService

    千次阅读 2021-02-28 14:21:58
    一、ScheduledExecutorService 设计思想ScheduledExecutorService,是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。需要注意,只有当调度任务来的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 172,200
精华内容 68,880
关键字:

java定时任务如何测试