Quartz：定时任务调度框架

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: DefaultQuartzScheduler
  org.quartz.scheduler.rmi.export: false
  org.quartz.scheduler.rmi.proxy: false
  org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
  org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
  org.quartz.threadPool.threadCount: 10
  org.quartz.threadPool.threadPriority: 5
  org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
  org.quartz.jobStore.misfireThreshold: 60000
  org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore  # 标识Quartz的持久化存储是RAM
  

  Quartz中相关类

  

  • Job接口： 自己写的“定时程序”实现此接口的void execute(JobExecutionContext arg0)方法,Job还有一类为有状态的StatefulJob接口，如果我们需要在上一个作业执行完后，根据其执行结果再进行下次作业的执行，则需要实现此接口。

    public class XXXJobs implements Job {
        
        @Autowired
        private XXXService xxxService;
        // 自己写的实现void execute()方法
        @Override
        public 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 {
                @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());
                }
            }
            -----------------------------------------------------------------------------------------
            public class Test {
                public static void main(String[] args) throws SchedulerException {
                    
                    //创建一个scheduler
                    Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
                    scheduler.getContext().put("skey", "svalue");
                    
                    //创建一个Trigger
                    Trigger trigger = TriggerBuilder.newTrigger()
                            .withIdentity("trigger1", "group1")
                            .usingJobData("t1", "tv1")
                            .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3)
                                    .repeatForever()).build();
                    trigger.getJobDataMap().put("t2", "tv2");
                    
                    //创建一个job
                    JobDetail job = JobBuilder.newJob(HelloJob.class)
                                .usingJobData("j1", "jv1")
                                .withIdentity("myjob", "mygroup").build();
                    job.getJobDataMap().put("j2", "jv2");
                    
                    //注册trigger并启动scheduler
                    scheduler.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中

                //监听所有的Job
                scheduler.getListenerManager().addJobListener(new SimpleJobListener(), EverythingMatcher.allJobs());
                //监听特定的Job
                scheduler.getListenerManager().addJobListener(new SimpleJobListener(), KeyMatcher.keyEquals(JobKey.jobKey("HelloWorld1_Job", "HelloWorld1_Group")));
                //监听同一任务组的Job
                scheduler.getListenerManager().addJobListener(new SimpleJobListener(), GroupMatcher.jobGroupEquals("HelloWorld2_Group"));
                //监听两个任务组的Job
                scheduler.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中：

                  //监听所有的Trigger
                  scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), EverythingMatcher.allTriggers());
                  //监听特定的Trigger
                  scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), KeyMatcher.keyEquals(TriggerKey.triggerKey("HelloWord1_Job", "HelloWorld1_Group")));
                  //监听一组Trigger
                  scheduler.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依赖

                      
                          org.springframework.boot
                          spring-boot-starter-quartz
                      
                      

                      • 新建Job，实现想要执行的任务

                        import org.quartz.Job;
                        import org.quartz.JobExecutionContext;
                        import java.time.LocalDateTime;
                        import java.time.format.DateTimeFormatter;
                        public class SimpleJob implements Job {
                            @Override
                            public 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 {
                              /*
                               * 基于时间间隔的定时任务
                               */
                              @Test
                              public 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、启动Scheduler
                                  scheduler.start();
                                  // 休眠，决定调度器运行时间，这里设置30s
                                  TimeUnit.SECONDS.sleep(30);
                                  // 关闭Scheduler
                                  scheduler.shutdown();
                              }
                          }
                          

                          附

                          参考：https://blog.csdn.net/mu_wind/article/details/124257719

                          cron在线生成：https://cron.qqe2.com/