Java 面试题——定时任务

代码星辰

已于 2023-09-30 20:12:11 修改

阅读量1.2k

点赞数 2

分类专栏： Java 后端面试文章标签：定时任务

于 2023-06-06 16:51:21 首次发布

本文链接：https://blog.csdn.net/weixin_43004044/article/details/131069663

版权

Java 后端面试专栏收录该内容

33 篇文章 9 订阅

订阅专栏

概述

什么是定时任务？为什么需要定时任务？

（1）定时任务是一种在指定的时间点或时间间隔内自动触发执行的任务。它能够周期性地执行一些重复性、时间敏感或计划性的操作，而无需人工干预。定时任务的需求主要有以下几个方面：

自动化：定时任务可以实现某些操作的自动化，无需人工手动执行。这可以提高工作效率，减少人力资源的投入，特别是对于一些重复性、繁琐的操作，如数据备份、日志清理、文件转换等，通过定时任务可以自动完成，节省人力成本和时间。
定时业务处理：在某些业务场景中，需要按照预设的时间计划执行一些操作，如定时发送邮件、定期生成报表、定时更新缓存等。通过定时任务，可以确保这些业务操作在预定的时间点或时间间隔内得到执行，满足业务需求。
特定时间点的操作：有些操作需要在特定的时间点进行，如定时上线、定时下线、定时触发系统升级等。定时任务可以让这些操作在指定的时间点自动执行，避免人为因素导致的延误或错误。
优化资源利用：通过合理调度定时任务，可以在系统的非高峰期执行一些资源密集型的任务，充分利用资源，减少对系统性能的影响。例如，在夜间执行数据库优化、数据同步等任务，可以减少对用户业务的影响。

（2）综上所述，定时任务能够实现操作的自动化、定时业务处理、特定时间点的操作，并且可以优化资源利用。通过定时任务，可以提高工作效率，降低人工操作的成本和错误率，进一步提升系统的稳定性和可靠性。

有哪些实现定时任务的方式？

（1）实现定时任务的方式如下所示：

单机定时任务：Timer、ScheduledExecutorService、DelayQueue、Spring Boot Task；
分布式定时任务：Redis、MQ；
分布式任务调度框架：XXL-JOB、Quartz

（2）具体如何实现见下面的详细介绍。

什么是 cron 表达式？如何使用？

（1）cron 表达式是一个用于指定定时任务执行时间的字符序列。它由 6 个或 7 个域组成，中间使用空格分开，每个域分别表示秒、分、小时、日期、月份、星期和年（可省略）。cron 表达式有如下两种语法格式：

Seconds Minutes Hours DayofMonth Month DayofWeek Year
Seconds Minutes Hours DayofMonth Month DayofWeek

（2）每一个域可出现的字符如下：

Seconds：可出现", - * /"四个字符，有效范围为 0-59 的整数；
Minutes：可出现", - * /"四个字符，有效范围为 0-59 的整数；
Hours：可出现", - * /"四个字符，有效范围为 0-23 的整数；
DayofMonth：可出现", - * / ? L W C"八个字符，有效范围为 0-31 的整数；
Month：可出现", - * /"四个字符，有效范围为 1-12 的整数或 JAN-DEC；
DayofWeek：可出现", - * / ? L C #"八个字符，有效范围为 1-7 的整数或 SUN-SAT 两个范围。1 表示星期天，2 表示星期一，依次类推；
Year：可出现", - * /"四个字符，有效范围为 1970-2099 年；

（3）每一个域都使用数字，但还可以出现如下特殊字符，它们的含义是：

