Quartz主要内容

Quartz是一个开源的任务调度框架，负责任务进度管理（就是一个在预先被纳入日程，当时间到达时，负责执行（或者通知）其他软件组件的系统），由OpenSymphony（一个开源组织）开发，这个框架进行了优良地解耦设计，
Quartz主要功能，就是在设定的时间内干什么事情，比如说把redis中的缓存数据与数据库中的数据进行同步、定时发送信息、设置一个周三才开始的活动。Quartz是一个基于Java实现的任务调度框架，应该说叫定时任务调度框架。在Java领域，有很多定时任务框架，这里简单对比一下目前比较流行的三款：

Quartz主要分为三大部分：

  • Job：定时执行的具体工作内容，想要调度的任务都必须实现 org.quartz.job 接口，然后实现接口中定义的 execute( ) 方法即可。
  • Trigger：触发器，指定运行参数，包括运行次数、运行开始时间和技术时间、运行时长等，如果想要凌晨1点执行备份数据的任务，那么 Trigger 就会设置凌晨1点执行该任务。其中 Trigger 又分为 SimpleTrigger 和 CronTrigger 两种。
  • Scheduler：调度器，将Job和Trigger组装起来，使定时任务被真正执行，主要负责基于Trigger设置的时间来启动、暂停、恢复、停止和触发时间修改对应的任务。

下图是Quartz主要的关系图:

文字化的描述就是，Job通过实现类与Trigger进行绑定，一个Job可以绑定多个Trigger（实现了Quartz的异步通知），但是一个Trigger只能绑定一个Job，且Job的实现类与Trigger通过Group和name来标识唯一性，Quartz是使用多线程来处理任务的。

Quartz集群

Quartz集群中每个节点是一个独立的Quartz任务应用，它又管理者其他节点。该集群需要分别对每个节点分别启动或停止，独立的Quartz节点并不与另一个节点或是管理节点通信。Quartz应用是通过共有相同数据库表来感知到另一应用。也就是说只有使用持久化JobStore存储Job和Trigger才能完成Quartz集群部署方案。
Quartz的集群部署方案是分布式的，没有负责集中管理的节点，而是利用数据库行锁的方式来实现集群环境下的并发控制。Quartz主要有两个行锁：

锁名解释
STATE_ACCESS状态访问锁
Trigger_ACCESS触发器访问锁

一个scheduler实例在集群模式下首先获取行锁才行。Quartz集群争用触发器行锁，锁被占用只能等待，获取触发器行锁之后，先获取需要等待触发的其他触发器信息。
定时任务的诸多要素，如任务名称、数量、状态、运行频率、运行时间等，是要存储起来的。JobStore，就是用来存储任务和触发器相关的信息的。Quartz 中有两种存储任务的方式，一种在在内存（RAMJobStore），一种是在数据库（JDBCJobStore）。
Quartz 默认的 JobStore 是 RAMJobstore，也就是把任务和触发器信息运行的信息存储在内存中，用到了 HashMap、TreeSet、HashSet 等等数据结构，如果程序崩溃或重启，所有存储在内存中的数据都会丢失。所以我们需要把这些数据持久化到磁盘。

# Default Properties file for use by StdSchedulerFactory# to create a Quartz Scheduler Instance, if a different# properties file is not explicitly specified.#org.quartz.scheduler.instanceName: DefaultQuartzSchedulerorg.quartz.scheduler.rmi.export: falseorg.quartz.scheduler.rmi.proxy: falseorg.quartz.scheduler.wrapJobExecutionInUserTransaction: falseorg.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPoolorg.quartz.threadPool.threadCount: 10org.quartz.threadPool.threadPriority: 5org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: trueorg.quartz.jobStore.misfireThreshold: 60000org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore# 标识Quartz的持久化存储是RAM

Quartz中相关类

  • Job接口： 自己写的“定时程序”实现此接口的void execute(JobExecutionContext arg0)方法,Job还有一类为有状态的StatefulJob接口，如果我们需要在上一个作业执行完后，根据其执行结果再进行下次作业的执行，则需要实现此接口。
