目录
一、定时任务
概念
作用
二、简单定时任务实现方式
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() { @Override public 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; @Override public 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() { @Override public 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) { // 定时任务1 TimerTask timerTask = new TimerTask() { @Override public 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); } }; // 定时任务2 TimerTask timerTask2 = new TimerTask() { @Override public 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的Timer和TimerTask类来实现定时任务的调度。以下是对代码的分析：
将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) { // 定时任务1 TimerTask timerTask = new TimerTask() { @Override public 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); } }; // 定时任务2 TimerTask timerTask2 = new TimerTask() { @Override public 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() { @Override public 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);
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的策略是如果错过了，就努力追上原来的节奏（制定好的节奏）。
简而言之：schedule的策略是错过了就错过了，后续按照新的节奏来走；scheduleAtFixedRate的策略是如果错过了，就努力追上原来的节奏。
4. 使用SpringTask实现定时任务
从Spring 3开始，Spring自带了一套定时任务工具Spring-Task（基于注解 @Scheduled，@EnableScheduling 形式实现），可以把它看成是一个轻量级的Quartz，使用起来十分简单，除Spring相关的包外不需要额外的包，支持注解和配置文件两种形式。通常情况下在Spring体系内，针对简单的定时任务，可直接使用Spring提供的功能。
如果你在使用Spring框架，可以利用@Scheduled注解来方便地实现定时任务。首先，需要确保你的Spring配置中启用了任务调度功能。如果是在Spring Boot项目中，需要在启动类上添加@EnableScheduling来开启定时任务。
以 Spring Boot 为例，实现定时任务只需两步：
开启定时任务添加定时任务（1）开启定时任务
如果是在Spring Boot项目中，需要在启动类上添加@EnableScheduling来开启定时任务
@EnableScheduling // 开启定时任务@SpringBootApplicationpublic 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：触发器，定义了任务的触发条件，如时间、周期等。 SimpleTriggerCronTirgger：和 Unix 的 cron 机制基本一样，基于通用的公历。DateIntervalTriggerNthIncludedDayTriggerJobDataMap：任务数据映射，用于传递任务执行时所需的数据。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 { @Override public 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.JobStoreTXorg.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegateorg.quartz.jobStore.dataSource = myDSorg.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。