Java中如何实现定时任务？

文章目录

定时任务基本介绍
- 前言
- 基本概念介绍
- 线程类实现定时任务
- - Thread类实现定时任务
  - Runnable接口实现定时任务
  - Callable接口实现定时任务
- Timer实现定时任务
- - Timer的常用方法
  - Timer的优缺点
  - schedule和scheduleAtFixedRate的区别
  - 代码示例
- ScheduledExecutorService实现定时
- - ScheduledExecutorService的常用方法
  - ScheduledExecutorService的异常处理
  - 代码示例
- @Scheduled注解实现定时
- - @Scheduled注解属性介绍
  - @Scheduled注解配置介绍
  - 代码示例
- 分布式定时任务
- 总结

定时任务基本介绍

前言

本文主要是对定时任务进行一个大致的了解，关于定时任务的详细使用细节，这个后面会进一步学习。通过本文你将了解定时任务是什么？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();
    }
}

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();
    }
}

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();
    }
}

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）第0~1秒，等待状态；
  
  2）第1秒，第一个任务开始执行，执行耗时3秒；
  
  3）计算第二个任务的预定执行时间：第一个任务的起始执行时间 + 任务执行周期两秒钟 = 1+2=3，所以第3秒是第二个任务的预定执行时间；
  
  4）第4秒，第一个任务执行完毕，但是发现当前时间已经超过了第二个任务的预定执行时间，所以第二个任务立即执行，第二个任务的执行时间是1秒钟；
  
  5）计算第三个任务的预定执行时间：第二个任务起始执行时间+任务执行周期两秒钟=4+2=6，所以第四个任务是预定在第6秒执行；
  
  6）第5秒钟，第二个任务执行完毕，发现当前是第5秒，还未到第6秒，所以还需要等待1秒钟
2. scheduleAtFixedRate是固定速率，更加侧重保持执行频率的稳定性。scheduleAtFixedRate当前任务到达规定时间一定执行，上一个未执行的任务会直接终止
简而言之：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);
    }
}

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

第一个任务耗时3s，超过了时间间隔1s，所以第二个任务立即执行
第二个任务耗时不到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);
    }
}

ScheduledExecutorService实现定时

ScheduledExecutorService的常用方法

ScheduledExecutorService类的常用方法
- schedule(Runnable command, long delay, TimeUnit unit): 在指定的延迟时间后执行一次任务。
- schedule(Callable<V> 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<V> task): 提交一个可获取结果的任务，并返回一个表示任务执行结果的 Future 对象。
- submit(Runnable task): 提交一个不返回结果的任务，并返回一个表示任务执行完成的 Future 对象。
- shutdown(): 优雅地关闭 ScheduledExecutorService，等待已提交的任务执行完毕。
- shutdownNow(): 强制关闭 ScheduledExecutorService，立即停止所有任务的执行。

注意区分：

ScheduledExecutorService是基于线程池的，可以在多线程的场景下使用，Timer是基于单线程的，无法在多线程下使用
ScheduledExecutorService 的两个 schedule 方法都不能重复执行，都是在指定延迟时候之后执行一次，Timer 的 schedule 方法既可以单词执行又可以重复执行
ScheduledExecutorService 的 scheduleWithFixedDelay 方法功能上等价于 Timer 的 schedule(TimerTask task, long delay, long period)
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继续执行任务

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

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

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

方案一：try-catch

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

方式二：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();
        }
    }
}

代码示例

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);
    }
}

@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("定时任务执行了");
    }
}

@Component
class MyTimerTask{
    /**
     * 每分钟执行一次，没有延迟
     */
    @Scheduled(fixedRate = 60 * 1000)
    public void run() {
        log.info("CycleDemo的run方法被执行了");
    }
}

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

分布式定时任务

前面所有的定时任务，无论是基于线程类，还是基于 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。

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