public class XXXJobs implements Job {@Autowiredprivate XXXService xxxService;// 自己写的实现void execute()方法@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {log.debug("xxxQueueJob start...");// 分布式锁，如果获取失败则返回XXXJob proxy = ApplicationContextUtil.getBean(getClass());proxy.jobHandler();log.debug("xxxQueueJob end...");}@JobToken@RedisLock(expiration = 20L)public void jobHandler() {// 定时任务核心逻辑}}
  • Trigger抽象类： 调度类(Scheduler)在时间到时调用此类，再由trigger类调用指定的定时程序。Quertz中提供了两类触发器为：SimpleTrigger,CronTrigger。前者用于实现比较简单的定时功能，例如几点开始，几点结束，隔多长时间执行，共执行多少次等，后者提供了使用表达式来描述定时功能，因此适用于比较复杂的定时描述，例如每个月的最后一个周五，每周的周四等。
    • SimpleTrigger：简单触发器，支持定义任务执行的间隔时间，执行次数的规则有两种，一是定义重复次数，二是定义开始时间和结束时间。如果同时设置了结束时间与重复次数，先结束的会覆盖后结束的，以先结束的为准。
    • CronTrigger：基于Cron表达式的触发器。
    • CalendarIntervalTrigger：基于日历的触发器，比简单触发器更多时间单位，且能智能区分大小月和平闰年。
    • DailyTimeIntervalTrigger：基于日期的触发器，如每天的某个时间段。

Trigger是有状态的：NONE, NORMAL, PAUSED, COMPLETE, ERROR, BLOCKED，状态之间转换关系如下图所示：

 Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "trigger-group").startNow()//立即生效.forJob(jobDetail).withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2) //每隔3s执行一次.repeatForever()) // 永久循环.build();
  • JobDetail类： 具体某个定时程序的详细描述，包括Name,Group,JobDataMap等。
JobDataMap jobDataMap = jobDetail.getJobDataMap();String name = jobDetail.getKey().getName();String group = jobDetail.getKey().getGroup();String jobName = jobDetail.getJobClass().getName();
  • JobExecutionContext类： 定时程序执行的run-time的上下文环境，用于得到当前执行的Job的名字，配置的参数等。
  • JobDataMap类： 用于描述一个作业的参数，参数可以为任何基本类型例如String,float等，也可为某个对象的引用.
  • JobListener,TriggerListener接口： 用于监听触发器状态和作业扫行状态，在特写状态执行相应操作。
  • JobStore类： 在哪里执行定进程序，可选的有在内存中，在数据库中。
public class HelloJob implements Job {@Overridepublic 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());}}-----------------------------------------------------------------------------------------public class Test {public static void main(String[] args) throws SchedulerException {//创建一个schedulerScheduler scheduler = StdSchedulerFactory.getDefaultScheduler();scheduler.getContext().put("skey", "svalue");//创建一个TriggerTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1").usingJobData("t1", "tv1").withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever()).build();trigger.getJobDataMap().put("t2", "tv2");//创建一个jobJobDetail job = JobBuilder.newJob(HelloJob.class).usingJobData("j1", "jv1").withIdentity("myjob", "mygroup").build();job.getJobDataMap().put("j2", "jv2");//注册trigger并启动schedulerscheduler.scheduleJob(job,trigger);scheduler.start(); }}

Quartz监听器

在 Quartz 中三个核心模块分别是 Job、Trigger、Scheduler，既然 Quartz中存在监听器，相应的，这三者也分别有对应的监听器。监听器的作用便是用于当任务调度中你所关注事件发生时，能够及时获取这一事件的通知。监听器也有作用域，主要分为

  • 全局监听器：能够接收到所有的Job/Trigger的事件通知；
  • 局部监听器：只能接收在其上注册Job或者Trigger的事件；

三核心监听器：

