理论基础：时间轮算法
链表或者数组实现时间轮：while-true-sleep
遍历数组，每个下标放置一个链表，链表节点放置任务，遍历到了就取出执行
缺陷：假设数组长度12代表小时，那么我想13点执行，就不太方便
round型时间轮：任务上记录一个round，遍历到了就将round减一，为0时取出执行
需要遍历所有的任务，效率较低
分层时间轮：使用多个不同维度的轮
天轮：记录几点执行
月轮：记录记号执行
月轮遍历到了，将任务去除放到天轮里面，就可以实现几号几点执行
/**
* @author cVzhanshi
* @create 2022-11-02 20:27
*/
public class TimerTest {
public static void main(String[] args) {
Timer timer = new Timer(); // 任务启动
for (int i = 0; i < 2; i++) {
TimerTask timerTask = new FooTimerTask("cvzhanshi" + i);
// 任务添加 第二个参数，启动时间 第三个参数，执行间隔时间
timer.schedule(timerTask , new Date() , 2000);
// 预设的执行时间nextExecutTime 12:00:00 12:00:02 12:00:04
//schedule 真正的执行时间 取决上一个任务的结束时间 ExecutTime 03 05 08 丢任务（少执行了次数）
//scheduleAtFixedRate 严格按照预设时间 12:00:00 12:00:02 12:00:04（执行时间会乱）
//单线程 任务阻塞 任务超时
}
}
}
执行源码解析
// Timer类中的两个常量
// 任务队列
private final TaskQueue queue = new TaskQueue();
// 执行任务的线程
private final TimerThread thread = new TimerThread(queue);
new Timer();
// 进入构造器
public Timer() {
// 调用了另一个构造器
this("Timer-" + serialNumber());
}
public Timer(String name) {
thread.setName(name);
// 启动线程执行线程的run方法
thread.start();
}
线程的run()方法
public void run() {
try {
// 主要方法 后面再说
mainLoop();
} finally {
...
}
}
timer.schedule(timerTask , new Date() , 2000);
public void schedule(TimerTask task, Date firstTime, long period) {
if (period <= 0)
throw new IllegalArgumentException("Non-positive period.");
sched(task, firstTime.getTime(), -period);
}
private void sched(TimerTask task, long time, long period) {
if (time < 0)
throw new IllegalArgumentException("Illegal execution time.");
// 充分限制周期值，以防止数字溢出，同时仍然有效地无限大。
if (Math.abs(period) > (Long.MAX_VALUE >> 1))
period >>= 1;
synchronized(queue) {
if (!thread.newTasksMayBeScheduled)
throw new IllegalStateException("Timer already cancelled.");
synchronized(task.lock) {
if (task.state != TimerTask.VIRGIN)
throw new IllegalStateException(
"Task already scheduled or cancelled");
// 设置下次执行时间
task.nextExecutionTime = time;
task.period = period;
task.state = TimerTask.SCHEDULED;
}
// 加入任务队列
queue.add(task);
// 获取最近要执行的任务，如果是当前任务，唤醒队列
if (queue.getMin() == task)
queue.notify();
}
}
mainLoop() 主要执行步骤
private void mainLoop() {
while (true) {
try {
TimerTask task;
boolean taskFired;
synchronized(queue) {
// 等待队列变为非空
while (queue.isEmpty() && newTasksMayBeScheduled)
queue.wait();
if (queue.isEmpty())
break; // 队列是空的，将永远保留；死亡
// 队列非空；获取第一个任务去执行
long currentTime, executionTime;
// 获取任务
task = queue.getMin();
synchronized(task.lock) {
// 如果任务状态是取消，无需操作，再次轮询队列
if (task.state == TimerTask.CANCELLED) {
queue.removeMin();
continue;
}
// 当前时间
currentTime = System.currentTimeMillis();
// 下次执行的时间
executionTime = task.nextExecutionTime;
// 如果下次执行时间小于等于当前时间
if (taskFired = (executionTime<=currentTime)) {
// 如果任务是单次的，直接删除
if (task.period == 0) {
queue.removeMin();
task.state = TimerTask.EXECUTED;
} else {
// 重复任务，重新安排,计算下次执行时间
queue.rescheduleMin(
task.period<0 ? currentTime - task.period
: executionTime + task.period);
}
}
}
//任务尚未启动；等待
if (!taskFired)
queue.wait(executionTime - currentTime);
}
if (taskFired)
// 执行任务，注意是单线程运行，不是运行start方法运行的
task.run();
} catch(InterruptedException e) {
}
}
}
总结：Timer是存在缺陷的 单线程 任务阻塞 任务超时
测试代码
/**
* @author cVzhanshi
* @create 2022-11-03 15:05
*/
public class ScheduleThreadPoolTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
for (int i = 0; i < 2; i++){
// 第一个参数：任务
// 第二个参数：第一次执行的时间
// 第三个参数：下次任务间隔的时间
// 第四个参数：时间单位
scheduledThreadPool.scheduleAtFixedRate(new Task("task-" + i ),0,2, TimeUnit.SECONDS);
// 执行单次任务的api
// scheduledThreadPool.schedule(new Task("task-" + i ),0, TimeUnit.SECONDS);
}
}
}
class Task implements Runnable{
private String name;
public Task(String name) {
this.name = name;
}
public void run() {
try {
System.out.println("name="+name+",startTime=" + new Date());
Thread.sleep(3000);
System.out.println("name="+name+",endTime=" + new Date());
//线程池执行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
ScheduledThreadPoolExecutor
SingleThreadScheduledExecutor
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与2EE与|2SE应用程序相结合也可以单独使用。
quartz是开源且具有丰富特性的"任务调度库"，能够集成于任何的java应用，小到独立的应用，大至电子商业系统。quartz能够创建亦简单亦复杂的调度，以执行上十、上百，甚至上万的任务。任务job被定义为标准的java组件，能够执行任何你想要实现的功能。quartz调度框架包含许多企业级的特性，如JTA事务、集群的支持。
简而言之，quartz就是基于java实现的任务调度框架，用于执行你想要执行的任何任务。
Quartz所涉及到的设计模式
● Builder模式
● Factory模式
● 组件模式 JobDetail Trigger
● 链式编程
任务Job
Job就是你想要实现的任务类，每一个Job必须实现org.quartz.job接口，且只需实现接口定义的execute()方法。
触发器Trigger
Trigger为你执行任务的触发器，比如你想每天定时3点发送一份统计邮件，Trigger将会设置3点执行该任务。Trigger主要包含两种SimplerTrigger和CronTrigger两种。
调度器Scheduler
Scheduler为任务的调度器，它会将任务Job及触发器Trigger整合起来，负责基于Trigger设定的时间来执行Job。
Quartz的体系结构
以下是Quartz编程API几个重要接口，也是Quartz的重要组件。
创建一个spring boot项目
导入依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-quartzartifactId>
dependency>
创建HelloJob
/**
* @author cVzhanshi
* @create 2022-11-02 18:35
*/
public class HelloJob implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("HelloJob" + new Date());
}
}
在main方法中进行配置任务调用
/**
* @author cVzhanshi
* @create 2022-11-02 18:36
*/
public class HelloSchedulerDemo {
public static void main(String[] args) throws SchedulerException {
// 1.调度器(Scheduler)，从工厂获取调度实例
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
//2.任务实例（JobDetail）
JobDetail jobDetail = JobBuilder.newJob(HelloJob.class) //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口
.withIdentity("job1", "group1") //参数1：任务的名称（唯一实例），参数2：任务组的名称
.build();
//3.触发器（Trigger）
SimpleTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity("trigger1", "group2") //参数1：触发器的名称（唯一实例），参数2：触发器组的名称
.startNow() // 马上启动触发器
.withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5))// 每5s触发一次，一直执行
.build();
//让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
scheduler.scheduleJob(jobDetail, trigger);
scheduler.start();
}
}
执行结果
HelloJobThu Nov 03 16:54:05 CST 2022 //每五秒执行一次
HelloJobThu Nov 03 16:54:10 CST 2022
HelloJobThu Nov 03 16:54:15 CST 2022
public static void main(String[] args) throws SchedulerException {
// 1.调度器(Scheduler)，从工厂获取调度实例
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
//2.任务实例（JobDetail）
JobDetail jobDetail = JobBuilder.newJob(HelloJob.class) //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口
.withIdentity("job1", "group1") //参数1：任务的名称（唯一实例），参数2：任务组的名称
.build();
//3.触发器（Trigger）
SimpleTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity("trigger1", "group2") //参数1：触发器的名称（唯一实例），参数2：触发器组的名称
.startNow() // 马上启动触发器
.withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5))
.build();
//让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
scheduler.scheduleJob(jobDetail, trigger);
scheduler.start();
}
通过demo我们知道。我们传给scheduler一个JobDetail实例，因为我们在创建JobDetail时，将要执行的job的类名传给了JobDetail，所以scheduler就知道了要执
行何种类型的job；每次当scheduler执行job时，在调用其execute(…)方法之前会创建该类的一个新的实例；执行完毕，对该实例的引用就被丢弃了，实例会被垃
圾回收；这种执行策略带来的一个后果是，job必须有一个无参的构造函数（当使用默认的JobFactory时）；另一个后果是，在job类中，不应该定义有状态的数据
属性，因为在job的多次执行中，这些属性的值不会保留。
那么如何给job实例增加属性或配置呢？如何在job的多次执行中，跟踪job的状态呢？
JobDataMap
JobDataMap中可以包含不限量的（序列化的）数据对象，在job实例执行的时候，可以使用其中的数据；JobDataMap是Java Map接口的一个实现，额外增加了一
些便于存取基本类型的数据的方法。
将job加入到scheduler之前，在构建JobDetail时，可以将数据放入JobDataMap，如代码所示：
//创建一个job
JobDetail job = JobBuilder.newJob(HelloJob.class)
.usingJobData("j1", "jv1")
.withIdentity("myjob", "mygroup")
.usingJobData("jobSays", "Hello World!")
.usingJobData("myFloatValue", 3.141f)
.build();
在job的执行过程中，可以从JobDataMap中取出数据，如下示例：
public class HelloJob implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
Object tv1 = context.getTrigger().getJobDataMap().get("t1");
Object tv2 = context.getTrigger().getJobDataMap().get("t2");
Object jv1 = context.getJobDetail().getJobDataMap().get("j1");
Object jv2 = context.getJobDetail().getJobDataMap().get("j2");
Object sv = null;
try {
sv = context.getScheduler().getContext().get("skey");
} catch (SchedulerException e) {
e.printStackTrace();
}
System.out.println(tv1+":"+tv2);
System.out.println(jv1+":"+jv2);
System.out.println(sv);
System.out.println("hello:"+ LocalDateTime.now());
}
}
如果你在job类中，为JobDataMap中存储的数据的key增加set方法（如在上面示例中，增加setJobSays(String val)方法），那么Quartz的默认JobFactory实现在job被实例化的时候会自动调用这些set方法，这样你就不需要在execute()方法中显式地从map中取数据了。
/**
* @author cVzhanshi
* @create 2022-11-02 18:35
*/
public class HelloJob implements Job {
private String j1;
public void setJ1(String j1) {
this.j1 = j1;
}
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println(j1); // jv1
}
}
JobDetail job = JobBuilder.newJob(HelloJob.class)
.usingJobData("j1", "jv1")
.withIdentity("myjob", "mygroup")
.build();
在Job执行时，JobExecutionContext中的JobDataMap为我们提供了很多的便利。它是JobDetail中的JobDataMap和Trigger中的JobDataMap的并集，但是如果存
在相同的数据，则后者会覆盖前者的值。
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
JobDataMap mergedJobDataMap = jobExecutionContext.getMergedJobDataMap();
System.out.println(mergedJobDataMap.get("j1"));
System.out.println(mergedJobDataMap.get("t1"));
System.out.println(mergedJobDataMap.get("name")); // jobDetail中的数据会被trigger覆盖，如果key相同的话
}
Job实例
你可以只创建一个job类，然后创建多个与该job关联的JobDetail实例，每一个实例都有自己的属性集和JobDataMap，最后，将所有的实例都加到scheduler中。
比如，你创建了一个实现Job接口的类“SalesReportJob”。该job需要一个参数（通过JobdataMap传入），表示负责该销售报告的销售员的名字。因此，你可以创建该job的多个实例（JobDetail），比如“SalesReportForJoe”、“SalesReportForMike”，将“joe”和“mike”作为JobDataMap的数据传给对应的job实例。
当一个trigger被触发时，与之关联的JobDetail实例会被加载，JobDetail引用的job类通过配置在Scheduler上的JobFactory进行初始化。默认的JobFactory实现，仅仅是调用job类的newInstance()方法，然后尝试调用JobDataMap中的key的setter方法。你也可以创建自己的JobFactory实现，比如让你的IOC或DI容器可以创建/初始化job实例。
在Quartz的描述语言中，我们将保存后的JobDetail称为“job定义”或者“JobDetail实例”,将一个正在执行的job称为“job实例”或者“job定义的实例”。当我们使用“job”时，一般指代的是job定义，或者JobDetail；当我们提到实现Job接口的类时，通常使用“job类”。
Job状态与并发
Scheduler每次执行，都会根据JobDetail创建一个新的 Job实例，这样就可以规避并发访文的问题(jobDeatil的实例也是新的)，看如下代码示例
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("JobDetail: " + System.identityHashCode(jobExecutionContext.getJobDetail().hashCode()));
System.out.println("Job: " + System.identityHashCode(jobExecutionContext.getJobInstance().hashCode()));
}
JobDetail: 2046941357
Job: 1895412701
// 每次都不一样
JobDetail: 1157785854
Job: 1341784974
**Quartz定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行，如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。**测试并发执行：
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("execute:" + new Date());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 任务设置成1s执行一次
// 执行结果 还是每秒执行一次，并没有sleep3s 所以是并发执行
// execute:Thu Nov 03 17:36:55 CST 2022
// execute:Thu Nov 03 17:36:56 CST 2022
// execute:Thu Nov 03 17:36:57 CST 2022
关于job的状态数据（即JobDataMap）和并发性，还有一些地方需要注意。在job类上可以加入一些注解，这些注解会影响job的状态和并发性。
@DisallowConcurrentExecution：将该注解加到job类上，告诉Quartz不要并发地执行同一个job定义（这里指特定的job类）的多个实例。拿上面的例子
来说，如果“SalesReportJob”类上有该注解，则同一时刻仅允许执行一个“SalesReportForJoe”实例，但可以并发地执行“SalesReportForMike”类的一个实例。
所以该限制是针对JobDetail的，而不是job类的。但是我们认为（在设计Quartz的时候）应该将该注解放在job类上，因为job类的改变经常会导致其行为发生
变化。
代码测试
@DisallowConcurrentExecution
public class HelloJob implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("execute:" + new Date());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 任务设置成1s执行一次
// 执行结果
// execute:Thu Nov 03 17:36:55 CST 2022
// execute:Thu Nov 03 17:36:58 CST 2022
执行结果是睡眠了3s才执行下一个任务，所以没有并发去执行同一个job定义（这里指特定的job类）的多个实例
如果你使用了@PersistJobDataAfterExecution注解，我们强烈建议你同时使用@DisallowConcurrentExecution注解，因为当同一个job（JobDetail）的两个实例
被并发执行时，由于竞争，JobDataMap中存储的数据很可能是不确定的。
Job的其它特性
通过JobDetail对象，可以给job实例配置的其它属性有：
Durability：如果一个job是非持久的，当没有活跃的trigger与之关联的时候，会被自动地从scheduler中删除。也就是说，非持久的job的生命期是由trigger的
存在与否决定的；
RequestsRecovery：如果一个job是可恢复的，并且在其执行的时候，scheduler发生硬关闭（hard shutdown)（比如运行的进程崩溃了，或者关机了），则
当scheduler重新启动的时候，该job会被重新执行。此时，该job的JobExecutionContext.isRecovering() 返回true。
Trigger的公共属性
所有类型的trigger都有TriggerKey这个属性，表示trigger的身份；除此之外，trigger还有很多其它的公共属性。这些属性，在构建trigger的时候可以通
TriggerBuilder设置。
trigger的公共属性有：
jobKey属性：当trigger触发时被执行的job的身份；
startTime属性：设置trigger第一次触发的时间；该属性的值是java.util.Date类型，表示某个指定的时间点；有些类型的trigger，会在设置的startTime时立
即触发，有些类型的trigger，表示其触发是在startTime之后开始生效。比如，现在是1月份，你设置了一个trigger–“在每个月的第5天执行”，然后你将
startTime属性设置为4月1号，则该trigger第一次触发会是在几个月以后了(即4月5号)。
endTime属性：表示trigger失效的时间点。比如，”每月第5天执行”的trigger，如果其endTime是7月1号，则其最后一次执行时间是6月5号。
优先级
如果你的trigger很多(或者Quartz线程池的工作线程太少)，Quartz可能没有足够的资源同时触发所有的trigger；这种情况下，你可能希望控制哪些trigger优先使用
Quartz的工作线程，要达到该目的，可以在trigger上设置priority属性。比如，你有N个trigger需要同时触发，但只有Z个工作线程，优先级最高的Z个trigger会被
首先触发。如果没有为trigger设置优先级，trigger使用默认优先级，值为5；priority属性的值可以是任意整数，正数、负数都可以。
错过触发
trigger还有一个重要的属性misfire；如果scheduler关闭了，或者Quartz线程池中没有可用的线程来执行job，此时持久性的trigger就会错过(miss)其触发时间，
即错过触发(misfire)。不同类型的trigger，有不同的misfire机制。它们默认都使用“智能机制(smart policy)”，即根据trigger的类型和配置动态调整行为。当
scheduler启动的时候，查询所有错过触发(misfire)的持久性trigger。然后根据它们各自的misfire机制更新trigger的信息。
判断misfire的条件
产生的可能原因
创建springboot项目
导入需要的依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.7</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>cn.cvzhanshi</groupId>
<artifactId>test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>test</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>
编辑配置文件application.yaml
server:
port: 8889
datasource:
url: jdbc:mysql://localhost:3306/test_quartz?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
编辑Quartz的配置文件spring-quartz.properties
#============================================================================
# 配置JobStore
#============================================================================
# JobDataMaps是否都为String类型，默认false
org.quartz.jobStore.useProperties=false
# 表的前缀，默认QRTZ_
org.quartz.jobStore.tablePrefix = QRTZ_
# 是否加入集群
org.quartz.jobStore.isClustered = true
# 调度实例失效的检查时间间隔 ms
org.quartz.jobStore.clusterCheckinInterval = 5000
# 数据保存方式为数据库持久化
org.quartz.jobStore.class=org.springframework.scheduling.quartz.LocalDataSourceJobStore
# 数据库代理类，一般org.quartz.impl.jdbcjobstore.StdJDBCDelegate可以满足大部分数据库
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#============================================================================
# Scheduler 调度器属性配置
#============================================================================
# 调度标识名 集群中每一个实例都必须使用相同的名称
org.quartz.scheduler.instanceName = ClusterQuartz
# ID设置为自动获取 每一个必须不同
org.quartz.scheduler.instanceId= AUTO
#============================================================================
# 配置ThreadPool
#============================================================================
# 线程池的实现类（一般使用SimpleThreadPool即可满足几乎所有用户的需求）
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
# 指定线程数，一般设置为1-100直接的整数，根据系统资源配置
org.quartz.threadPool.threadCount = 5
# 设置线程的优先级(可以是Thread.MIN_PRIORITY（即1）和Thread.MAX_PRIORITY（这是10）之间的任何int 。默认值为Thread.NORM_PRIORITY（5）。)
org.quartz.threadPool.threadPriority = 5
编辑Job类
/**
* @author cVzhanshi
* @create 2022-11-07 10:20
*/
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class QuartzJob extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
try {
Thread.sleep(2000);
System.out.println(context.getScheduler().getSchedulerInstanceId());
System.out.println("taskname=" + context.getJobDetail().getKey().getName());
System.out.println("执行时间：" + new Date());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
统一使用一个配置好的调度器Scheduler
/**
* @author cVzhanshi
* @create 2022-11-07 10:53
*/
@Configuration
public class SchedulerConfig {
@Autowired
private DataSource dataSource;
@Bean
public Scheduler scheduler() throws IOException {
return schedulerFactoryBean().getScheduler();
}
@Bean
public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
factoryBean.setSchedulerName("cluster_scheduler");
// 设置数据源
factoryBean.setDataSource(dataSource);
factoryBean.setApplicationContextSchedulerContextKey("application");
// 加载配置文件
factoryBean.setQuartzProperties(quartzProperties());
// 设置线程池
factoryBean.setTaskExecutor(schedulerThreadPool());
// 设置延迟开启任务时间
factoryBean.setStartupDelay(0);
return factoryBean;
}
@Bean
public Properties quartzProperties() throws IOException {
PropertiesFactoryBean factoryBean = new PropertiesFactoryBean();
factoryBean.setLocation(new ClassPathResource("/spring-quartz.properties"));
factoryBean.afterPropertiesSet();
return factoryBean.getObject();
}
@Bean
public Executor schedulerThreadPool(){
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors());
executor.setQueueCapacity(Runtime.getRuntime().availableProcessors());
return executor;
}
}
编写监听器，监听容器加载事件，加载完成就启动任务
/**
* @author cVzhanshi
* @create 2022-11-07 11:04
*/
@Component
// 监听springboot容器是否启动，启动了就执行定时任务
public class StartApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
@Autowired
private Scheduler scheduler;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
TriggerKey triggerKey = TriggerKey.triggerKey("trigger1", "group1");
try {
/**
* 在调度器中获取指定key的trigger，
*/
Trigger trigger = scheduler.getTrigger(triggerKey);
if(trigger == null){
trigger = TriggerBuilder.newTrigger()
.withIdentity("trigger1","group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?"))
.startNow()
.build();
}
JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class).withIdentity("job1", "group1").build();
scheduler.scheduleJob(jobDetail, trigger);
scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
启动服务
# 输出结果
taskname=job1
执行时间：Mon Nov 07 14:19:02 CST 2022
A029095-NC1667801934353
taskname=job1
执行时间：Mon Nov 07 14:19:12 CST 2022
Quartz集群是一个jobdetail分配到一个节点且一直在这个节点不会改变的
demo示例：
修改上述整合的代码
/**
* @author cVzhanshi
* @create 2022-11-07 11:04
*/
@Component
// 监听springboot容器是否启动，启动了就执行定时任务
public class StartApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
@Autowired
private Scheduler scheduler;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
try {
TriggerKey triggerKey = TriggerKey.triggerKey("trigger1", "group1");
/**
* 在调度器中获取指定key的trigger，
*/
Trigger trigger = scheduler.getTrigger(triggerKey);
if(trigger == null){
trigger = TriggerBuilder.newTrigger()
.withIdentity("trigger1","group1")
.withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?"))
.startNow()
.build();
}
JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class).withIdentity("job1", "group1").build();
scheduler.scheduleJob(jobDetail, trigger);
TriggerKey triggerKey2 = TriggerKey.triggerKey("trigger1", "group1");
/**
* 在调度器中获取指定key的trigger，
*/
Trigger trigger2 = scheduler.getTrigger(triggerKey2);
if(trigger2 == null){
trigger2 = TriggerBuilder.newTrigger()
.withIdentity("trigger2","group2")
.withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?"))
.startNow()
.build();
}
JobDetail jobDetail2 = JobBuilder.newJob(QuartzJob.class).withIdentity("job2", "group2").build();
scheduler.scheduleJob(jobDetail2, trigger2);
scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
先启动一个节点
# 任务是在同样一个节点执行的
A029095-NC1667802623784
taskname=job1
执行时间：Mon Nov 07 14:30:32 CST 2022
A029095-NC1667802623784
taskname=job2
执行时间：Mon Nov 07 14:30:32 CST 2022
A029095-NC1667802623784
taskname=job1
执行时间：Mon Nov 07 14:30:42 CST 2022
A029095-NC1667802623784
taskname=job2
执行时间：Mon Nov 07 14:30:42 CST 2022
换一个端口号在启动一个节点
第一个节点
A029095-NC1667802623784
taskname=job1
执行时间：Mon Nov 07 14:31:42 CST 2022
A029095-NC1667802623784
taskname=job1
执行时间：Mon Nov 07 14:31:52 CST 2022
第二个节点
A029095-NC1667802696272
taskname=job2
执行时间：Mon Nov 07 14:31:42 CST 2022
A029095-NC1667802696272
taskname=job2
执行时间：Mon Nov 07 14:31:52 CST 2022
v