SpringBoot 2.0+与Quartz的集成

最新推荐文章于 2024-08-13 10:44:34 发布

我小叮当无可奈何

最新推荐文章于 2024-08-13 10:44:34 发布

阅读量1.5k

点赞数

分类专栏： springboot项目文章标签： Quartz Springboot2.0+ springboot 定时器 quartz集群

本文链接：https://blog.csdn.net/qq_33407429/article/details/89848966

版权

springboot项目专栏收录该内容

23 篇文章 0 订阅

订阅专栏

由于项目需要用到quartz集群，所以总结了一下quartz的使用方法

一、什么是Quartz

Quartz是一个强大任务调度框架，工作时候会在这些情况下使用到quartz框架，列举3个实际用到的场景

监控平台会自动审核物品
餐厅系统会在每周四晚上的22点自动审核并生成报表
人事系统会在每天早晨8点给有待办的人员自动发送Email提醒

1.1 Quartz特点

作为一个优秀的开源调度框架，Quartz 具有以下特点：

强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求；
灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数据的多种存储方式；
分布式和集群能力，Terracotta 收购后在原来功能基础上作了进一步提升。

另外，作为 Spring 默认的调度框架，Quartz 很容易与 Spring 集成实现灵活可配置的调度功能
quartz调度核心元素

Scheduler:任务调度器，是实际执行任务调度的控制器。在spring中通过SchedulerFactoryBean封装起来。
Trigger：触发器，用于定义任务调度的时间规则，有SimpleTrigger,CronTrigger,DateIntervalTrigger和NthIncludedDayTrigger，其中CronTrigger用的比较多，本文主要介绍这种方式。CronTrigger在spring中封装在CronTriggerFactoryBean中。
Calendar:它是一些日历特定时间点的集合。一个trigger可以包含多个Calendar，以便排除或包含某些时间点。
JobDetail:用来描述Job实现类及其它相关的静态信息，如Job名字、关联监听器等信息。在spring中有JobDetailFactoryBean和 MethodInvokingJobDetailFactoryBean两种实现，如果任务调度只需要执行某个类的某个方法，就可以通过MethodInvokingJobDetailFactoryBean来调用。
Job(执行逻辑)：是一个接口，只有一个方法void execute(JobExecutionContext context),开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上下文的各种信息。Job运行时的信息保存在JobDataMap实例中。实现Job接口的任务，默认是无状态的，若要将Job设置成有状态的，在quartz中是给实现的Job添加@DisallowConcurrentExecution注解（以前是实现StatefulJob接口，现在已被Deprecated）,在与spring结合中可以在spring配置文件的job detail中配置concurrent参数。

在这里插入图片描述
主要线程
在Quartz中，有两类线程，也即执行线程和调度线程，其中执行任务的线程通常用一个线程池维护
Scheduler调度线程主要有两个：regular Scheduler Thread（执行常规调度）和Misfire Scheduler Thread（执行错失的任务）。其中Regular Thread 轮询Trigger，如果有将要触发的Trigger，则从任务线程池中获取一个空闲线程，然后执行与改Trigger关联的job；Misfire Thraed则是扫描所有的trigger，查看是否有错失的，如果有的话，根据一定的策略进行处理
在这里插入图片描述
数据存储
Quartz中的trigger和job需要存储下来才能被使用。Quartz中有两种存储方式：RAMJobStore,JobStoreSupport，其中RAMJobStore是将trigger和job存储在内存中，而JobStoreSupport是基于jdbc将trigger和job存储到数据库中。RAMJobStore的存取速度非常快，但是由于其在系统被停止后所有的数据都会丢失，所以在集群应用中，必须使用JobStoreSupport。表结构如表1-1所示。

1.2 Quartz集群

一个Quartz集群中的每个节点是一个独立的Quartz应用，它又管理着其他的节点。这就意味着你必须对每个节点分别启动或停止。Quartz集群中，独立的Quartz节点并不与另一其的节点或是管理节点通信，而是通过相同的数据库表来感知到另一Quartz应用的。

二、Quartz主要流程

2.1 启动流程

