• Java中如何实现定时任务？

    文章目录

    定时任务基本介绍

    前言

    本文主要是对定时任务进行一个大致的了解，关于定时任务的详细使用细节，这个后面会进一步学习。通过本文你将了解定时任务是什么？Java中常见的实现定时任务的方式有哪些，以及常见的成熟的第三方定时任务框架有哪些

    基本概念介绍

    • 什么的定时任务？

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

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

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

    • 定时任务的作用？

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

    • 在Java中，常见的可以实现定时的方式有如下几种

      • 线程类实现定时任务：比如Thread、Runnable、Callable等线程类都可以实现定时任务
      • Timer/TimerTask：Java提供了java.util.Timer和java.util.TimerTask类，可以用于创建定时任务。通过创建一个Timer对象，并调用其schedule()方法，可以指定任务的执行时间和执行间隔。然后，创建一个继承自TimerTask的子类，实现具体的任务逻辑，并在run()方法中定义需要执行的代码。最后，将该任务对象通过Timer的schedule()方法进行调度即可。
      • ScheduledExecutorService：Java提供了java.util.concurrent.ScheduledExecutorService接口，可以用于创建定时任务。通过调用ScheduledExecutorService的scheduleAtFixedRate()或scheduleWithFixedDelay()方法，可以指定任务的执行时间和执行间隔。然后，创建一个实现了Runnable接口的类，实现具体的任务逻辑，并在run()方法中定义需要执行的代码。最后，将该任务对象提交给ScheduledExecutorService进行调度即可。
      • @Scheduled注解：这个是Spring框架所提供的，通过在方法上添加@Scheduled注解，并设置相应的时间表达式，就可以让方法按照指定的时间间隔自动执行。

    线程类实现定时任务

    这个了解即可，我也没有做过多介绍，在实际的生产中基本上不会使用这种方式的，使用的最多的还是后面那几种

    Thread类实现定时任务

    • Thread类实现定时任务

      class MyTimerTask extends Thread{
    /**
     * 每隔一秒钟执行一次
     */
    @Override
    public void run() {
        while (true) {
            // 执行定时任务的逻辑
            System.out.println("执行定时任务");
            try {
                // 休眠指定时间
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTimerTask());
        thread.start();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25

    Runnable接口实现定时任务

    • Runnable接口实现定时任务

      class MyTimerTask implements Runnable{
    /**
     * 每隔一秒钟执行一次
     */
    @Override
    public void run() {
        while (true) {
            // 执行定时任务的逻辑
            System.out.println("执行定时任务");
            try {
                // 休眠指定时间
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTimerTask());
        thread.start();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25

    Callable接口实现定时任务

    • Callable接口实现定时任务

      class MyTimerTask implements Callable<Object> {
    /**
     * 每隔一秒钟执行一次
     */
    @Override
    public Object call() throws Exception {
        while (true) {
            // 执行定时任务的逻辑
            System.out.println("执行定时任务");
            try {
                // 休眠指定时间
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        FutureTask<Object> timerTask = new FutureTask<>(new MyTimerTask());
        Thread thread = new Thread(timerTask);
        thread.start();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    Timer实现定时任务

    Timer的常用方法

    • Timer类的常用方法
      • schedule(TimerTask task, Date time)：在指定的时间执行任务。参数task是要执行的任务，参数time是任务的执行时间。
      • schedule(TimerTask task, long delay)：在指定的延迟时间后执行任务。参数task是要执行的任务，参数delay是任务的延迟时间（单位为毫秒）。
      • schedule(TimerTask task, long delay, long period)：在指定的延迟时间后开始执行任务，并按照指定的周期重复执行。参数task是要执行的任务，参数delay是任务的延迟时间（单位为毫秒），参数period是任务的执行周期（单位为毫秒）。
      • scheduleAtFixedRate(TimerTask task, long delay, long period)：在指定的延迟时间后开始执行任务，并以固定的速率重复执行。参数task是要执行的任务，参数delay是任务的延迟时间（单位为毫秒），参数period是任务的执行周期（单位为毫秒）。该方法会尽量保持每次任务执行的时间间隔固定。
      • cancel()：取消所有已安排的任务。调用该方法后，Timer将不再接受新任务，并尝试终止当前正在执行的任务。

    Timer的优缺点

    • Timer的优缺点
      • 优点：JDK自带的，简单易用
      • 缺点：
        • 对系统时间敏感：Timer类的任务调度是基于绝对时间的，而不是相对时间。这意味着对系统时间的改变非常敏感，当系统时间发生变化时，可能导致任务执行时间的误差。
        • 单线程执行：Timer类内部使用单个线程来执行所有的定时任务。如果某个任务执行时间过长，会影响其他任务的执行，可能导致任务被延迟。
        • 错误处理能力有限：Timer类的错误处理能力较弱。如果定时任务出现异常并抛出未捕获的异常，Timer类将会停止所有任务的执行。
        • 任务的无法持久化：当应用程序关闭或重启时，Timer 中已经调度的任务会丢失
        • 不适合高并发场景：由于Timer类使用单个线程执行所有任务，不适合在高并发环境下使用。当任务过多或任务执行时间较长时，会影响整体性能和响应性。

    schedule和scheduleAtFixedRate的区别

    • schedule和scheduleAtFixedRate的区别

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

        // 延迟1s后开始执行任务，然后每隔2秒执行
timer.schedule(task, 1000, 2000);

        • 1
        • 2

        1）第0~1秒，等待状态；

        2）第1秒，第一个任务开始执行，执行耗时3秒；

        3）计算第二个任务的预定执行时间：第一个任务的起始执行时间 + 任务执行周期两秒钟 = 1+2=3，所以第3秒是第二个任务的预定执行时间；

        4）第4秒，第一个任务执行完毕，但是发现当前时间已经超过了第二个任务的预定执行时间，所以第二个任务立即执行，第二个任务的执行时间是1秒钟；

        5）计算第三个任务的预定执行时间：第二个任务起始执行时间+任务执行周期两秒钟=4+2=6，所以第四个任务是预定在第6秒执行；

        6）第5秒钟，第二个任务执行完毕，发现当前是第5秒，还未到第6秒，所以还需要等待1秒钟

        image-20231003213924364

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

        image-20231003215712057

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

    光说没用，我们用代码来测试一下：

    class MyTimerTask extends TimerTask {
    static int i = 0;
    public void run() {
        // 定时执行的任务逻辑
        System.out.println(i+"执行定时任务开始，当前时间" + new Date());
        if (i % 2 == 0) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println(i+"执行定时任务结束，当前时间" + new Date());
        i++;
    }
}

public class Main {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new MyTimerTask();
        // 延迟0秒开始执行（也就是立即开始执行），每隔1秒执行一次
        timer.schedule(task, 0, 1000);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    image-20231004101555811

    可以看到，对于偶数，休眠3s，对于基数直接执行，间隔是1s

    1. 第一个任务耗时3s，超过了时间间隔1s，所以第二个任务立即执行
    2. 第二个任务耗时不到1s，第三个任务直接就等待1s之后才执行

    可以看到上述的过程是完全符合我之前画的那张图的，看到网上一些文章对这点存在误解，简单的认为所有的任务间隔都是固定的，所以说实践是检验真理的唯一标准

    代码示例

    class MyTimerTask extends TimerTask {
    public void run() {
        // 定时执行的任务逻辑
        System.out.println("执行定时任务");
    }
}

public class Main {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new MyTimerTask();
        // 延迟0秒开始执行（也就是立即开始执行），每隔1秒执行一次
        timer.schedule(task, 0, 1000);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    ScheduledExecutorService实现定时

    ScheduledExecutorService的常用方法

    • ScheduledExecutorService类的常用方法
      • schedule(Runnable command, long delay, TimeUnit unit): 在指定的延迟时间后执行一次任务。
      • schedule(Callable callable, long delay, TimeUnit unit): 在指定的延迟时间后执行一次任务，并返回一个可获取结果的 Future 对象。
      • scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit): 在初始延迟时间后开始执行任务，并以固定的时间间隔重复执行任务。
      • scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit): 在初始延迟时间后开始执行任务，并在每次任务完成后延迟指定的时间再执行下一次任务。
      • submit(Callable task): 提交一个可获取结果的任务，并返回一个表示任务执行结果的 Future 对象。
      • submit(Runnable task): 提交一个不返回结果的任务，并返回一个表示任务执行完成的 Future 对象。
      • shutdown(): 优雅地关闭 ScheduledExecutorService，等待已提交的任务执行完毕。
      • shutdownNow(): 强制关闭 ScheduledExecutorService，立即停止所有任务的执行。

    注意区分：

    1. ScheduledExecutorService是基于线程池的，可以在多线程的场景下使用，Timer是基于单线程的，无法在多线程下使用
    2. ScheduledExecutorService 的 两个 schedule 方法都不能重复执行，都是在指定延迟时候之后执行一次，Timer 的 schedule 方法既可以单词执行又可以重复执行
    3. ScheduledExecutorService 的 scheduleWithFixedDelay 方法功能上等价于 Timer 的 schedule(TimerTask task, long delay, long period)
    4. ScheduledExecutorService 的 scheduleAtFixedRate 方法功能上等价于 Timer 的 scheduleAtFixedRate，有一点最大的区别就是ScheduledExecutorService 的 scheduleAtFixedRate 在执行任务时抛出异常，不会像 Timer 一样立即停止所有的任务，而是会内部捕获，不会影响其它线程任务的执行

    ScheduledExecutorService的异常处理

    class MyTimerTask implements Runnable {
    public void run() {
        // 定时执行的任务逻辑
        System.out.println(Thread.currentThread().getName() + "执行定时任务");
        if (Thread.currentThread().getName().equals("pool-1-thread-1")) {
            throw new RuntimeException("pool-1-thread-1 执行任务发生了异常");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        Runnable timerTask = new MyTimerTask();
        // 延迟0秒开始执行（也就是立即开始执行），每隔1秒执行一次
        executor.scheduleAtFixedRate(timerTask, 0, 1, TimeUnit.SECONDS);
        executor.scheduleAtFixedRate(timerTask, 0, 1, TimeUnit.SECONDS);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    可以看到线程1在执行任务时，因为异常导致直接终止了，但是完全没有影响线程2继续执行任务

    image-20231003222905020

    如果是Timer的话，就直接抛异常了

    image-20231003223135126

    通过上面的Demo，我们可以看出来 ScheduledExecutorService 的任务中如果出现了异常，是压根对其它任务的执行没有一点影响的，但这也带来了一个比较大的弊端，抛出一个异常，一点信息都没有，我们完全丧失了对任务中是否有异常的一个感知能力，这个问题是会严重影响到我们定位问题，比如我们上线一个项目，这个项目的一个定时任务抛出了一个异常，导致大量定时任务的堆积，而我们无法通过日志定位到具体的异常，这就很烦人了

    常见的解决措施有如下几种

    • 方案一：try-catch

      我们直接在任务中包一个大范围的 try-catch，管你是什么异常全都给你捕获🤣

      image-20231003223848644

    • 方式二：ScheduledFuture

      通过ScheduledFuture对象获取调度结果，这种方式也比较好

      注意点：在使用scheduledFuture.get()一定要避免线程阻塞，如果任务中没有returen，会导致任务线程阻塞，下面这张图的代码就发生了阻塞

      class MyTimerTask implements Runnable {
    @Override
    public void run() {
        // 定时执行的任务逻辑
        System.out.println(Thread.currentThread().getName() + "执行定时任务");
        if (Thread.currentThread().getName().equals("pool-1-thread-1")) {
            throw new RuntimeException("pool-1-thread-1 执行任务发生了异常");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        MyTimerTask timerTask = new MyTimerTask();
        // 延迟0秒开始执行（也就是立即开始执行），每隔1秒执行一次
        Future<?> future = executor.scheduleAtFixedRate(timerTask, 0, 1, TimeUnit.SECONDS);
        executor.scheduleAtFixedRate(timerTask, 0, 1, TimeUnit.SECONDS);
        // 检查任务是否执行完成
        if (!future.isDone()) {
            // 任务还未执行完成，可以选择等待一段时间或进行其他操作
            System.out.println("任务还未执行完成");
        }
        try {
            // 获取任务的结果
            Object result = future.get();
            // 这个不会输出，因为future.get()获取到了任务中的一个异常，直接跳到catch块中了
            System.out.println("任务执行结果：" + result);
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33

      image-20231003225419027

    代码示例

    class MyTimerTask implements Runnable {
    public void run() {
        // 定时执行的任务逻辑
        System.out.println("执行定时任务");
    }
}

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        Runnable timerTask = new MyTimerTask();
        // 延迟0秒开始执行（也就是立即开始执行），每隔1秒执行一次
        executor.scheduleAtFixedRate(timerTask, 0, 1, TimeUnit.SECONDS);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    @Scheduled注解实现定时

    @Scheduled注解属性介绍

    • @Scheduled注解属性介绍
      • cron()：用于指定Cron表达式，表示任务的执行时间规则。例如0 0 * * * ?表示每天的凌晨12点执行一次任务。
      • zone()：用于指定Cron表达式的时区，默认为空字符串。如果需要根据不同的时区执行任务，则可以设置该属性。
      • fixedDelay()和fixedDelayString()：用于指定任务的固定延迟时间，即任务结束后等待多长时间再次执行。默认值为-1，表示不使用固定延迟。
      • fixedRate()和fixedRateString()：用于指定任务的固定频率，即任务开始执行后多长时间再次执行。默认值为-1，表示不使用固定频率。
      • initialDelay()和initialDelayString()：用于指定任务的初始延迟时间，即任务首次执行前等待多长时间。默认值为-1，表示立即执行。
      • timeUnit()：用于指定时间单位，可选值有TimeUnit.MILLISECONDS（毫秒，默认值）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分钟）等

    fixedDelay + initialDelay 属性功能上就等价于 Timer 的schedule方法了，

    fixedRate+initialDelay属性功能上就等价于 Timer 的 scheduleAtFixedRate 方法了

    @Scheduled注解配置介绍

    相关详情请参考：spring.io/guides/gs/scheduling-tasks/

    可以在yaml文件中修改SpringTask的相关配置项

    PS：我现在平常用SpringTask一般都是用来做数据同步的，基本上都是使用默认的配置项即可，没有进行过修改

    • 线程池相关配置：
      • spring.task.scheduling.pool.size：指定任务调度线程池的大小。
      • spring.task.scheduling.thread-name-prefix：指定任务调度线程的名称前缀。
    • 异步执行相关配置：
      • spring.task.execution.thread-name-prefix：指定异步任务执行线程的名称前缀。
      • spring.task.execution.thread-pool.core-size：指定异步任务执行线程池的核心线程数。
      • spring.task.execution.thread-pool.max-size：指定异步任务执行线程池的最大线程数。
    • 任务触发器相关配置：
      • spring.task.scheduling.pool.await-termination-period：指定在关闭容器时等待任务执行完成的最长时间。
      • spring.task.scheduling.shutdown.await-termination：指定是否等待所有任务执行完成后再关闭容器。
    • 额外的配置项：
      • spring.task.scheduling.annotation.enable：指定是否启用基于注解的任务调度。
      • spring.task.scheduling.configurer.ignore-scheduled-task-exceptions：指定是否忽略调度任务的异常。

    代码示例

    @Component
class MyTimerTask{
    /**
     * 延迟1s后每隔5秒执行一次任务（timeUnit默认就是毫秒TimeUnit.MILLISECONDS）
     */
    @Scheduled(fixedDelay = 5000, initialDelay = 1000, timeUnit = TimeUnit.MILLISECONDS)
    public void run() {
        System.out.println("定时任务执行了");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    @Component
class MyTimerTask{
    /**
     * 每分钟执行一次，没有延迟
     */
    @Scheduled(fixedRate = 60 * 1000)
    public void run() {
        log.info("CycleDemo的run方法被执行了");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    @Component
class MyTimerTask{
    /**
     *每隔5秒执行一次任务，没有延迟
     */
    @Scheduled(cron = "0 0/5 * * * ?")
    public void run() {
        System.out.println("定时任务执行了");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    分布式定时任务

    前面所有的定时任务，无论是基于线程类，还是基于 JDK 自带的定时任务，还是基于Spring提供的Spring Task，都无法在分布式环境下使用，并且不支持持久化，一旦服务重启所有的定时任务都将发生丢失，所以我们需要使用到其它的第三方成熟的定时任务框架。当然由于文章字数有限，这里只是简单的介绍一些第三方成熟的定时任务框架，关于具体的详情，后续将进行进一步的学习，敬请期待吧(●ˇ∀ˇ●)

    • Quartz：是一个功能强大的开源作业调度框架，用于在Java应用程序中实现定时任务调度和作业调度。

    • XXL-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轻量级且具备分布式任务调度和弹性扩缩容能力。

    总结

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

    • JDK自带的定时任务Timer和ScheduledExecutorService，我们需要了解两者的区别

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

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

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

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

    最后来一句“万金油”的话：具体场景具体分析，不能纸上谈兵，这些东西都是理论上的

    参考资料

  • 相关阅读:
    B032-服务器 Tomcat JavaWeb项目 Servlet
    C++图书馆管理系统
    二进制部署1.23.4版本k8s集群-6-部署Node节点服务
    Electron 调试node_internal代码*
    C# Onnx Yolov8 Detect 印章 指纹捺印 检测
    机器学习笔记之隐马尔可夫模型(六)总结部分
    Python集合-set使用
    一种基于时空位置预测的空间众包任务分配方法
    算法D38 | 动态规划1 | 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯
    jvm server和client模式切换
  • 原文地址：https://blog.csdn.net/qq_66345100/article/details/133545895