Java中如何实现定时任务？

水w

已于 2024-10-06 23:34:08 修改

阅读量505

点赞数 13

分类专栏： java 文章标签： java 开发语言定时任务

于 2024-10-06 23:22:29 首次发布

本文链接：https://blog.csdn.net/qq_45956730/article/details/142728761

版权

java 专栏收录该内容

61 篇文章 8 订阅

订阅专栏

1. Thread线程等待（最原始最简单方式）

2. 使用java.util.Timer

Timer 优缺点分析

3. 使用JDK自带的ScheduledExecutorService

schedule和scheduleAtFixedRate的区别

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

scheduleAtFixedRate保持执行频率的稳定

4. 使用SpringTask实现定时任务

一、定时任务

概念

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

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

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

作用

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

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

今天我们来讨论一下在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);

第0~1秒，等待状态；
第1秒，第一个任务开始执行，执行耗时3秒；
计算第二个任务的预定执行时间：第一个任务的起始执行时间 + 任务执行周期两秒钟 = 1+2=3，所以第3秒是第二个任务的预定执行时间；
第4秒，第一个任务执行完毕，但是发现当前时间已经超过了第二个任务的预定执行时间，所以第二个任务立即执行，第二个任务的执行时间是1秒钟；
计算第三个任务的预定执行时间：第二个任务起始执行时间+任务执行周期两秒钟=4+2=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的策略是如果错过了，就努力追上原来的节奏（制定好的节奏）。

简而言之：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 // 开启定时任务
@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 {
    @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.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。