Spring定时任务的几种实现

合集下载

spring定时任务详解（@Scheduled注解）

spring定时任务详解（@Scheduled注解）Spring配置⽂件xmlns加⼊xmlns:task="/schema/task"xsi:schemaLocation中加⼊/schema/task/schema/task/spring-task-3.0.xsd"Spring扫描注解的配置<context:component-scan base-package="com.imwoniu.*" />任务扫描注解<task:executor id="executor" pool-size="5" /><task:scheduler id="scheduler" pool-size="10" /><task:annotation-driven executor="executor" scheduler="scheduler" />代码实现：注解@Scheduled 可以作为⼀个触发源添加到⼀个⽅法中，例如，以下的⽅法将以⼀个固定延迟时间5秒钟调⽤⼀次执⾏，这个周期是以上⼀个调⽤任务的完成时间为基准，在上⼀个任务完成之后，5s后再次执⾏：@Scheduled(fixedDelay = 5000)public void doSomething() {// something that should execute periodically}如果需要以固定速率执⾏，只要将注解中指定的属性名称改成fixedRate即可，以下⽅法将以⼀个固定速率5s来调⽤⼀次执⾏，这个周期是以上⼀个任务开始时间为基准，从上⼀任务开始执⾏后5s再次调⽤：@Scheduled(fixedRate = 5000)public void doSomething() {// something that should execute periodically}如果简单的定期调度不能满⾜，那么cron表达式提供了可能package com.imwoniu.task;import org.springframework.scheduling.annotation.Scheduled;import ponent;@Componentpublic class TaskDemo {@Scheduled(cron = "0 0 2 * * ?") //每天凌晨两点执⾏void doSomethingWith(){("定时任务开始......");long begin = System.currentTimeMillis();//执⾏数据库操作了哦...long end = System.currentTimeMillis();("定时任务结束，共耗时：[" + (end-begin) / 1000 + "]秒");}}关于Cron表达式(转载)表达式⽹站⽣成:按顺序依次为秒（0~59）分钟（0~59）⼩时（0~23）天（⽉）（0~31，但是你需要考虑你⽉的天数）⽉（0~11）天（星期）（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）7.年份（1970－2099）其中每个元素可以是⼀个值(如6),⼀个连续区间(9-12),⼀个间隔时间(8-18/4)(/表⽰每隔4⼩时),⼀个列表(1,3,5),通配符。

SpringScheduled定时任务+异步执行