*：表示匹配该域的任意值，假如在 Minutes 域使用 *，即表示每分钟都会触发事件。
?：只能用在 DayofMonth 和 DayofWeek 两个域。它也匹配域的任意值，但实际不会。因为 DayofMonth 和 DayofWeek 会相互影响。例如想在每月的 20 日触发调度，不管 20 日到底是星期几，则只能使用如下写法：13 13 15 20 * ?，其中最后一位只能用 ?，而不能使用 *，如果使用 * 表示不管星期几都会触发，实际上并不是这样。
-：表示范围，例如在 Minutes 域使用 5-20，表示从 5 分到 20 分钟每分钟触发一次。
/：表示数值的增量，简单来说，比如分写上 0/5 表示从0分开始，每隔 5 分钟。
,：表示列出枚举值值。例如：在 Minutes 域使用5,20，则意味着在第 5 和第 20 分钟分别触发一次。
L：表示最后，只能出现于 DayofWeek 和 DayofMonth 域，如果在 DayofWeek 域使用5L，意味着在最后的一个星期四触发。
W：表示有效工作日（周一到周五），只能用于 DayofMonth 域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth 使用 5W，如果 5 日是星期六，则将在最近的工作日：星期五，即 4 日触发。如果 5 日是星期天，则在 6 日（周一）触发；如果 5 日在星期一到星期五中的一天，则就在 5 日触发。另外一点，W 的最近寻找不会跨过月份。
LW：这两个字符可以连用，表示在某个月最后一个工作日，即最后一个非周六周末的日期。
#：用于确定每个月第几个星期几，只能用于 DayofWeek 域，例如在 4#2，表示某月的第二个星期三。

（4）通过这些符号的组合，cron 表达式可以非常灵活地指定任务的执行时间。例如，0 0 12 * * ? 表示每天中午 12 点执行任务，0 0/5 * * * ?表示每隔 5 分钟执行任务。cron 表达式的格式非常有规律，因此很容易书写和修改，同时也非常强大和灵活。在 Java 中，可以使用类库Quartz 和 Spring 的 @Scheduled 注解等来支持 cron 表达式。

① 参考自 cron 百度百科。
② 有时编写复杂的 cron 表达式比较麻烦，因此我们可以通过在线 cron 表达式生成器来辅助我们。

单机定时任务

Timer

（1）java.util.Timer 是 JDK 1.3 开始就已经支持的一种定时任务的实现方式。具体来说，Timer 类的作用如下：

创建定时任务：通过 Timer 类，可以创建一个在指定时间点触发执行的定时任务。可以设置任务的执行时间和周期，如一次性执行、每天执行、每隔一段时间执行等。
延时任务：除了定时任务，Timer 类也支持创建延时任务，即在一段时间后触发执行的任务。
多任务管理：Timer 类支持同时管理多个定时任务。可以创建 Timer 实例，然后通过添加多个任务来管理不同的定时任务。

（2）下面是一个使用 Timer 类的简单示例：

class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer();

        // 创建定时任务
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时任务执行了：" + new Date());
            }
        };

        // 安排任务在指定时间点执行
        timer.schedule(task, new Date());

        // 延时任务，5秒后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("延时任务执行了：" + new Date());
            }
        }, 5000);

        // 取消定时任务
        task.cancel();
        timer.cancel();
    }
}

（3）Timer 类的优缺点如下：

优点：
- 简单易用：Timer 类提供了一种简单的方式来安排定时任务和延时任务，使用起来比较容易上手。
- 内置的任务调度器：Timer 类内置了一个任务调度器，可以根据任务的时间点或延时来触发执行，无需额外编写复杂的调度逻辑。
- 多任务管理：Timer 类支持同时管理多个定时任务，可以通过 Timer 实例添加并管理不同的任务。
缺点：
- 单线程执行：Timer 类是单线程的，所有的任务都是在同一个线程中按顺序执行的。如果某个任务执行时间过长，会影响其他任务的执行时间和精确性。
- 不适用于并发：Timer 类对于并发环境不是线程安全的，在多线程情况下使用 Timer 类可能会导致任务执行的混乱和不准确。
- 缺乏高级特性：Timer 类在任务调度和管理方面的功能相对简单，不支持像 Quartz 框架那样的复杂任务调度、灵活的任务触发条件和错误处理机制。

Timer 类适用于一些简单的定时任务和延时任务的需求，但对于复杂的任务调度和并发环境下的任务管理，可能需要考虑其他更为强大和可靠的任务调度框架。

DelayQueue

参考 Java 并发编程面试题——BlockingQueue 这篇文章中与 DelayQueue 有关的介绍。

ScheduledExecutorService

参考 Java 并发编程面试题——线程池这篇文章中与 ScheduledExecutorService 的相关介绍。

Spring Boot Task

@Scheduled 注解有什么作用？