  • JobListener

任务调度中，与任务 Job 相关的事件包括： Job 开始要执行的提示，执行完成的提示，接口如下：

package org.quartz;public interface JobListener {String getName(); //用于获取改JobListener 的名称// Scheduler 在 JobDetail 将要被执行时调用这个方法void jobToBeExecuted(JobExecutionContext var1);// cheduler 在 JobDetail 即将被执行，但又被 TriggerListener 否决时会调用该方法void jobExecutionVetoed(JobExecutionContext var1);// Scheduler 在 JobDetail 被执行之后调用这个方法void jobWasExecuted(JobExecutionContext var1, JobExecutionException var2);}

将JobListener绑定到Scheduler中

//监听所有的Jobscheduler.getListenerManager().addJobListener(new SimpleJobListener(), EverythingMatcher.allJobs());//监听特定的Jobscheduler.getListenerManager().addJobListener(new SimpleJobListener(), KeyMatcher.keyEquals(JobKey.jobKey("HelloWorld1_Job", "HelloWorld1_Group")));//监听同一任务组的Jobscheduler.getListenerManager().addJobListener(new SimpleJobListener(), GroupMatcher.jobGroupEquals("HelloWorld2_Group"));//监听两个任务组的Jobscheduler.getListenerManager().addJobListener(new SimpleJobListener(), OrMatcher.or(GroupMatcher.jobGroupEquals("HelloWorld1_Group"), GroupMatcher.jobGroupEquals("HelloWorld2_Group")));
  • TriggerListener

任务调度中，与触发器 Trigger 相关的事件包括： 触发器触发、触发器未正常触发、触发器完成等，接口如下：

package org.quartz;import org.quartz.Trigger.CompletedExecutionInstruction;public interface TriggerListener {String getName(); //用于获取触发器的名称// 当与监听器相关联的Trigger被触发，Job上的**execute()**方法将被执行时，Scheduler就调用该方法void triggerFired(Trigger var1, JobExecutionContext var2);//在 Trigger 触发后，Job 将要被执行时由 Scheduler 调用这个方法。// TriggerListener 给了一个选择去否决 Job 的执行。假如这个方法返回 true，这个 Job 将不会为此次 Trigger 触发而得到执行boolean vetoJobExecution(Trigger var1, JobExecutionContext var2);// Scheduler 调用这个方法是在 Trigger 错过触发时void triggerMisfired(Trigger var1);// Trigger 被触发并且完成了 Job 的执行时，Scheduler 调用这个方法void triggerComplete(Trigger var1, JobExecutionContext var2, CompletedExecutionInstruction var3);}

将TriggerListener绑定到Scheduler中：

//监听所有的Triggerscheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), EverythingMatcher.allTriggers());//监听特定的Triggerscheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), KeyMatcher.keyEquals(TriggerKey.triggerKey("HelloWord1_Job", "HelloWorld1_Group")));//监听一组Triggerscheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), GroupMatcher.groupEquals("HelloWorld1_Group"));//移除监听器scheduler.getListenerManager().removeTriggerListener("SimpleTrigger");
  • SchedulerListener

SchedulerListener会在Scheduler的生命周期中关键事件发生时被调用。与Scheduler有关的事件包括：增加一个job/trigger，删除一个job/trigger，scheduler发生严重错误，关闭scheduler等。接口如下：

package org.quartz;public interface SchedulerListener {// 用于部署JobDetail时调用void jobScheduled(Trigger var1);// 用于卸载JobDetail时调用void jobUnscheduled(TriggerKey var1);// 当一个 Trigger 来到了再也不会触发的状态时调用这个方法void triggerFinalized(Trigger var1);// Scheduler 调用这个方法是发生在一个 Trigger 或 Trigger 组被暂停时void triggerPaused(TriggerKey var1);void triggersPaused(String var1);// Scheduler 调用这个方法是发生成一个 Trigger 或 Trigger 组从暂停中恢复时void triggerResumed(TriggerKey var1);void triggersResumed(String var1);void jobAdded(JobDetail var1);void jobDeleted(JobKey var1);void jobPaused(JobKey var1);void jobsPaused(String var1);void jobResumed(JobKey var1);void jobsResumed(String var1);void schedulerError(String var1, SchedulerException var2);void schedulerInStandbyMode();// 当Scheduler处于StandBy模式时，调用该方法void schedulerStarted();void schedulerStarting();void schedulerShutdown();void schedulerShuttingdown();void schedulingDataCleared();}

将SchedulerListener绑定到Scheduler中

//创建监听scheduler.getListenerManager().addSchedulerListener(new SimpleSchedulerListener());//移除监听scheduler.getListenerManager().removeSchedulerListener(new SimpleSchedulerListener());

Quartz使用流程

  • 引入Maven依赖
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-quartz</artifactId></dependency>
  • 新建Job，实现想要执行的任务
import org.quartz.Job;import org.quartz.JobExecutionContext;import java.time.LocalDateTime;import java.time.format.DateTimeFormatter;public class SimpleJob implements Job {@Overridepublic void execute(JobExecutionContext jobExecutionContext) {// 创建一个事件，下面仅创建一个输出语句作演示System.out.println(Thread.currentThread().getName() + "--" + DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()));}}
  • 创建Trigger与Scheduler，执行定时任务
import com.quartz.demo.schedule.SimpleJob;import org.junit.jupiter.api.Test;import org.quartz.*;import org.quartz.impl.StdSchedulerFactory;import java.util.Date;import java.util.concurrent.TimeUnit;public class SimpleQuartzTest {/* * 基于时间间隔的定时任务 */@Testpublic void simpleTest() throws SchedulerException, InterruptedException {// 1、创建Scheduler（调度器）SchedulerFactory schedulerFactory = new StdSchedulerFactory();Scheduler scheduler = schedulerFactory.getScheduler();// 2、创建JobDetail实例，并与SimpleJob类绑定(Job执行内容)JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class).withIdentity("job1", "group1").build();// 3、构建Trigger（触发器），定义执行频率和时长Trigger trigger = TriggerBuilder.newTrigger()// 指定group和name，这是唯一身份标识.withIdentity("trigger-1", "trigger-group").startNow()//立即生效.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2) //每隔2s执行一次.repeatForever())// 永久执行.build();//4、将Job和Trigger交给Scheduler调度scheduler.scheduleJob(jobDetail, trigger);// 5、启动Schedulerscheduler.start();// 休眠，决定调度器运行时间，这里设置30sTimeUnit.SECONDS.sleep(30);// 关闭Schedulerscheduler.shutdown();}}

附
参考：https://blog.csdn.net/mu_wind/article/details/124257719
cron在线生成：https://cron.qqe2.com/