前言

在我们开发中，经常碰到在某个时间点去执行某些操作，而我们不能人为的干预执行，这个时候就需要我们使用定时任务去完成该任务，下面我们来介绍下载springBoot中定时任务实现的方式。

定时任务实现方式

1. 使用Timer
2. cheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
3. pring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。
4. Quartz：这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。

使用Timer

1. java.util.Timer类和java.util.TimerTask抽象类可以用来实现简单的定时任务。这种方法通常用于执行一次性或周期性的任务。Timer类用于安排执行TimerTask对象。
2. 使用java.util.Timer和java.util.TimerTask实现定时任务

import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {

 public static void main(String[] args) {
 // 创建 Timer 实例
 Timer timer = new Timer();
 
 // 创建 TimerTask 实例
 MyTimerTask myTask = new MyTimerTask();
 
 // 安排任务在 2 秒后执行，并且只执行一次
 timer.schedule(myTask, 2000);
 }
 
 // 自定义的 TimerTask
 static class MyTimerTask extends TimerTask {
 @Override
 public void run() {
 System.out.println("任务执行了！当前时间：" + System.currentTimeMillis());
 }
 }
}

使用ScheduledExecutorService

1. scheduledExecutorService是 Java 并发包java.util.concurrent 中提供的一个更加强大和灵活的定时任务工具。它可以用来安排周期性或一次性执行的任务，并且支持延迟执行、固定延迟执行和固定频率执行。
2. 通过 ScheduledExecutorService 实例、 Runnable 或 Callable 接口来实现定时任务

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorServiceExample {

 public static void main(String[] args) {
 // 创建一个单线程的 ScheduledExecutorService
 ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

 // 创建一个 Runnable 任务
 Runnable task = new Runnable() {
 @Override
 public void run() {
 System.out.println("任务执行了！当前时间：" + System.currentTimeMillis());
 }
 };

 // 安排任务在 2 秒后首次执行，之后每 5 秒执行一次
 executor.scheduleAtFixedRate(task, 2, 5, TimeUnit.SECONDS);

 // 为了测试，主线程睡眠 10 秒后退出
 try {
 Thread.sleep(10000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }

 // 关闭 executor
 executor.shutdown();
 }
}

使用Spring Task

1. Spring框架中，可以使用@Scheduled注解来自动化执行定时任务。这个注解允许你在需要执行定时任务的方法上标注，并定义任务的执行周期。Spring的定时任务支持多种触发机制，包括固定延迟、固定频率和cron表达式。
2. 以下是使用Spring @Scheduled注解实现定时任务的基本步骤：
1. 启用定时任务：在你的Spring配置类上添加@EnableScheduling注解，以启用对定时任务的支持。
2. 在你的组件类中创建一个方法，并在这个方法上添加@Scheduled注解，定义任务的执行周期。
3. 启动你的Spring应用。
3. 关于cron讲解可以参照【https://www.bejson.com/othertools/cron/】

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

@Component
public class ScheduledTasks {

 // 任务1：每5秒执行一次
 @Scheduled(fixedRate = 5000)
 public void reportCurrentTimeWithFixedRate() {
 System.out.println("当前时间：" + System.currentTimeMillis());
 }

 // 任务2：延迟3秒后执行，然后每10秒执行一次
 @Scheduled(delay = 3000, fixedRate = 10000)
 public void reportCurrentTimeWithDelayAndFixedRate() {
 System.out.println("当前时间：" + System.currentTimeMillis());
 }

 // 任务3：使用cron表达式，每天凌晨1点执行一次
 @Scheduled(cron = "0 0 1 * * ?")
 public void reportCurrentTimeWithCronExpression() {
 System.out.println("当前时间：" + System.currentTimeMillis());
 }
}


//在启用定时任务之前，确保在你的Spring配置类上添加了@EnableScheduling注解
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration
@EnableScheduling
public class SchedulerConfig {
 // 你的配置
}
使用Quartz

1. Quartz是一个用于Java应用的强大的开源作业调度库。它提供了灵活的调度机制，可以用来安排任务的精确执行。Quartz支持多种触发器类型，如简单触发器、日期触发器、间隔触发器和cron触发器，以及灵活的任务执行模型。
2. Quartz还支持更复杂的调度逻辑，如日历调度、事件调度和作业链调度。你可以根据需要使用Quartz提供的API来构建复杂的定时任务,详细请看文档【https://www.quartz-scheduler.org/】
3. 实现步骤
1. xml配置

<dependency>
 <groupId>org.quartz-scheduler</groupId>
 <artifactId>quartz</artifactId>
 <version>2.3.2</version> <!-- 使用适合你项目的版本 -->
</dependency>

1. 实现job接口

import org.quartz.Job;
import org.quartz.JobExecutionContext;

public class MyQuartzJob implements Job {
 @Override
 public void execute(JobExecutionContext context) {
 // 在这里编写你的任务逻辑
 System.out.println("Quartz 任务执行了！当前时间：" + System.currentTimeMillis());
 }
}
创建一个Scheduler实例，并配置触发器和任务。
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzScheduler {
 public static void main(String[] args) {
 try {
 // 获取 Scheduler 实例
 Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
 
 // 启动 Scheduler
 scheduler.start();
 
 // 创建一个唯一标识任务的 JobKey
 JobKey jobKey = new JobKey("myJob", "myJobGroup");
 
 // 创建一个 JobDetail 实例，并与 Job 接口实现类关联
 JobDetail job = JobBuilder.newJob(MyQuartzJob.class)
 .withIdentity(jobKey)
 .build();
 
 // 创建一个 Trigger 实例，设置触发器参数
 Trigger trigger = TriggerBuilder.newTrigger()
 .withIdentity("myTrigger", "myTriggerGroup")
 .withSchedule(
 SimpleScheduleBuilder.simpleSchedule()
 .withIntervalInSeconds(5) // 每5秒触发一次
 .build()
 )
 .forJob(jobKey)
 .build();
 
 // 注册触发器和任务
 scheduler.scheduleJob(job, trigger);
 
 // 等待1分钟，以便观察任务执行
 Thread.sleep(60000);
 
 // 关闭 Scheduler
 scheduler.shutdown();
 } catch (SchedulerException se) {
 se.printStackTrace();
 } catch (InterruptedException ie) {
 ie.printStackTrace();
 }
 }
}