（1）@Scheduled 注解用于创建定时任务，通过使用该注解，可以在指定的时间间隔内反复执行带有注解的方法。@Scheduled 注解支持 cron 表达式、固定速率和固定延迟等方式来指定任务的执行时间。

（2）@Scheduled 注解有以下属性：

cron：用于指定 cron 表达式，表示定时任务的执行时间；
fixedDelay：用于指定延迟时间（单位是毫秒），表示在任务完成后到下一次任务开始之间的毫秒数；
fixedRate：用于指定速率时间（单位是毫秒），表示在任务开始时间点到下一次任务开始时间点之间的毫秒数；
initialDelay：用于指定初始延迟时间（单位是毫秒），表示任务第一次执行前等待的毫秒数。

（3）这些属性可以在 @Scheduled 中任意组合使用，来达到定制定时任务的目的。需要注意的是，@Scheduled 注解要求其所在的类必须是 Spring 管理的 Bean，因此一般需要将类定义为 @Component 或 @Service 等注解的组件类。同时，如果需要使用到 cron 表达式来执行任务，则需要手动配置 cron 表达式。

介绍一下 spring-boot-starter-quartz。

spring-boot-starter-quartz 是一个 Spring Boot 的快速启动器 (Starter)，它提供了在 Spring Boot 应用程序中添加 Quartz 定时任务的依赖和自动配置。Quartz 是一个用于创建和管理定时任务的框架，它提供了非常丰富的功能，例如支持 cron 表达式设定执行时间、支持任务优先级、并且具有失败重试机制等。Quartz 自带线程池，可以高效地执行大量任务，而且支持分布式处理。因此，在 Spring Boot 应用程序中使用 Quartz 是很常见的。

在 Spring Boot 中如何实现定时任务？

使用 @Schedule 注解

（1）我们可以使用 @Schedule 注解创建一个定时任务：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

//这个任务会在每天的中午 12 点执行，输出一行文字
@Component
public class MyTask {
    @Scheduled(cron = "0 0 12 * * ?")
    public void execute() {
        System.out.println("定时任务执行了！");
    }
}

然后，在启动类上添加 @Enablescheduling 注解，该注解的作用是发现注解@Scheduled 的任务并在后台执行该任务。在 Spring Boot 应用程序中，默认情况下是关闭计划任务的，通过添加 @EnableScheduling 注解，Spring 就会扫描注解的 Bean 并将其注册在使用了 @Scheduled 注解的方法上。在使用 @EnableScheduling 注解之前，需要确保 Spring Boot 项目中已经添加了 spring-boot-starter 或 spring-boot-starter-web 依赖，因为这两个依赖默认引入了 Spring 的计划任务依赖 spring-context-support。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

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

（2）需要注意的是，@EnableScheduling 注解只是开启了 Spring 的计划任务功能。如果需要使用 Quartz 框架等更强大的定时任务工具，还需要在应用程序中添加相应的依赖和配置。最后，除了使用 @Scheduled 注解，还可以使用 Spring Boot 提供的 ScheduledExecutorService 或实现 Runnable 接口来创建定时任务。首先，在应用程序中导入 java.util.concurrent.ScheduledExecutorService 类，然后创建一个 ScheduledExecutorService 对象，并且按照需要设置延迟时间和间隔时间即可。

Quartz 框架

使用 Spring Boot 搭建的应用程序，默认提供了 Spring 自带的定时任务功能，但是，如果需要更加丰富、复杂的任务调度功能，推荐使用 Quartz 框架。而 spring-boot-starter-quartz 是Spring Boot提供的一个构建基于 Quartz 的应用程序的启动器。下面是使用 spring-boot-starter-quartz 进行任务调度的步骤：

在 pom.xml 文件中添加 spring-boot-starter-quartz 的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

编写一个定时任务的类，并且添加 @Component 注解。

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

@Component
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("定时任务开始执行...");
    }
}

在应用程序配置类中添加 Quartz 配置：