若quartz是配置在spring中，当服务器启动时，就会装载相关的bean。SchedulerFactoryBean实现了InitializingBean接口，因此在初始化bean的时候，会执行afterPropertiesSet方法，该方法将会调用SchedulerFactory(DirectSchedulerFactory 或者 StdSchedulerFactory，通常用StdSchedulerFactory)创建Scheduler。SchedulerFactory在创建quartzScheduler的过程中，将会读取配置参数，初始化各个组件，关键组件如下：

1. ThreadPool
一般是使用SimpleThreadPool,SimpleThreadPool创建了一定数量的WorkerThread实例来使得Job能够在线程中进行处理。WorkerThread是定义在SimpleThreadPool类中的内部类，它实质上就是一个线程。在SimpleThreadPool中有三个list：workers-存放池中所有的线程引用，availWorkers-存放所有空闲的线程，busyWorkers-存放所有工作中的线程；
线程池的配置参数如下所示：

org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=3
org.quartz.threadPool.threadPriority=5

2. JobStore
分为存储在内存的RAMJobStore和存储在数据库的JobStoreSupport(包括JobStoreTX和JobStoreCMT两种实现，JobStoreCMT是依赖于容器来进行事务的管理，而JobStoreTX是自己管理事务），若要使用集群要使用JobStoreSupport的方式；

3. QuartzSchedulerThread
用来进行任务调度的线程，在初始化的时候paused=true,halted=false,虽然线程开始运行了，但是paused=true，线程会一直等待，直到start方法将paused置为false；

另外，SchedulerFactoryBean还实现了SmartLifeCycle接口，因此初始化完成后，会执行start()方法，该方法将主要会执行以下的几个动作：

创建ClusterManager线程并启动线程:该线程用来进行集群故障检测和处理，将在下文详细讨论；
创建MisfireHandler线程并启动线程:该线程用来进行misfire任务的处理，将在下文详细讨论；
置QuartzSchedulerThread的paused=false，调度线程才真正开始调度；
在这里插入图片描述

2.2 QuartzSchedulerThread线程

先获取线程池中的可用线程数量（若没有可用的会阻塞，直到有可用的）；
获取30m内要执行的trigger(即acquireNextTriggers)：
获取trigger的锁，通过select …for update方式实现；获取30m内（可配置）要执行的triggers（需要保证集群节点的时间一致），若@ConcurrentExectionDisallowed且列表存在该条trigger则跳过，否则更新trigger状态为ACQUIRED(刚开始为WAITING)；插入firedTrigger表，状态为ACQUIRED;（注意：在RAMJobStore中，有个timeTriggers，排序方式是按触发时间nextFireTime排的；JobStoreSupport从数据库取出triggers时是按照nextFireTime排序）;
等待直到获取的trigger中最先执行的trigger在2ms内；
triggersFired：
5.1更新firedTrigger的status=EXECUTING;
5.2更新trigger下一次触发的时间；
5.3更新trigger的状态：无状态的trigger->WAITING，有状态的trigger->BLOCKED，若nextFireTime==null ->COMPLETE；
5.4commit connection,释放锁；
针对每个要执行的trigger，创建JobRunShell，并放入线程池执行：
6.1execute:执行job
6.2获取TRIGGER_ACCESS锁
6.3若是有状态的job：更新trigger状态：BLOCKED->WAITING,PAUSED_BLOCKED->BLOCKED
6.4若@PersistJobDataAfterExecution，则updateJobData
6.5删除firedTrigger
6.6commit connection，释放锁
步骤如下

调度过程中Trigger状态变化;

2.3 MisfireHandler线程

下面这些原因可能造成 misfired job:

2.3.1 系统因为某些原因被重启。在系统关闭到重新启动之间的一段时间里，可能有些任务会被 misfire；

2.3.2 Trigger 被暂停（suspend）的一段时间里，有些任务可能会被 misfire；

2.3.3 线程池中所有线程都被占用，导致任务无法被触发执行，造成 misfire；

2.3.4 有状态任务在下次触发时间到达时，上次执行还没有结束；为了处理 misfired job，Quartz 中为 trigger 定义了处理策略，主要有下面两种：
MISFIRE_INSTRUCTION_FIRE_ONCE_NOW：针对 misfired job 马上执行一次；

MISFIRE_INSTRUCTION_DO_NOTHING：忽略 misfired job，等待下次触发；默认是MISFIRE_INSTRUCTION_SMART_POLICY，该策略在CronTrigger中=MISFIRE_INSTRUCTION_FIRE_ONCE_NOW线程默认1分钟执行一次；在一个事务中，默认一次最多recovery 20个；

执行流程：

若配置(默认为true，可配置)成获取锁前先检查是否有需要recovery的trigger，先获取misfireCount；
获取TRIGGER_ACCESS锁；
hasMisfiredTriggersInState：获取misfired的trigger，默认一个事务里只能最大20个misfired
trigger（可配置），misfired判断依据：status=waiting,next_fire_time <
current_time-misfirethreshold(可配置，默认1min)
notifyTriggerListenersMisfired
updateAfterMisfire:获取misfire策略(默认是MISFIRE_INSTRUCTION_SMART_POLICY，该策略在CronTrigger中=MISFIRE_INSTRUCTION_FIRE_ONCE_NOW)，根据策略更新nextFireTime；
将nextFireTime等更新到trigger表；
commit connection，释放锁8.如果还有更多的misfired，sleep短暂时间(为了集群负载均衡)，否则sleep
misfirethreshold时间，后继续轮询；

misfireHandler线程执行流程如图所示
在这里插入图片描述

2.4 ClusterManager集群管理线程

初始化：

failedInstance=failed+self+firedTrigger表中的schedulerName在scheduler_state表中找不到的（孤儿）

线程执行：

每个服务器会定时(org.quartz.jobStore.clusterCheckinInterval这个时间)更新SCHEDULER_STATE表的LAST_CHECKIN_TIME，若这个字段远远超出了该更新的时间，则认为该服务器实例挂了；

注意：每个服务器实例有唯一的id，若配置为AUTO，则为hostname+current_time

线程执行的具体流程：

检查是否有超时的实例failedInstances;
更新该服务器实例的LAST_CHECKIN_TIME；
若有超时的实例：
获取STATE_ACCESS锁；
获取超时的实例failedInstances;
获取TRIGGER_ACCESS锁；
clusterRecover:
针对每个failedInstances，通过instanceId获取每个实例的firedTriggers;
针对每个firedTrigger：
更新trigger状态：
BLOCKED->WAITING
PAUSED_BLOCKED->PAUSED
ACQUIRED->WAITING
若firedTrigger不是ACQUIRED状态（在执行状态）,且jobRequestRecovery=true:
创建一个SimpleTrigger，存储到trigger表，status=waiting,MISFIRE_INSTR=MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY.
删除firedTrigger
clusterManager线程执行时序图如图
在这里插入图片描述

2.7 问题列表

时间同步问题

Quartz实际并不关心你是在相同还是不同的机器上运行节点。当集群放置在不同的机器上时，称之为水平集群。节点跑在同一台机器上时，称之为垂直集群。对于垂直集群，存在着单点故障的问题。这对高可用性的应用来说是无法接受的，因为一旦机器崩溃了，所有的节点也就被终止了。对于水平集群，存在着时间同步问题。

节点用时间戳来通知其他实例它自己的最后检入时间。假如节点的时钟被设置为将来的时间，那么运行中的Scheduler将再也意识不到那个结点已经宕掉了。另一方面，如果某个节点的时钟被设置为过去的时间，也许另一节点就会认定那个节点已宕掉并试图接过它的Job重运行。最简单的同步计算机时钟的方式是使用某一个Internet时间服务器(Internet Time Server ITS)。

节点争抢Job问题

因为Quartz使用了一个随机的负载均衡算法，Job以随机的方式由不同的实例执行。Quartz官网上提到当前，还不存在一个方法来指派(钉住) 一个 Job 到集群中特定的节点。

从集群获取Job列表问题

当前，如果不直接进到数据库查询的话，还没有一个简单的方式来得到集群中所有正在执行的Job列表。请求一个Scheduler实例，将只能得到在那个实例上正运行Job的列表。Quartz官网建议可以通过写一些访问数据库JDBC代码来从相应的表中获取全部的Job信息

三、Springboot集成Quartz

目录结构如下：
在这里插入图片描述

3.1 pom.xml添加依赖

         <!-- spring boot2.x + quartz  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

3.2 application.yml增加配置

#日志
logging:
  level:
    com:
      alipay:
        demo:
          mapper: debug
          quartz: debug
  file: quartz-service.log

#Mybatis
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  mapperLocations: /mapper/*.xml
  typeAliasesPackage: com.hiQiBlog.entity
#端口
server:
  port: 8090
  tomcat:
    uri-encoding: utf-8
#durid框架
spring:
  datasource:
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
    driver-class-name: com.mysql.cj.jdbc.Driver
    exceptionSorter: true
    filters: stat,wall,log4j
    initialSize: 5
    maxActive: 20
    maxPoolPreparedStatementPerConnectionSize: 20
    maxWait: 60000
    minEvictableIdleTimeMillis: 300000
    minIdle: 5
    password: 123456
    poolPreparedStatements: true
    testOnBorrow: false
    testOnReturn: false
    testWhileIdle: true
    timeBetweenEvictionRunsMillis: 60000
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC
    useGlobalDataSourceStat: true
    username: root
    validationQuery: SELECT 1 FROM DUAL
  mvc:
    static-path-pattern: /static/**
    view:
      prefix: /templates/
      suffix: .html
 #缓存
  redis:
    database: 3
    host: 127.0.0.1
    jedis:
      pool:
        max-active: 8
        max-idle: 8
        max-wait: -1
        min-idle: 0
      shutdown-timeout: 100
    password: ''
    port: 6379
    timeout: 3600
#Quartz
quartz:
  #相关属性配置
  properties:
    org:
      quartz:
        scheduler:
          instanceName: clusteredScheduler
          instanceId: AUTO
        jobStore:
          class: org.quartz.impl.jdbcjobstore.JobStoreTX
          driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
          tablePrefix: QRTZ_
          isClustered: true
          clusterCheckinInterval: 10000
          useProperties: false
        threadPool:
          class: org.quartz.simpl.SimpleThreadPool
          threadCount: 10
          threadPriority: 5
          threadsInheritContextClassLoaderOfInitializingThread: true
  #数据库方式
  job-store-type: jdbc

3.3 新增myjob.class

package com.hiQiBlog.job;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.time.LocalDateTime;

public class MyJob extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("start My Job：" + LocalDateTime.now());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end  My Job：" + LocalDateTime.now());

    }
}

3.4 新增MyCronJob.class

package com.hiQiBlog.job;

import com.hiQiBlog.controller.UserController;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.util.Date;

public class MyCronJob extends QuartzJobBean {

    @Autowired
    UserController userController;

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("任务执行了" + new Date());
        // indexController.testMail();
    }
}

3.5 新增QuartzConfiguration.class

package com.hiQiBlog.config;

import com.hiQiBlog.job.MyCronJob;
import com.hiQiBlog.job.MyJob;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//其实现在的配置就等价于在传统的xml中配置bean是一样的。
@Configuration
public class QuartzConfiguration {

    // 使用jobDetail包装job
    @Bean
    public JobDetail myJobDetail() {
        return JobBuilder.newJob(MyJob.class).withIdentity("myJob").storeDurably().build();
    }

    // 把jobDetail注册到trigger上去
    @Bean
    public Trigger myJobTrigger() {
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(15).repeatForever();

        return TriggerBuilder.newTrigger()
                .forJob(myJobDetail())
                .withIdentity("myJobTrigger")
                .withSchedule(scheduleBuilder)
                .build();
    }

    // 使用jobDetail包装job
    @Bean
    public JobDetail myCronJobDetail() {
        return JobBuilder.newJob(MyCronJob.class).withIdentity("myCronJob").storeDurably().build();
    }

    // 把jobDetail注册到Cron表达式的trigger上去
    @Bean
    public Trigger CronJobTrigger() {
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/10 * * * * ?");

        return TriggerBuilder.newTrigger()
                .forJob(myCronJobDetail())
                .withIdentity("myCronJobTrigger")
                .withSchedule(cronScheduleBuilder)
                .build();
    }
}