SpringScheduled定时任务+异步执⾏Spring定时任务 + 异步执⾏1.实现spring定时任务的执⾏import org.springframework.scheduling.annotation.Scheduled;import ponent;import java.text.SimpleDateFormat;import java.util.Date;@Componentpublic class ScheduledTasks {private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");@Scheduled(fixedDelay = 5000)public void first() throws InterruptedException {System.out.println("第⼀个定时任务开始 : " + sdf.format(new Date()) + "\r\n线程 : " + Thread.currentThread().getName());System.out.println();Thread.sleep(1000 * 10); //模拟第⼀个任务执⾏的时间}@Scheduled(fixedDelay =3000)public void second() {System.out.println("第⼆个定时任务开始 : " + sdf.format(new Date()) + "\r\n线程 : " + Thread.currentThread().getName());System.out.println();}}由于执⾏定时任务默认的是单线程，存在的问题是：线程资源被第⼀个定时任务占⽤,第⼆个定时任务并不是3秒执⾏⼀次;解决⽅法，创建定时任务的线程调度器，交给spring管理调度import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.TaskScheduler;import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;@Configurationpublic class ScheduleConfig {@Beanpublic TaskScheduler taskScheduler() {ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();scheduler.setPoolSize(10);return scheduler;}}这样就可以保证定时任务之间是多线程，⽽每个定时任务之间是单线程，保证了定时任务的异步，同时保证了消息的幂等性。

Spring提供的三种定时任务机制及其比较

Spring提供的三种定时任务机制及其比较定时任务的需求在众多应用系统中广泛存在，在Spring中，我们可以使用三种不同的定时机制，下面一一描述并加以比较1. 基于Quartz的定时机制下面详细解释这个类图中涉及的关键类及其使用场景1.1. SchedulerFactoryBean这是Spring中基于Quartz的定时机制入口，只要Spring容器装载了这个类，Quartz定时机制就会启动，并加载定义在这个类中的所有triggerSpring配置范例：[xhtml]view plaincopy1.<bean id="sfb"class="org.springframework.scheduling.quartz.SchedulerFactoryBean">2.3.<property name="triggers">4.<list>5.<ref local="appSubscTrigger"/>6.</list>7.</property>8.9.10.<property name="globalTriggerListeners">11.<list>12.<ref local="myTaskTriggerListener"/>13.</list>14.</property>15.</bean>1.2. CronTriggerBean实现了Trigger接口，基于Cron表达式的触发器这种触发器的好处是表达式与linux下的crontab一致，能够满足非常复杂的定时需求，也容易配置Spring配置范例：[xhtml]view plaincopy1.<bean id="notifyTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean">2.<property name="jobDetail"ref="notifyJobDetail"/>3.<property name="cronExpression"value="${notify_trigger_cron_expression}"/>4.</bean>1.3. SimpleTriggerBean该类也实现了Trigger接口，基于配置的定时调度这个触发器的优点在于很容易配置一个简单的定时调度策略Spring配置范例：[xhtml]view plaincopy1.<bean id="simpleReportTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean">2.<property name="jobDetail">3.<ref bean="reportJob"/>4.</property>5.<property name="startDelay">6.<value>3600000</value>7.</property>8.<property name="repeatInterval">9.<value>86400000</value>10.</property>11.</bean>1.4. JobDetailBeanJobDetail类的简单扩展，能够包装一个继承自QuartzJobBean的普通Bean，使之成为定时运行的Job缺点是包装的Bean必须继承自一个指定的类，通用性不强，对普通Job的侵入性过强，不推荐使用1.5. MethodInvokingJobDetailFactoryBeanSpring提供的一个不错的JobDetail包装工具，能够包装任何bean，并执行类中指定的任何stati或非static的方法，避免强制要求bean去实现某接口或继承某基础类Spring配置范例：[xhtml]view plaincopy1.<bean id="notifyJobDetail"parent="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">2.<property name="targetObject"ref="notifyServerHandler"/>3.<property name="targetMethod"value="execute"/>4.</bean>1.6. 关于TriggerListener和JobListenerQuartz中提供了类似WebWork的拦截器的功能，系统执行任务前或任务执行完毕后，都会检查是否有对应的Listener需要被执行，这种AOP的思想为我们带来了灵活的业务需求实现方式。

如何在spring中配置定时任务（job）-zxs9999的专栏-CSDN博客

如何在spring中配置定时任务（job）-zxs9999的专栏-CSDN博客如何在spring中配置定时任务(job) 收藏一、在web.xml文件中进行如下配置：<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext-*.xml</param-value></context-param>那么需要在工程下创建一个以applicationContext- 为开头的xml 文件eg:applicationContext-jobconfig.xmlxml的头和结尾部分跟其他spring配置文件相似，就不赘述，正文如下：<bean id="youJobName(类别名)" class="com.******.YourJobClassLocation(类的定位)" /> <bean id="doYourJob(别名)" class="org.springframework.scheduling.quartz.MethodInvoking JobDetailFactoryBean"><property name="targetObject"><ref bean="youJobName(类别名)""/></property><property name="targetMethod"><value>runMethodName(定时执行的方法名)</value></property></bean><bean id="youJobNameTrigger(触发器别名)" class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail"><ref bean="doYourJob(别名)""/></property><property name="cronExpression"><value>0 0/20 * * * ?(定时的时间配置)</value></property></bean><bean id="doScheduler" class="org.springframework.scheduling.quartz.SchedulerFactory Bean"><property name="triggers"><list><ref local="youJobNameTrigger(触发器别名)"/></list></property></bean>这样的配置几本就可以运转了，但是有一个地方可能是你需要根据你的需求来确定的，那就是触发时间。

SpringBoot执行定时任务@Scheduled的方法

SpringBoot执⾏定时任务@Scheduled的⽅法在做项⽬时，需要⼀个定时任务来接收数据存⼊数据库，后端再写⼀个接⼝来提供该该数据的最新的那⼀条。

数据保持最新：设计字段sign的值（0，1）来设定是否最新定时任务插⼊数据：⾸先进⾏更新，将所有为1即新数据设置过期，然后插⼊新数据，设置sign为1。

这两个操作是原⼦操作。

通过添加事务来进⾏控制。

Java 定时任务的⼏种实现⽅式基于 java.util.Timer 定时器，实现类似闹钟的定时任务使⽤ Quartz、elastic-job、xxl-job 等开源第三⽅定时任务框架，适合分布式项⽬应⽤使⽤ Spring 提供的⼀个注解： @Schedule，开发简单，使⽤⽐较⽅便，也是本⽂介绍的⼀种⽅式Spring 提供的⼀个注解： @Schedule，开发简单，使⽤⽐较⽅便，也是本⽂介绍的⼀种⽅式Spring ⾃⾝提供了对定时任务的⽀持，本⽂将介绍 Spring Boot 中 @Scheduled 定时器的使⽤。

创建定时任务⾸先，在项⽬启动类上添加@EnableScheduling注解，开启对定时任务的⽀持@SpringBootApplication@EnableSchedulingpublic class ScheduledApplication {public static void main(String[] args) {SpringApplication.run(ScheduledApplication.class, args);}}其中@EnableScheduling注解的作⽤是发现注解@Scheduled的任务并后台执⾏。

其次，编写定时任务类和⽅法，定时任务类通过Spring IOC 加载，使⽤@Component注解，定时⽅法使⽤@Scheduled注解。

@Componentpublic class ScheduledTask {@Scheduled(fixedRate = 3000)public void scheduledTask() {System.out.println("任务执⾏时间：" + LocalDateTime.now());}}fixedRate 是 long 类型，表⽰任务执⾏的间隔毫秒数，以上代码中的定时任务每 3 秒执⾏⼀次。

Spring@Scheduled定时任务的fixedRate,fixedDelay,cro。。。

Spring@Scheduled定时任务的fixedRate,fixedDelay,cro。

⼀. 三种定时类型。

1.cron --@Scheduled（cron="0/5 * * * *？"）当时间达到设置的时间会触发事件。

上⾯那个例⼦会每5秒执⾏⼀次。

2018/1/4 14:27:302018/1/4 14:27:352018/1/4 14:27:402018/1/4 14:27:452018/1/4 14:27:502.fixedRate --@Scheduled（fixedRate=2000）每两秒执⾏⼀次时间。

3.fixedDelay --@Scheduled（fixedDelay=2000）每次任务执⾏完之后的2s后继续执⾏看字⾯意思容易理解，但是任务执⾏长度超过周期会怎样呢？不多说，直接上图：import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.Date;import org.springframework.scheduling.annotation.Scheduled;import ponent;@Componentpublic class MyProcessor{DateFormat sdf = new SimpleDateFormat("HH:mm:ss");int[] delays = new int[]{8,3,6,2,2};int index = 0;@Scheduled(cron = "0/5 * * * * ?}")public void process() {try {if(index > delays.length - 1){if(index == delays.length){System.out.println("---------- test end at " + sdf.format(new Date()) + " ---------");}index ++;return;}else{System.out.println(index + ":start run at" + sdf.format(new Date()));}Thread.sleep(delays[index] * 1000);System.out.println(index + ":end run at " + sdf.format(new Date()));index ++;} catch (InterruptedException e) {e.printStackTrace();}}}。

spring定时任务（@Scheduled注解）

spring定时任务（@Scheduled注解）（⼀）在xml⾥加⼊task的命名空间1. xmlns:task="/schema/task"2. /schema/task /schema/task/spring-task-4.1.xsd（⼆）启⽤注解驱动的定时任务<task:annotation-driven scheduler="scheduler" executor="executor" proxy-target-class="true"/>（三）配置定时任务的线程池<task:executor id="executor" pool-size="10"/> <task:scheduler id="scheduler" pool-size="10"/>（四）写我们的定时任务Cron Expressionscron的表达式被⽤来配置CronTrigger实例。

cron的表达式是字符串，实际上是由七⼦表达式，描述个别细节的时间表。

这些⼦表达式是分开的空⽩，代表：1. 1. Seconds2. 2. Minutes3. 3. Hours4. 4. Day-of-Month5. 5. Month6. 6. Day-of-Week7. 7. Year (可选字段)例 "0 0 12 ? * WED" 在每星期三下午12:00 执⾏,个别⼦表达式可以包含范围, 例如，在前⾯的例⼦⾥("WED")可以替换成 "MON-FRI", "MON, WED, FRI"甚⾄"MON-WED,SAT".“*” 代表整个时间段.每⼀个字段都有⼀套可以指定有效值，如Seconds (秒) ：可以⽤数字0－59 表⽰，Minutes(分) ：可以⽤数字0－59 表⽰，Hours(时) ：可以⽤数字0-23表⽰,Day-of-Month(天) ：可以⽤数字1-31 中的任⼀⼀个值，但要注意⼀些特别的⽉份Month(⽉) ：可以⽤0-11 或⽤字符串 “JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV and DEC” 表⽰Day-of-Week(每周)：可以⽤数字1-7表⽰（1 ＝星期⽇）或⽤字符⼝串“SUN, MON, TUE, WED, THU, FRI and SAT”表⽰“/”：为特别单位，表⽰为“每”如“0/15”表⽰每隔15分钟执⾏⼀次,“0”表⽰为从“0”分开始, “3/20”表⽰表⽰每隔20分钟执⾏⼀次，“3”表⽰从第3分钟开始执⾏“?”：表⽰每⽉的某⼀天，或第周的某⼀天“L”：⽤于每⽉，或每周，表⽰为每⽉的最后⼀天，或每个⽉的最后星期⼏如“6L”表⽰“每⽉的最后⼀个星期五”“W”：表⽰为最近⼯作⽇，如“15W”放在每⽉（day-of-month）字段上表⽰为“到本⽉15⽇最近的⼯作⽇”““#”：是⽤来指定“的”每⽉第n个⼯作⽇,例在每周（day-of-week）这个字段中内容为"6#3" or "FRI#3" 则表⽰“每⽉第三个星期五”1）Cron表达式的格式：秒分时⽇⽉周年(可选)。

SpringBoot三种定时任务实现方式

SpringBoot三种定时任务实现方式在Spring Boot项目中，实现定时任务是常见需求。

Spring Boot提供了多种灵活的方式来实现定时任务，包括基于注解的方式、基于接口的方式以及使用外部任务调度工具等。

定时任务作为一种系统调度工具，在一些需要有定时作业的系统中应用广泛，如每逢某个时间点统计数据、在将来某个时刻执行某些动作...定时任务在主流开发语言均提供相应的API供开发者调用，在Java中，实现定时任务有很多种方式，原生的方式实现一个完整定时任务需要由Timer、TimerTask两个类，Timer 是定时器类，用来按计划开启后台线程执行指定任务，TimerTask一个抽象类，它的子类代表一个可以被Timer计划的任务。

除此之外，还可以用ScheduledExecutorService类或者使用第三方jar库Quartz，其中Quartz是一个优秀的定时任务框架，发展至今已经非常成熟，以致后来其他的定时任务框架的核心思想或底层大多源于Quartz。

springboot作为Java的一种开发框架，在springboot项目中实现定时任务不仅可以使用Java提供的原生方式，还可以使用springboot提供的定时任务API。

本文将详细介绍三种常用的Spring Boot定时任务实现方式，并提供相应的例子代码。

1. 基于注解的方式（@Scheduled）使用@Scheduled注解是实现Spring Boot定时任务最简单直接的方式。

首先，你需要在Spring Boot的启动类或者配置类上添加@EnableScheduling注解来启用定时任务支持。

然后，在需要定时执行的方法上添加@Scheduled注解，并指定cron表达式或固定间隔。

例子代码：在上面的代码中，@Scheduled注解分别使用了cron表达式和固定频率（fixedRate）两种方式来定义定时任务。

需要注意的是，@EnableScheduling 注解只需要在Spring Boot的启动类或配置类上添加一次。

enablescheduling注解

enablescheduling注解enablescheduling注解，又叫Spring定时任务注解，是Spring 框架提供的一种能够自动安排任务执行的注解。

其作用是在用户设定的定时时间到期后，自动触发用户设置的任务，以实现定时执行的功能。

enablescheduling注解的使用，可以大大降低开发和维护的复杂度，提高应用的可靠性，也有利于统一定时任务的管理。

## 二、enablescheduling注解原理enablescheduling注解是基于Java的反射机制来实现的，当用户将enablescheduling注解添加到目标类时，Spring就会检测到注解所标注的对象，然后对其进行反射处理，通过反射机制解析注解，实现对目标类的操作。

这就是enablescheduling注解的原理。

## 三、enablescheduling注解的使用1. 使用@Enablesscheduling注解：在类上添加@Enablesscheduling注解，开启定时任务功能；2.加@Scheduled注解：在要执行定时任务的方法上添加@Scheduled注解，定义执行任务的时间和间隔；3.动定时任务：启动Spring容器，就可以自动执行定时任务； ##、enablescheduling注解的优势1.便快捷：使用enablescheduling注解，可以快速实现定时任务，新手也可以非常容易上手；2.于管理：使用enablescheduling注解，可以统一管理各个任务，可以更加方便地进行定时任务的开启、暂停和停止；3.高应用可靠性：使用enablescheduling注解，可以有效减少任务的失败率，提高任务的可靠性；4.低开发复杂度：使用enablescheduling注解，可以减少专门用于定时任务的程序的开发，降低开发复杂度；## 五、enablescheduling注解的不足1.前只支持单机环境：enablescheduling注解目前只支持单机环境，对于分布式环境，需要分别配置定时任务；2.带有参数的定时任务支持不够好：enablescheduling注解对带有参数的定时任务支持不够好，要实现带有参数的定时任务，还需要稍微改动代码；3.度任务量过大也会受到影响：如果调度任务量过大，可能会造成系统性能的下降，对系统整体性能造成影响；##、enablescheduling注解的应用1.常提醒：enablescheduling注解可以用于实现日常提醒，例如每日早上定时提醒用户进行备忘录的查看和记录等；2.现网站的定时统计：可以使用enablescheduling注解定时统计某个网站的数据，以便于更加直观地查看网站的历史访问情况；3.时发布内容：可以使用enablescheduling注解定时发布内容，例如可以定时发布某个博客站点的每日文章等；## 七、总结enablescheduling注解是一种可以自动安排任务执行的注解，它的使用可以方便快捷的实现定时任务，提高应用的可靠性，降低开发复杂度，可以应用于日常提醒，定时统计，定时发布内容等方面。

定时任务任务的三种方法

定时任务任务的三种⽅法1，spring整合quartz⽅式，这种⽹上资料太多，简单引⽤⼀下就ok。

<bean id="taskJob" class="com.tyyd.dw.task.DataConversionTask"/><bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="group" value="job_work"/><property name="name" value="job_work_name"/><property name="concurrent" value="false"/><property name="targetObject"><ref bean="taskJob"/></property><property name="targetMethod"><value>run</value></property></bean><bean id="myTrigger"class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"><property name="name" value="work_default_name"/><property name="group" value="work_default"/><property name="jobDetail"><ref bean="jobDetail"/></property><property name="cronExpression"><value>0/5 * * * * ?</value></property></bean><bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref bean="myTrigger"/></list></property></bean>2.spring task⽅式的定时任务（最为简单，功能也简单）<bean id="task1" class="com.XXX.Task1"></bean><bean id="task2" class="com.XXX.Task2"></bean><task:scheduled-tasks><task:scheduled ref="task1" method="execute" cron="0 */1 * * * ?"/><task:scheduled ref="task2" method="execute" cron="0 */1 * * * ?"/></task:scheduled-tasks>使⽤的时候，直接写⼀个类，⼀个⽅法就可以了，简单快捷。

Java中定时任务的6种实现方式

Java中定时任务的6种实现⽅式⽬录1、线程等待实现2、JDK⾃带Timer实现2.1 核⼼⽅法2.2使⽤⽰例2.2.1指定延迟执⾏⼀次2.2.2固定间隔执⾏2.2.3固定速率执⾏2.3 schedule与scheduleAtFixedRate区别2.3.1schedule侧重保持间隔时间的稳定2.3.2scheduleAtFixedRate保持执⾏频率的稳定2.4 Timer的缺陷3、JDK⾃带ScheduledExecutorService3.1 scheduleAtFixedRate⽅法3.2 scheduleWithFixedDelay⽅法4、Quartz框架实现4.1 Quartz集成5、Spring Task5.1 fixedDelay和fixedRate的区别5.2 Spring Task的缺点6、分布式任务调度6.1 Quartz分布式6.2 轻量级神器XXL-Job6.3 其他框架7、⼩结前⾔：⼏乎在所有的项⽬中，定时任务的使⽤都是不可或缺的，如果使⽤不当甚⾄会造成资损。

还记得多年前在做⾦融系统时，出款业务是通过定时任务对外打款，当时由于银⾏接⼝处理能⼒有限，外加定时任务使⽤不当，导致发出⼤量重复出款请求。

还好在后⾯环节将交易卡在了系统内部，未发⽣资损。

所以，系统的学习⼀下定时任务，是⾮常有必要的。

这篇⽂章就带⼤家整体梳理学习⼀下Java领域中常见的⼏种定时任务实现。

1、线程等待实现先从最原始最简单的⽅式来讲解。

可以先创建⼀个thread，然后让它在while循环⾥⼀直运⾏着，通过sleep⽅法来达到定时任务的效果。

public class Task {public static void main(String[] args) {// run in a secondfinal long timeInterval = 1000;Runnable runnable = new Runnable() {@Overridepublic void run() {while (true) {System.out.println("Hello !!");try {Thread.sleep(timeInterval);} catch (InterruptedException e) {e.printStackTrace();}}}};Thread thread = new Thread(runnable);thread.start();}}这种⽅式简单直接，但是能够实现的功能有限，⽽且需要⾃⼰来实现。

【spring-boot】springboot整合quartz实现定时任务

【spring-boot】springboot整合quartz实现定时任务在做项⽬时有时候会有定时器任务的功能，⽐如某某时间应该做什么，多少秒应该怎么样之类的。

spring⽀持多种定时任务的实现。

我们来介绍下使⽤spring的定时器和使⽤quartz定时器 1.我们使⽤spring-boot作为基础框架，其理念为零配置⽂件，所有的配置都是基于注解和暴露bean的⽅式。

2.使⽤spring的定时器: spring⾃带⽀持定时器的任务实现。

其可通过简单配置来使⽤到简单的定时任务。

@Component@Configurable@EnableSchedulingpublic class ScheduledTasks{@Scheduled(fixedRate = 1000 * 30)public void reportCurrentTime(){System.out.println ("Scheduling Tasks Examples: The time is now " + dateFormat ().format (new Date ()));}//每1分钟执⾏⼀次@Scheduled(cron = "0 */1 * * * * ")public void reportCurrentByCron(){System.out.println ("Scheduling Tasks Examples By Cron: The time is now " + dateFormat ().format (new Date ()));}private SimpleDateFormat dateFormat(){return new SimpleDateFormat ("HH:mm:ss");}}没了，没错，使⽤spring的定时任务就这么简单，其中有⼏个⽐较重要的注解： @EnableScheduling：标注启动定时任务。

Spring4定时器cronTrigger和simpleTrigger实现方法

Spring4定时器cronTrigger和simpleTrigger实现⽅法spring4定时器 cronTrigger和simpleTrigger实现⽅法Quartz 是个开源的作业调度框架，为在应⽤程序中进⾏作业调度提供了简单却强⼤的机制。

Quartz 允许开发⼈员根据时间间隔（或天）来调度作业。

它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。

整合了 Quartz 的应⽤程序可以重⽤来⾃不同事件的作业，还可以为⼀个事件组合多个作业。

SimpleTrigger 当需要在规定的时间执⾏⼀次或在规定的时间段以⼀定的时间间隔重复触发执⾏Job时，SimpleTrigger就可以满⾜要求；SimpleTrigger的属性有：开始时间、结束时间、重复次数和重复的时间间隔，重复次数属性的值可以为0、正整数、或常量 SimpleTrigger.REPEAT_INDEFINITELY，重复的时间间隔属性值必须为0或长整型的正整数，以毫秒作为时间单位，当重复的时间间隔为0时，意味着与Trigger同时触发执⾏（或⼏乎与Scheduler开始时同时触发执⾏）。

如果有指定结束时间属性值，则结束时间属性优先于重复次数属性，这样的好处在于：当我们需要创建⼀个每间隔10秒钟触发⼀次直到指定的结束时间的 Trigger，⽽⽆需去计算从开始到结束的所重复的次数，我们只需简单的指定结束时间和使⽤REPEAT_INDEFINITELY作为重复次数的属性值即可（我们也可以指定⼀个⽐在指定结束时间到达时实际执⾏次数⼤的重复次数）。

CronTrigger ⽀持⽐ SimpleTrigger 更具体的调度，⽽且也不是很复杂。

基于 cron 表达式，CronTrigger ⽀持类似⽇历的重复间隔，⽽不是单⼀的时间间隔。

Cron 表达式包括以下 7 个字段：格式: [秒] [分] [⼩时] [⽇] [⽉] [周] [年]序号说明是否必填允许填写的值允许的通配符1 秒是 0-59 , - * /2 分是 0-59 , - * /3 ⼩时是 0-23 , - * /4 ⽇是 1-31 , - * ? / L W5 ⽉是 1-12 or JAN-DEC , - * /6 周是 1-7 or SUN-SAT , - * ? / L #7 年否 empty 或 1970-2099 , - * /Quartz官⽅⽹站对SimpleTrigger和CronTrigger的简单对⽐：SimpleTrigger is handy if you need 'one-shot' execution (just single execution of a job at a given moment in time), or if you need to fire a job at a given time, and have it repeat N times, with a delay of T between executions.当你需要的是⼀次性的调度（仅是安排单独的任务在指定的时间及时执⾏），或者你需要在指定的时间激活某个任务并执⾏N次，设置每次任务执⾏的间隔时间T。

SpringBoot定时任务动态修改cron表达式改变执行周期

SpringBoot定时任务动态修改cron表达式改变执⾏周期⼀、场景引⼊前不久做过⼀个根据下载指令定时下载⽂件到服务器的需求。

轮询下载的周期需要根据下载任务量的⼤⼩动态修改，下载任务密集的时候就周期缩⼩，下载任务少量时就扩⼤周期时间。

java本⾝和第三⽅开源框架Spring共有三种执⾏定时任务的⽅式：1) Java⾃带的java.util.Timer类：这个类允许你调度⼀个java.util.TimerTask任务。

(这种⽅式⽐较古⽼，⾃从第三⽅开源框架出现以来，基本不使⽤java⾃带的定时任务组件)2) 开源的第三⽅框架： Quartz 或者 elastic-job ，但是这个⽐较复杂和重量级，适⽤于分布式场景下的定时任务，可以根据需要多实例部署定时任务。

3) 使⽤Spring提供的注解： @Schedule 。

如果定时任务执⾏时间较短，并且⽐较单⼀，可以使⽤这个注解。

以上三种执⾏定时任务的⽅式都只能固定执⾏周期，⼀旦定时任务跑起来之后就不可能修改周期，只能修改周期后重新启动，现在需要动态修改执⾏周期，故这三种⽅式都不能使⽤。

⼆、解决⽅式既然不能⽤通过传统的⽅式，那就要想到强⼤的第三⽅开源框架带来的便利，Spring从3.0版本开始在框架中加⼊了⼀个新的定时任务线程池配置类，即：org.springframework.scheduling.concurrent包中有⼀个ThreadPoolTaskScheduler类，它继承了抽象类ExecutorConfigurationSupport并实现了AsyncListenableTaskExecutor，SchedulingTaskExecutor，TaskScheduler三个接⼝，其中实现了TaskScheduler中的⼀个⽅法：ScheduledFuture<?> schedule(Runnable task, Trigger trigger)源码：@Overridepublic ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {ScheduledExecutorService executor = getScheduledExecutor();try {ErrorHandler errorHandler =(this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();}catch (RejectedExecutionException ex) {throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);}}通过源码即可发现只要将对应的定时任务的线程以及包含cron表达式的 Trigger 参数传⼊即可按指定的周期启动定时任务。

SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）

SpringBoot中并发定时任务的实现、动态定时任务的实现（看这⼀篇就够了）原创不易，如需转载，请注明出处，否则将追究法律责任！！！⼀、在JAVA开发领域，⽬前可以通过以下⼏种⽅式进⾏定时任务1、单机部署模式Timer：jdk中⾃带的⼀个定时调度类，可以简单的实现按某⼀频度进⾏任务执⾏。

提供的功能⽐较单⼀，⽆法实现复杂的调度任务。

ScheduledExecutorService：也是jdk⾃带的⼀个基于线程池设计的定时任务类。

其每个调度任务都会分配到线程池中的⼀个线程执⾏，所以其任务是并发执⾏的，互不影响。

Spring Task：Spring提供的⼀个任务调度⼯具，⽀持注解和配置⽂件形式，⽀持Cron表达式，使⽤简单但功能强⼤。

Quartz：⼀款功能强⼤的任务调度器，可以实现较为复杂的调度功能，如每⽉⼀号执⾏、每天凌晨执⾏、每周五执⾏等等，还⽀持分布式调度，就是配置稍显复杂。

2、分布式集群模式（不多介绍，简单提⼀下）问题：I、如何解决定时任务的多次执⾏？II、如何解决任务的单点问题，实现任务的故障转移？问题I的简单思考：1、固定执⾏定时任务的机器（可以有效避免多次执⾏的情况，缺点就是单点故障问题）。

2、借助Redis的过期机制和分布式锁。

3、借助mysql的锁机制等。

成熟的解决⽅案：1、Quartz：可以去看看这篇⽂章[Quartz分布式]( https:///jiafuwei/p/6145280.html)。

2、elastic-job：（https:///elasticjob/elastic-job-lite）当当开发的弹性分布式任务调度系统，采⽤zookeeper实现分布式协调，实现任务⾼可⽤以及分⽚。

3、xxl-job:（https:///xuxueli/xxl-job）是⼤众点评员发布的分布式任务调度平台，是⼀个轻量级分布式任务调度框架。

4、saturn:(https:///vipshop/Saturn) 是唯品会提供⼀个分布式、容错和⾼可⽤的作业调度服务框架。

springboot集成schedule实现定时任务

springboot集成schedule实现定时任务背景在项⽬开发过程中，我们经常需要执⾏具有周期性的任务。

通过定时任务可以很好的帮助我们实现。

我们拿常⽤的⼏种定时任务框架做⼀个⽐较：从以上表格可以看出，Spring Schedule框架功能完善，简单易⽤。

对于中⼩型项⽬需求，Spring Schedule是完全可以胜任的。

1、springboot集成schedule1.1 添加maven依赖包由于Spring Schedule包含在spring-boot-starter基础模块中了，所有不需要增加额外的依赖。

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies>1.2 启动类，添加启动注解在springboot⼊⼝或者配置类中增加@EnableScheduling注解即可启⽤定时任务。

@EnableScheduling@SpringBootApplicationpublic class ScheduleApplication {public static void main(String[] args) {SpringApplication.run(ScheduleApplication.class, args);}}1.3.添加定时任务我们将对Spring Schedule三种任务调度器分别举例说明。

springboot定时任务（多线程）

springboot定时任务（多线程）直接上代码：1、定义⼀个配置类import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.annotation.EnableAsync;import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import java.util.concurrent.Executor;@Configuration@EnableAsyncpublic class ScheduleConfig {@Value("${schedule.corePoolSize}") // 引⼊yml配置private int corePoolSize;@Value("${schedule.maxPoolSize}")private int maxPoolSize;@Value("${schedule.queueCapacity}")private int queueCapacity;@Beanpublic Executor taskExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(corePoolSize);executor.setMaxPoolSize(maxPoolSize);executor.setQueueCapacity(queueCapacity);executor.initialize();return executor;}}application.ymlschedule:corePoolSize: 10maxPoolSize: 100queueCapacity: 102、定义需要按时执⾏的服务corn语句在线⽣成器：说明：可能会遇到定时任务⼀下次执⾏多次的情况，这是由于执⾏速度很快，corn语句匹配仍然⽣效导致的。

Spring内置定时任务调度@Scheduled使用详解

Spring内置定时任务调度@Scheduled使⽤详解Spring提供了@Scheduled注解⽤于定时任务。

⼀、@Scheduled的基本使⽤启⽤调度⽀持：@EnableScheduling可以将@Scheduled注释与触发器元数据⼀起添加到⽅法中。

例如，以下⽅法每隔5秒调⽤⼀次，并具有固定的延迟，这意味着周期是从前⾯每次调⽤的完成时间开始计算的@Scheduled(fixedDelay=5000)public void doSomething() {// something that should execute periodically}如果需要固定速率执⾏，可以更改批注中指定的属性名。

以下⽅法每5秒调⽤⼀次（在每次调⽤的连续开始时间之间计算）@Scheduled(fixedRate=5000)public void doSomething() {// something that should execute periodically}对于固定延迟和固定速率任务，可以通过指⽰在⾸次执⾏⽅法之前要等待的毫秒数来指定初始延迟@Scheduled(initialDelay=1000, fixedRate=5000)public void doSomething() {// something that should execute periodically}如果简单的周期性调度不够表达，可以提供cron表达式。

例如，以下命令仅在⼯作⽇执⾏：@Scheduled(cron="*/5 * * * * MON-FRI")public void doSomething() {// something that should execute on weekdays only}实现SchedulingConfigurer接⼝，重写configureTasks⽅法：@Schedule注解的⼀个缺点就是其定时时间不能动态更改，它适⽤于具有固定任务周期的任务，若要修改任务执⾏周期，只能⾛“停服务→修改任务执⾏周期→重启服务”这条路。

Springboot自带定时任务实现动态配置Cron参数方式

Springboot⾃带定时任务实现动态配置Cron参数⽅式⽬录Springboot⾃带定时任务实现动态配置Cron参数SpringBoot定时任务的四种实现⽅式(主要)spring动态配置cron表达式，不需要停服SchedulingConfigurer接⼝实现动态加载cron表达式Springboot⾃带定时任务实现动态配置Cron参数同学们，我今天分享⼀下SpringBoot动态配置Cron参数。

场景是这样⼦的：后台管理界⾯对定时任务进⾏管理，可动态修改执⾏时间，然后保存⼊库，每次任务执⾏前从库⾥查询时间，以达到动态修改Cron参数的效果。

好，咱们⼀起来看看是怎么回事。

SpringBoot定时任务的四种实现⽅式(主要)Timer：这是java⾃带的java.util.Timer类，这个类允许你调度⼀个java.util.TimerTask任务。

使⽤这种⽅式可以让你的程序按照某⼀个频度执⾏，但不能在指定时间运⾏。

⼀般⽤的较少。

ScheduledExecutorService：也jdk⾃带的⼀个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的⼀个线程去执⾏,也就是说,任务是并发执⾏,互不影响。

Spring Task：Spring3.0以后⾃带的task，可以将它看成⼀个轻量级的Quartz，⽽且使⽤起来⽐Quartz简单许多。

Quartz：这是⼀个功能⽐较强⼤的的调度器，可以让你的程序在指定时间执⾏，也可以按照某⼀个频度执⾏，配置起来稍显复杂。

1.1使⽤Timer这是让你按照固定的频率去执⾏⼀个任务，不能指定时间。

public class TestTimer {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.println("task run:"+ new Date());}};Timer timer = new Timer();//安排指定的任务在指定的时间开始进⾏重复的固定延迟执⾏。

定时任务的N种解决方案

定时任务的N种解决⽅案
1, java 有个延时任务接⼝ DelayQueue 实现这个接⼝可以做到延时队列
缺点:耗费资源，不持久( java程序重启后丢失 )，
2. 基于spring 定时任务。

缺点:定时执⾏，不能灵活的指定时间，时间误差⽐较⼤
3. 基于java的查询机制，每次使⽤数据的时候检查⼀下是否满⾜任务条件。

保证每次看到的结果都是正确的（保证关系的数据都正确的变化，不关⼼的数据是否正确⽆所谓）。

缺点。

效率低，及时性不⾼
4.基于redis 的过期事件
有点：效率极⾼，缺点。

redis的过期事件没有持久，触发即忘。

不可持久。

如果没有收到过期事件，那么过期事件必然丢失。

5.基于mq 的延时消息
⽬前来说做最好的⼀种⽅案。

及时性⾼，可持久。

效率⾼。