Java中如何实现定时任务?

目录

一、定时任务

概念

作用

二、简单定时任务实现方式

1. Thread线程等待(最原始最简单方式)

2. 使用java.util.Timer

Timer 优缺点分析

3. 使用JDK自带的ScheduledExecutorService

 schedule和scheduleAtFixedRate的区别

schedule侧重保持间隔时间的稳定

scheduleAtFixedRate保持执行频率的稳定

4. 使用SpringTask实现定时任务

三、分布式定时任务实现方式

1. Quartz

示例:使用Quartz进行定时任务调度

Quartz的持久化

2. XXL-Job

3. Elastic-Job

比较

四、总结


一、定时任务

概念

定时任务是一种自动化执行特定操作的方式,可以根据预定的时间、日期或间隔周期性地执行某些任务。

在平常的生活中,大家肯定是有设置闹钟的习惯,我们需要通过闹钟来提醒我们到这个时刻,我们应该做指定的事情。同样的在编程当中,我们很多时候也是需要实现这样的操作的,到达指定的时刻,我们想要我们的程序去执行某一个事情,比如:指定时间发送邮箱、指定时间发送生日祝福……

以上的种种到达指定时间做指定事情,就是定时任务。

作用

  • 自动化任务执行:定时任务能够在预定的时间触发执行某些任务,无需人工干预。这对于需要定期执行的重复性任务非常有效,例如数据备份、统计报表生成、系统维护等。
  • 提高效率和准确性:通过定时任务,可以在特定的时间段内自动执行任务,避免了人工操作的疏忽和错误。这样可以提高任务的执行效率和准确性,并降低因人为原因导致的错误风险。
  • 节省时间和资源:定时任务可以代替人工手动执行的操作,节省了大量人力资源和时间成本。同时,它也可以合理分配系统资源,避免任务集中导致的系统负载过高。
  • 异步执行:定时任务可以在后台异步执行,不会阻塞用户的其他操作。这对于需要执行耗时较长的任务或需要长时间运行的操作非常有用,可以提高系统的响应速度和用户体验。

二、简单定时任务实现方式

今天我们来讨论一下在Java中如何实现定时任务。定时任务在很多场景下都非常有用,例如定期执行清理工作、数据备份、发送通知等。

在Java中,常见的可以实现定时任务的方式有如下几种:

(1)线程类实现定时任务:比如Thread、Runnable、Callable等线程类都可以实现定时任务。

(2)Timer/TimerTask:Java提供了java.util.Timer和java.util.TimerTask类,可以用于创建定时任务。通过创建一个Timer对象,并调用其schedule()方法,可以指定任务的执行时间和执行间隔。然后,创建一个继承自TimerTask的子类,实现具体的任务逻辑,并在run()方法中定义需要执行的代码。最后,将该任务对象通过Timer的schedule()方法进行调度即可。

(3)ScheduledExecutorService:Java提供了java.util.concurrent.ScheduledExecutorService接口,可以用于创建定时任务。通过调用ScheduledExecutorService的scheduleAtFixedRate()或scheduleWithFixedDelay()方法,可以指定任务的执行时间和执行间隔。然后,创建一个实现了Runnable接口的类,实现具体的任务逻辑,并在run()方法中定义需要执行的代码。最后,将该任务对象提交给ScheduledExecutorService进行调度即可。

(4)@Scheduled注解:这个是Spring框架所提供的,通过在方法上添加@Scheduled注解,并设置相应的时间表达式,就可以让方法按照指定的时间间隔自动执行。

1. Thread线程等待(最原始最简单方式)

创建一个thread,然后让它在while循环里一直运行着,通过sleep方法来达到定时任务的效果。