import org.quartz.JobDetail;
import org.quartz.SimpleTrigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzConfig {
    @Autowired
    private MyJob myJob;

    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean() {
        JobDetailFactoryBean factory = new JobDetailFactoryBean();
        factory.setJobClass(MyJob.class);
        factory.setDurability(true);
        return factory;
    }

    @Bean
    public SimpleTriggerFactoryBean triggerFactoryBean() {
        SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
        factory.setJobDetail(jobDetailFactoryBean().getObject());
        factory.setStartDelay(0L);
        factory.setRepeatInterval(5000);
        factory.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
        return factory;
    }

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setJobDetails(new JobDetail[]{jobDetailFactoryBean().getObject()});
        factory.setTriggers(triggerFactoryBean().getObject());
        return factory;
    }
}

在上述代码中，我们使用 JobDetailFactoryBean、SimpleTriggerFactoryBean 和 SchedulerFactoryBean 来配置 Quartz 的相关参数。其中，JobDetailFactoryBean 用于将 Job 类绑定到 Quartz 上下文中，SimpleTriggerFactoryBean 用于定义执行该 Job 的调度策略，而SchedulerFactoryBean 则是将前面的两个 Bean 组合成一个调度工厂实例。

在上述配置完成后，需要在自定义的 @SpringBootApplication 启动类中加上 @EnableQuartz 注解开启 Quartz。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.scheduling.annotation.EnableQuartz;

@SpringBootApplication
@EnableScheduling
@EnableAsync
@Configuration
@EnableQuartz
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

这样就可以使用 Quartz 进行任务调度了。在上述配置中，我们定义了一个名为 MyJob 的任务，该任务将定期执行。同时，我们还定义了调度间隔等参数，以满足复杂的需求。

分布式定时任务

MQ

参考 RabbitMQ——入门介绍这篇文章中延迟队列这一节的内容。

Redis

要使用 Redis 实现延时任务，可以使用 Redis 的 Sorted Set 和定时任务调度器 (scheduler) 实现。下面是一个具体的示例代码：

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

import java.util.Set;

public class RedisDelayedTask {

    private static final String TASK_CHANNEL = "delayed_tasks";

    public static void main(String[] args) {
        // 创建一个 Redis 连接
        Jedis jedis = new Jedis("localhost");

        // 添加延迟任务
        addDelayedTask(jedis, "task1", 10); // 在 10 秒后执行的任务
        addDelayedTask(jedis, "task2", 30); // 在 30 秒后执行的任务

        // 启动任务调度器
        startTaskScheduler(jedis);

        // 关闭 Redis 连接
        jedis.close();
    }

    private static void addDelayedTask(Jedis jedis, String taskId, int delaySeconds) {
        // 计算任务的执行时间
        long executeTime = System.currentTimeMillis() + (delaySeconds * 1000);

        // 将任务添加到有序集合中
        jedis.zadd(TASK_CHANNEL, executeTime, taskId);
    }

    private static void startTaskScheduler(Jedis jedis) {
        while (true) {
            // 获取最早需要执行的任务
            Set<Tuple> tasks = jedis.zrangeWithScores(TASK_CHANNEL, 0, 0);

            // 如果没有任务或任务的执行时间未到，则等待一段时间后重新检查
            if (tasks == null || tasks.isEmpty() || tasks.iterator().next().getScore() > System.currentTimeMillis()) {
                try {
                    Thread.sleep(1000); // 等待1秒钟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                continue;
            }

            // 执行任务
            Tuple task = tasks.iterator().next();
            String taskId = task.getElement();
            double executeTime = task.getScore();

            // 输出任务信息
            System.out.println("执行任务：" + taskId + "，执行时间：" + executeTime);

            // 删除已执行的任务
            jedis.zrem(TASK_CHANNEL, taskId);
        }
    }
}

（2）具体分析如下：

在上述示例中，通过 addDelayedTask 方法向 Redis 的 Sorted Set 中添加延时任务。其中，addDelayedTask 方法通过计算任务的执行时间，并使用 zadd 命令将任务添加到有序集合中。
startTaskScheduler 方法启动任务调度器，它会循环地从 Sorted Set 中获取最早需要执行的任务，判断是否需要等待任务的执行时间到达。如果任务的执行时间未到，调度器会暂停一段时间后重新检查。当任务的执行时间到达时，调度器会输出任务信息，并使用 zrem 命令从 Sorted Set 中删除已执行的任务。