/*** 匿名内部类实现 java.lang.Runnable 接口*/
public class ThreadTask {public static void main(String[] args) {final long timeInterval = 1000;//创建线程(匿名内部类方式)Thread thread = new Thread(new Runnable() {@Overridepublic void run() {while (true){SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");String dateStr = sdf.format(new Date());System.out.println("线程等待实现定时任务:" + dateStr);try {Thread.sleep(timeInterval);} catch (InterruptedException e) {e.printStackTrace();}}}});//开启线程thread.start();}
}
public class ThreadTask1 {public static void main(String[] args) {MyRunnable runnable = new MyRunnable();//创建线程(自定义类MyRunnable实现java.lang.Runnable接口)Thread t = new Thread(runnable);//开启线程t.start();}
}/*** 自定义类MyRunnable实现java.lang.Runnable接口*/
class MyRunnable implements Runnable{final long timeInterval = 1000;@Overridepublic void run() {while (true){SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");String dateStr = sdf.format(new Date());System.out.println("线程等待实现定时任务1:" + dateStr);try {Thread.sleep(timeInterval);} catch (InterruptedException e) {e.printStackTrace();}}}
}

2. 使用java.util.Timer

JDK自带的Timer API算是最古老的定时任务实现方式了。Timer是一种定时器工具,使用java.util.Timer工具类。用来在一个后台线程计划执行指定任务。它可以安排任务“执行一次”或者定期“执行多次”。

Timer类核心方法如下:

// 在指定延迟时间后执行指定的任务
schedule(TimerTask task,long delay);// 在指定时间执行指定的任务。(只执行一次)
schedule(TimerTask task, Date time);// 延迟指定时间(delay)之后,开始以指定的间隔(period)重复执行指定的任务
schedule(TimerTask task,long delay,long period);// 在指定的时间开始按照指定的间隔(period)重复执行指定的任务
schedule(TimerTask task, Date firstTime , long period);// 在指定的时间开始进行重复的固定速率执行任务
scheduleAtFixedRate(TimerTask task,Date firstTime,long period);// 在指定的延迟后开始进行重复的固定速率执行任务
scheduleAtFixedRate(TimerTask task,long delay,long period);// 终止此计时器,丢弃所有当前已安排的任务。
cancal();// 从此计时器的任务队列中移除所有已取消的任务。
purge();
import java.util.Timer;
import java.util.TimerTask;public class TimerExample {public static void main(String[] args) {TimerTask task = new TimerTask() {@Overridepublic void run() {System.out.println("Task executed at: " + System.currentTimeMillis());}};Timer timer = new Timer();// 安排任务在1秒后执行,并且每隔1秒执行一次timer.scheduleAtFixedRate(task, 1000, 1000);}
}

在这个示例中,我们创建了一个Timer对象,并用scheduleAtFixedRate方法安排一个TimerTask在1秒后开始执行,并且每隔1秒执行一次。

Timer 优缺点分析

优点:JDK自带的,简单易用。

缺点:

(1)对系统时间敏感

Timer类的任务调度是基于绝对时间的,而不是相对时间,所以它对系统时间的改变非常敏感。当系统时间发生变化时,可能导致任务执行时间的误差。

(2)不适合高并发场景

由于Timer类使用单个线程执行所有任务,不适合在高并发环境下使用。当任务过多或任务执行时间较长时,会影响整体性能和响应性。

(3)任务的无法持久化

当应用程序关闭或重启时,Timer 中已经调度的任务会丢失。

(4)单线程执行

Timer类内部使用单个线程来执行所有的定时任务。如果某个任务执行时间过长,会影响其他任务的执行,可能导致任务被延迟。

当一个任务的执行时间过长时,会影响其他任务的调度。

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;/*** @author water* @date 2024/10/5*/
public class Main {public static void main(String[] args) {// 定时任务1TimerTask timerTask = new TimerTask() {@Overridepublic void run() {SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");String dateStr = sdf.format(new Date());System.out.println("进入定时任务1:" + dateStr);// 休眠5秒try {TimeUnit.SECONDS.sleep(5);}catch (InterruptedException e) {e.printStackTrace();}dateStr = sdf.format(new Date());System.out.println("运行定时任务1:" + dateStr);}};// 定时任务2TimerTask timerTask2 = new TimerTask() {@Overridepublic void run() {SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");String dateStr = sdf.format(new Date());System.out.println("-----进入定时任务2:" + dateStr);dateStr = sdf.format(new Date());System.out.println("-----运行定时任务2:" + dateStr);}};// 计时器Timer timer = new Timer();// 添加执行任务(延迟 1s 执行,每 2s 执行一次)timer.schedule(timerTask, 1000, 2000);timer.schedule(timerTask2, 1000, 2000);}
}

这段代码展示了如何使用Java的TimerTimerTask类来实现定时任务的调度。以下是对代码的分析:

timerTask安排在延迟1秒后执行,随后每2秒执行一次。 将timerTask2也安排在延迟1秒后执行,随后每2秒执行一次。

定时任务1第一次运行时会在1秒后进入并输出时间。由于在run()方法中调用了sleep(3),这意味着此任务在执行期间会阻塞3秒。这会导致timerTask的后续执行被延迟。

定时任务2将在1秒后运行,并每2秒执行一次,但由于定时任务1在运行时阻塞了线程,可能会影响任务2的执行频率。

代码的执行结果如下,

任务调度的具体过程:

  • 刚开始主程序启动。
  • 在时间是22:14:23.108时,任务1timerTask第一次执行,打印“进入定时任务1”字符串。任务2也被调度开始执行,但由于是单线程,任务2必须等待任务1完成。
  • 在时间22:14:23.108到22:14:28.115时,任务1继续执行, 并休眠5秒,打印“运行定时任务1”字符串。此时任务2还是处于等待状态。
  • 在时间是22:14:28.115时,任务1完成。然后此时任务2就开始执行,打印“进入定时任务2”和“运行定时任务2”字符串。
  • 在时间是22:14:28.116时,因为初始的执行间隔为2秒,所以任务1再次被调度,打印“进入定时任务1”字符串。但由于被调度再次执行的任务1仍在执行,任务2再次处于等待状态。
  • 在时间是22:14:28.116到22:14:33.110时,任务1继续执行, 并休眠5秒,打印“运行定时任务1”字符串。
  • .....

当任务 1 运行时间超过设定的间隔时间时,任务 2 也会延迟执行 原本任务 1 和任务 2 的执行时间间隔都是 2s,但因为任务 1 执行了 5s,因此任务 2 的执行时间间隔也变成了10秒(和原定时间不符)。

(5)错误处理能力有限

Timer线程是不会捕获异常的,如果TimerTask抛出的了未检查异常则会导致Timer线程终止,同时Timer也不会重新恢复线程的执行,它会错误的认为整个Timer线程都会取消。同时,已经被安排单尚未执行的TimerTask也不会再执行了,新的任务也不能被调度。因此如果TimerTask抛出未检查的异常,Timer将会产生无法预料的行为。

(6)任务异常影响其他任务

使用 Timer 类实现定时任务时,当一个任务抛出异常,其他任务也会终止运行。

Timer线程是不会捕获异常的,如果TimerTask抛出的了未检查异常则会导致Timer线程终止,同时Timer也不会重新恢复线程的执行,它会错误的认为整个Timer线程都会取消。同时,已经被安排单尚未执行的TimerTask也不会再执行了,新的任务也不能被调度。

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;/*** @author water* @date 2024/10/5*/
public class Main {public static void main(String[] args) {// 定时任务1TimerTask timerTask = new TimerTask() {@Overridepublic void run() {SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");String dateStr = sdf.format(new Date());System.out.println("进入定时任务1:" + dateStr);//发生异常int num = 10 / 0;dateStr = sdf.format(new Date());System.out.println("运行定时任务1:" + dateStr);}};// 定时任务2TimerTask timerTask2 = new TimerTask() {@Overridepublic void run() {SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");String dateStr = sdf.format(new Date());System.out.println("----进入定时任务2:" + dateStr);dateStr = sdf.format(new Date());System.out.println("----运行定时任务2:" + dateStr);}};// 计时器Timer timer = new Timer();// 添加执行任务(延迟 1s 执行,每 2s 执行一次)timer.schedule(timerTask, 1000, 2000);timer.schedule(timerTask2, 1000, 2000);}
}

代码的执行结果如下, 

3. 使用JDK自带的ScheduledExecutorService

ScheduledExecutorService是Java并发包(java.util.concurrent)中的一个接口, 是JAVA 1.5后新增的定时任务接口,它是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行(任务是并发执行,互不影响)。

ScheduledExecutorService可以实现Timer具备的所有功能,并解决了 Timer类存在的问题提供了比Timer更强大的定时任务调度功能。它可以调度任务在给定的延迟后运行,或者周期性地执行。

注意:只有当执行调度任务时,ScheduledExecutorService才会真正启动一个线程,其余时间ScheduledExecutorService都是出于轮询任务的状态。

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*** @author water* @date 2024/10/5*/
public class Main {public static void main(String[] args) {ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);Runnable task = new Runnable() {@Overridepublic void run() {String dateTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());System.out.println("执行任务的时间:" + dateTime);}};// 安排任务在1秒后执行,并且每隔1秒执行一次scheduler.scheduleAtFixedRate(task, 1, 1, TimeUnit.SECONDS);}
}

在这个示例中,我们创建了一个ScheduledExecutorService对象,并用scheduleAtFixedRate方法安排一个任务在1秒后开始执行,并且每隔1秒执行一次。

 schedule和scheduleAtFixedRate的区别

在了解schedule与scheduleAtFixedRate方法的区别之前,先看看它们的相同点:

  • 任务执行未超时,下次执行时间 = 上次执行开始时间 + period。

  • 任务执行超时,下次执行时间 = 上次执行结束时间。

  • 在任务执行未超时时,它们都是上次执行时间加上间隔时间,来执行下一次任务。而执行超时时,都是立马执行。

它们的不同点在于侧重点不同

  • schedule方法侧重保持间隔时间的稳定。
  • scheduleAtFixedRate方法更加侧重于保持执行频率的稳定。
schedule侧重保持间隔时间的稳定

schedule是固定延迟,更加侧重保持延迟间隔的固定性。每次都是以上一个任务的起始时间来判断时间间隔。

schedule方法会因为前一个任务的延迟而导致其后面的定时任务延时。计算公式为scheduledExecutionTime(第n+1次) = realExecutionTime(第n次) + periodTime。

也就是说如果第n次执行task时,由于某种原因这次执行时间过长,执行完后的systemCurrentTime>= scheduledExecutionTime(第n+1次),则此时不做时隔等待,立即执行第n+1次task。

而接下来的第n+2次task的scheduledExecutionTime(第n+2次)就随着变成了realExecutionTime(第n+1次)+periodTime。这个方法更注重保持间隔时间的稳定。

// 延迟1s后开始执行任务,然后每隔2秒执行
timer.schedule(task, 1000, 2000);
  1. 第0~1秒,等待状态;
  2. 第1秒,第一个任务开始执行,执行耗时3秒;
  3. 计算第二个任务的预定执行时间:第一个任务的起始执行时间 + 任务执行周期两秒钟 = 1+2=3,所以第3秒是第二个任务的预定执行时间;
  4. 第4秒,第一个任务执行完毕,但是发现当前时间已经超过了第二个任务的预定执行时间,所以第二个任务立即执行,第二个任务的执行时间是1秒钟;
  5. 计算第三个任务的预定执行时间:第二个任务起始执行时间+任务执行周期两秒钟=4+2=6,所以第三个任务是预定在第6秒执行;
  6. 第5秒钟,第二个任务执行完毕,发现当前是第5秒,还未到第6秒,所以还需要等待1秒钟。

scheduleAtFixedRate保持执行频率的稳定

scheduleAtFixedRate是固定速率,更加侧重保持执行频率的稳定性。scheduleAtFixedRate当前任务到达规定时间一定执行,上一个未执行的任务会直接终止。

scheduleAtFixedRate在反复执行一个task的计划时,每一次执行这个task的计划执行时间在最初就被定下来了,也就是scheduledExecutionTime(第n次)=firstExecuteTime +n*periodTime。

如果第n次执行task时,由于某种原因这次执行时间过长,执行完后的systemCurrentTime>= scheduledExecutionTime(第n+1次),则此时不做period间隔等待,立即执行第n+1次task。

接下来的第n+2次的task的scheduledExecutionTime(第n+2次)依然还是firstExecuteTime+(n+2)*periodTime这在第一次执行task就定下来了。说白了,这个方法更注重保持执行频率的稳定。

如果用一句话来描述任务执行超时之后schedule和scheduleAtFixedRate的区别就是:schedule的策略是错过了就错过了,后续按照新的节奏来走;scheduleAtFixedRate的策略是如果错过了,就努力追上原来的节奏(制定好的节奏)。

image-20231003215712057

简而言之schedule的策略是错过了就错过了,后续按照新的节奏来走;scheduleAtFixedRate的策略是如果错过了,就努力追上原来的节奏。

4. 使用SpringTask实现定时任务

从Spring 3开始,Spring自带了一套定时任务工具Spring-Task(基于注解 @Scheduled,@EnableScheduling 形式实现),可以把它看成是一个轻量级的Quartz,使用起来十分简单,除Spring相关的包外不需要额外的包,支持注解和配置文件两种形式。通常情况下在Spring体系内,针对简单的定时任务,可直接使用Spring提供的功能。

如果你在使用Spring框架,可以利用@Scheduled注解来方便地实现定时任务。首先,需要确保你的Spring配置中启用了任务调度功能。如果是在Spring Boot项目中,需要在启动类上添加@EnableScheduling来开启定时任务。

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

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

(1)开启定时任务

如果是在Spring Boot项目中,需要在启动类上添加@EnableScheduling来开启定时任务

@EnableScheduling // 开启定时任务
@SpringBootApplication
public class Job4ScheduledApplication {public static void main(String[] args) {SpringApplication.run(Job4ScheduledApplication.class, args);}
}

(2)添加定时任务

定时任务的添加只需要使用 @Scheduled 注解标注即可,如果有多个定时任务可以创建多个 @Scheduled 注解标注的方法。

@Component  //@Component用于实例化类,将其类托管给 Spring 容器
public class TaskJobUtil {/*** cron表达式:表示每2秒 执行任务*/@Scheduled(cron = "0/2 * * * * ?")public void task() {System.out.println("task0-start");sleep(5);System.out.println("task0-end");}/*** fixedRate:每间隔2秒执行一次任务* 注意,默认情况下定时任务是在同一线程同步执行的,如果任务的执行时间(如5秒)大于间隔时间,则会等待任务执行结束后直接开始下次任务*/@Scheduled(fixedRate = 2000)public void task0() {System.out.println("task0-start");sleep(5);System.out.println("task0-end");}/*** fixedDelay:每次延时2秒执行一次任务* 注意,这里是等待上次任务执行结束后,再延时固定时间后开始下次任务*/@Scheduled(fixedDelay = 2000)public void task1() {System.out.println("task1-start");sleep(5);System.out.println("task1-end");}/*** initialDelay:首次任务启动的延时时间*/@Scheduled(initialDelay = 2000, fixedDelay = 3000)public void task2() {System.out.println("task2-start");sleep(5);System.out.println("task2-end");}private void sleep(long time) {try {TimeUnit.SECONDS.sleep(time);} catch (InterruptedException e) {e.printStackTrace();}}
}

三、分布式定时任务实现方式

前面所有的定时任务,无论是基于线程类,还是基于 JDK 自带的定时任务,还是基于Spring提供的Spring Task,都无法在分布式环境下使用,并且不支持持久化,一旦服务重启所有的定时任务都将发生丢失,所以我们需要使用到其它的第三方成熟的定时任务框架。

1. Quartz

除了JDK自带的API之外,我们还可以使用开源的框架来实现,比如Quartz。Quartz是一个开源的任务调度库,用于在Java应用程序中实现定时任务调度和作业调度。,它允许开发者通过配置或编程方式定义、调度和管理任务。

使用Quartz可以开发一个或者多个定时任务,每个定时任务可以单独指定执行的时间,例如每隔1小时执行一次、每个月第一天上午10点执行一次、每个月最后一天下午5点执行一次等。

Quartz既可以单独使用也可以跟spring框架整合使用,在实际开发中一般会使用后者。

(1)Quartz的核心功能包括:

  • 任务调度:定义任务的执行计划,并在指定时间或周期性执行任务。
  • 任务管理:管理和控制任务的生命周期,如启动、暂停、删除等。
  • 持久化:支持将任务的状态持久化到数据库,以便在应用重启后恢复任务状态。

(2)Quartz架构图如下:

Quartz主要由以下几个核心组件组成:

  • Scheduler:调度器,是Quartz的核心,用于管理和调度任务。
  • Job:任务接口,定义任务的执行逻辑,即具体要执行的任务。所有Quartz任务必须实现这个接口。
  • JobDetail:任务细节对象,定义了任务的具体实现和执行参数。
  • Trigger:触发器,定义了任务的触发条件,如时间、周期等。
    • SimpleTrigger
    • CronTirgger:和 Unix 的 cron 机制基本一样,基于通用的公历。
    • DateIntervalTrigger
    • NthIncludedDayTrigger
  • JobDataMap:任务数据映射,用于传递任务执行时所需的数据。

JobDetail就是对job的定义,而job是具体执行的逻辑内容。 具体的执行的逻辑需要实现 job类,并实现execute方法。如果使用JobDetail来定义,那么每次调度都会创建一个new job实例,这样带来的好处就是任务并发执行的时候,互不干扰,不会对临界资源造成影响。

(3)Quartz的使用步骤

使用Quartz进行定时任务调度通常包括以下步骤:

  • 创建任务类:实现Job接口,定义任务的执行逻辑。
  • 配置调度器:创建并配置Scheduler实例。
  • 定义任务细节:创建JobDetail对象,指定任务类及其参数。
  • 定义触发器:创建Trigger对象,指定任务的触发条件。
  • 启动调度器:将任务细节和触发器注册到调度器,并启动调度器。

示例:使用Quartz进行定时任务调度

以下是一个使用Quartz进行定时任务调度的完整示例:

(1)创建任务类

在这个示例中,HelloJob类实现了Job接口,定义了任务的执行逻辑,即打印一条消息。

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;public class HelloJob implements Job {@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("Hello, Quartz!");}
}

HelloJob 类该类实现了 Job 接口。实现了Quartz 调度器调用的核心方法 execute 方法。

execute 方法的JobExecutionContext context 参数允许作业访问调度上下文中的信息,如触发器、调度器等。在方法体内,使用 System.out.println("Hello, Quartz!"); 打印一条简单的消息,表示作业被执行。

(2)配置调度器

在这个示例中,我们创建了一个调度器,并定义了一个任务和一个触发器。任务HelloJob每10秒执行一次,并在控制台上打印消息。

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobDataMap;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.SimpleScheduleBuilder;public class QuartzExample {public static void main(String[] args) {try {// 创建调度器工厂SchedulerFactory schedulerFactory = new org.quartz.impl.StdSchedulerFactory();Scheduler scheduler = schedulerFactory.getScheduler();// 定义任务细节JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").usingJobData("key", "value") // 传递任务数据.build();// 定义触发器Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1").startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(10) // 每10秒执行一次.repeatForever()).build();// 将任务细节和触发器注册到调度器scheduler.scheduleJob(jobDetail, trigger);// 启动调度器scheduler.start();} catch (SchedulerException e) {e.printStackTrace();}}
}

在这个示例中,我们创建一个调度器工厂的实例schedulerFactory,使用默认的标准调度器工厂。从调度器工厂获取一个调度器实例scheduler,用于安排和执行任务。

然后,创建一个新的任务细节,指定作业类为 HelloJob。该类应该实现 org.quartz.Job 接口。为任务指定唯一的标识符,名称为 "myJob",组名为 "group1"。通过 JobDataMap 向任务传递参数,方便在作业执行时使用。构建最终的 JobDetail 对象。

创建一个新的触发器构建器实例,为触发器指定唯一的标识符,名称为 "myTrigger",组名为 "group1",设置触发器为立即开始执行。使用简单调度器定义触发规则:设置触发器每 10 秒执行一次,并且使触发器无限期重复执行。构建最终的 Trigger 对象。

将任务和触发器注册到调度器中,使其能够根据触发器的调度规则执行任务。

启动调度器,使其开始调度任务。

(3)使用Cron表达式

Quartz支持使用Cron表达式来定义更复杂的触发条件。Cron表达式是一种字符串格式,用于表示任务的触发时间。以下是一个使用Cron表达式的示例:

Trigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("myCronTrigger", "group1").withSchedule(CronScheduleBuilder.cronSchedule("0 0/5 * * * ?")) // 每5分钟执行一次.build();

在这个示例中,创建了一个名为 "myCronTrigger" 的 Cron 触发器,它每 5 分钟触发一次。Cron表达式"0 0/5 * * * ?"表示任务将在每5分钟的开始时刻执行一次。

Quartz的持久化

Quartz支持将任务的状态持久化到数据库,以便在应用重启后恢复任务状态。要使用持久化功能,需要配置Quartz的持久化存储。

(1)配置持久化存储

quartz.properties文件中配置数据库连接和持久化存储,

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.dataSource = myDS
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.isClustered = true

还需要配置数据源myDS,以便Quartz能够连接到数据库。

(2)数据库表

Quartz提供了创建数据库表的SQL脚本,可以在Quartz官网下载。执行这些脚本将创建Quartz所需的表。

2. XXL-Job

XXL-Job是一个轻量级分布式任务调度平台。特点是平台化,易部署,开发迅速、学习简单、轻量级、易扩展。由调度中心和执行器功能完成定时任务的执行。调度中心负责统一调度,执行器负责接收调度并执行。

3. Elastic-Job

Elastic-Job是一个开源的分布式任务调度解决方案,它是基于Java的轻量级分布式调度框架。

比较

三者的比较

  • 功能和特性:
    • Quartz:Quartz是一个功能强大的作业调度框架,支持灵活的任务调度策略、分布式集群、任务持久化等特性。它具有丰富的API和扩展点,可以根据需求进行定制开发和扩展。
    • XXL-Job:XXL-Job是一个分布式任务调度平台,提供了可视化操作界面、多种任务调度方式、分片任务支持等特性。它注重于任务的管理和监控,并提供了报警与告警功能。
    • Elastic-Job:Elastic-Job是一个轻量级的分布式任务调度解决方案,支持分布式任务调度、弹性扩缩容、任务监控和管理等特性。它注重于任务的弹性扩展和容错机制。
  • 分布式支持:
    • Quartz:Quartz在分布式场景中需要基于数据库锁来保证操作的唯一性,通过多个节点的异步运行实现高可用性。但它没有执行层面的任务分片机制。
    • XXL-Job:XXL-Job提供了分布式集群的支持,可以实现任务的负载均衡和高可用性。它支持分片任务和动态调整任务节点数量的特性。
    • Elastic-Job:Elastic-Job支持分布式任务调度,具备弹性扩缩容能力,可以根据任务的执行情况动态调整任务节点数量。
  • 可视化和管理界面:
    • Quartz:Quartz本身没有提供可视化的任务管理界面,需要通过其他工具或自行开发来实现。
    • XXL-Job:XXL-Job提供了简洁直观的任务管理界面,方便用户进行任务的创建、编辑、状态查看等操作。
    • Elastic-Job:Elastic-Job提供了任务监控和管理功能,可以查看任务的执行日志、运行状态、统计信息等。
  • 社区活跃度和生态系统:
    • Quartz:Quartz是一个非常成熟且广泛使用的作业调度框架,拥有强大的社区支持和丰富的生态系统。
    • XXL-Job:XXL-Job也有一个活跃的社区,并且在国内得到广泛应用和认可。
    • Elastic-Job:Elastic-Job相对较新,并且社区规模较小,但其在分布式任务调度领域有一定的影响力。
  • 应用场景:
    • Quartz在功能和扩展性上非常强大,适用于复杂的任务调度需求。
    • XXL-Job注重于任务管理和监控,并提供了可视化的操作界面。
    • Elastic-Job轻量级且具备分布式任务调度和弹性扩缩容能力。

四、总结

(1)线程+休眠实现定时任务,是最简单实现定时任务的方式了,但这只是提供一种思路,实习开发中几乎不会使用。

(2)JDK自带的定时任务Timer和ScheduledExecutorService,我们需要了解两者的区别。

  • Timer是单线程的,一旦发生异常,将终止所有的任务;Timer是绝对时间的,会受到系统时间的影响。
  • ScheduledExecutorService是基于线程池,是多线程的,一旦发生异常,不会终止所有的任务;ScheduledExecutorService是相对时间 ,不会受到系统时间的影响。
  • 注意区固定间隔和固定频率的区别。

(3)Spring Task实现的定时任务是基于线程池,是多线程的,一旦发生异常,不会终止所有的任务;基于相对时间,不会受到系统时间的影响。

(4)分布式定时任务,一般是直接使用第三方成熟的定时任务框架,当然如果你公司资金充足可以选择开发定制化定时任务框架。选用开源的第三方成熟定时任务框架,好处在于功能完善、免费,代码质量也是有保障的。

如果你当前系统比较小,或者说没那么在意可靠性,可以选用 JDK自带的定时任务或者是SpringTask,否则就选用分布式定时任务框架,轻量级就可以选用 XXL-Job,大型系统可以选用Quartz。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/881202.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

B 私域模式升级:开源技术助力传统经销体系转型

一、引言 1.1 研究背景 随着市场竞争加剧,传统经销代理体系面临挑战。同时,开源技术发展迅速,为 B 私域升级带来新机遇。在当今数字化时代,企业面临着日益激烈的市场竞争。传统的经销代理体系由于管理效率低下、渠道局限、库存压…

贝锐蒲公英网盘首发,秒建私有云,高速远程访问

虽然公共网盘带来了不少便利,但是大家对隐私泄露和重要数据泄密的担忧也随之增加。如果想要确保数据安全,自建私有云似乎是一条出路,然而面对搭建私有云的复杂步骤,许多人感到力不从心,NAS设备的成本也往往让人望而却步…

项目——超级马里奥——Day(2)

争取今天晚上能搞一半啊,啊啊啊啊,感觉事多的忙不过来 设计思路: 1)创建并完成常量类 ------->一张图片的情况 先完成对图片的封装------>把图片加载一遍 (老实说,我也不太知道为什么&#xff0…

【项目安全设计】软件系统安全设计规范和标准(doc原件)

1.1安全建设原则 1.2 安全管理体系 1.3 安全管理规范 1.4 数据安全保障措施 1.4.1 数据库安全保障 1.4.2 操作系统安全保障 1.4.3 病毒防治 1.5安全保障措施 1.5.1实名认证保障 1.5.2 接口安全保障 1.5.3 加密传输保障 1.5.4终端安全保障 资料获取:私信或者进主页。…

约数个数约数之和

好久没发文章了.......不过粉丝还是一个没少...... 今天来看两道超级恶心的数论题目! No.1 约数个数 No.2 约数之和 先来看第一道:约数个数 题目描述 给定 n 个正整数 ai​,请你输出这些数的乘积的约数个数,答案对 10^97 取模 输入格式 第一行包含…

OBOO鸥柏丨OLED透明触摸查询一体机数字科技触控广告屏技术前沿

吊挂透明OLED触摸屏一体机正成为博物馆数字化展示的“共同奔赴赛道选择,透过透明屏幕看到展示物品的内部结构和细节,GG纯平面触控实现展示查询交互与互动的完美结合。相比传统的商用/工业液晶显示屏机柜,OLED透明触摸屏具有更高的对比度和更广…

佳易王电玩店ps5计时计费系统软件倒计时语音提醒软件操作教程

一、前言 【试用版软件下载可以点击最下方官网卡片】 佳易王电玩店ps5计时计费系统软件倒计时语音提醒软件操作教程 1、时间显示:正常使用时间,直观显示在对应桌旁。 2、倒计时显示:右侧显示剩余多少分钟, 3、定时语音提醒&am…

阿里云域名注册购买和备案

文章目录 1、阿里云首页搜索 域名注册2、点击 控制台3、域名控制台 1、阿里云首页搜索 域名注册 2、点击 控制台 3、域名控制台

YOLOv11改进,YOLOv11添加DCNv4可变性卷积(windows系统成功编译),二次创新C2f结构,全网最详细教程

改进训练结果前: 二次创新C2f结构训练结果: 摘要 引入了可变形卷积 v4 (DCNv4),这是一种为广泛视觉应用设计的高效且有效的操作算子。DCNv4通过两项关键增强解决了其前身DCNv3的局限性:1. 移除空间聚合中的softmax归一化,以增强其动态特性和表达能力;2. 优化内存访问以…

Task与 async 和await关键字使用和探讨

基本概念&#xff1a; Task (任务): 在 .NET 中&#xff0c;Task 表示一个可能会在未来完成的操作&#xff0c;可以是异步的&#xff0c;也可以是同步的。Task<TResult> 是返回结果的任务&#xff0c;而 Task 是不返回结果的任务。async 关键字: 标记一个方法为异步方法…

Linux:进程的创建、终止和等待

一、进程创建 1.1 fork函数初识 #include pid_t fork(void); 返回值&#xff1a;子进程中返回0&#xff0c;父进程返回子进程id&#xff0c;出错返回-1 调用fork函数后&#xff0c;内核做了下面的工作&#xff1a; 1、创建了一个子进程的PCB结构体、并拷贝一份相同的进程地址…

JavaScript for循环语句

for循环 循环语句用于重复执行某个操作&#xff0c;for语句就是循环命令&#xff0c;可以指定循环的起点、终点和终止条件。它的格式如下 for(初始化表达式;条件;迭代因子){语句} for语句后面的括号里面&#xff0c;有三个表达式 初始化表达式(initialize):确定循环变量的初始…

27 Vue3之unocss原子化

前置知识 什么是原子化 CSS 原子化 CSS 是一种 CSS 的架构方式&#xff0c;它倾向于小巧且用途单一的 class&#xff0c;并且会以视觉效果进行命名。 为什么使用 原子化 CSS 传统方案 制作原子化 CSS 的传统方案其实就是提供所有你可能需要用到的 CSS 工具。例如&#xff0c…

05:(寄存器开发)定时器一

定时器 1、系统定时器SysTick1.1、SysTick中断的使用1.2、使用SysTick制作延迟函数 2、基本定时器2.1、基本定时器中断的使用2.2、使用基本定时器制作延时函数 1、系统定时器SysTick 1.1、SysTick中断的使用 ①SysTcik系统滴答定时器和片上外设定时器不同&#xff0c;它在CPU…

第十一章 缓存之更新/穿透/雪崩/击穿

目录 一、什么是缓存 二、缓存更新策略 2.1. 缓存主动更新策略 2.1.1. Cache Aside模式&#xff08;主流&#xff09;‌ 2.1.2. Read/Write Through模式‌ 2.1‌.3. Write Behind模式‌ 2.1.4. 总结 三、缓存穿透 四、缓存雪崩 五、缓存击穿 5.1. 互斥锁实现 5.1.1…

C语言复习概要(四)

本文 1. 操作符的分类算术操作符关系操作符逻辑操作符 2. 二进制制和进制转换二进制与十六进制的表示进制转换算法 3. 原码、反码和补码原码反码补码 1. 操作符的分类 C语言中的操作符种类繁多&#xff0c;常用的主要操作符可以按照其功能进行如下分类&#xff1a; 算术操作符…

C++关于链表基础知识

单链表 // 结点的定义 template <class T> struct Node { T data ; Node <T> *next; //指向下一个node 的类型与本node相同 } // 最后一个node指针指向Null 生成结点&#xff1a; Node <T> * p new Node < T>; 为结点赋值: p-> data …

【微服务】服务注册与发现 - Eureka(day3)

CAP理论 P是分区容错性。简单来说&#xff0c;分区容错性表示分布式服务中一个节点挂掉了&#xff0c;并不影响其他节点对外提供服务。也就是一台服务器出错了&#xff0c;仍然可以对外进行响应&#xff0c;不会因为某一台服务器出错而导致所有的请求都无法响应。综上所述&…

LabVIEW机床加工监控系统

随着制造业的快速发展&#xff0c;机床加工的效率与稳定性成为企业核心竞争力的关键。传统的机床监控方式存在效率低、无法远程监控的问题。为了解决这些问题&#xff0c;开发了一种基于LabVIEW的机床加工监控系统&#xff0c;通过实时监控机床状态&#xff0c;改进生产流程&am…

PhotoMaker部署文档

一、介绍 PhotoMaker&#xff1a;一种高效的、个性化的文本转图像生成方法&#xff0c;能通过堆叠 ID 嵌入自定义逼真的人类照片。相当于把一张人的照片特征提取出来&#xff0c;然后可以生成你想要的不同风格照片&#xff0c;如写真等等。 主要特点&#xff1a; 在几秒钟内…