分布式调度器Quartz解读

术语：

scheduler：任务调度器

job： 被调度的任务

trigger：触发器，用于定义Job调度时间规则，一个Job可对应多个trigger

misfire：本来应该被执行但实际没有被执行的任务调度

一 概述

Quartz是一个用JAVA实现的开源的任务调度框架。

Quartz 任务调度的核心元素是 scheduler, trigger 和 job，job是被调度执行的任务，trigger定义了job何时被调度的规则， scheduler 是实际执行调度的控制器。

Quartz集群中的每个节点是一个独立的Quartz应用，没有负责集中管理的节点。节点将自身信息注册至数据库的qrtz_scheduler_state表中，并定时刷新心跳。节点间通过数据库表来感知到另一节点，通过qrtz_locks表的行锁来进行通信（STATE_ACCESS/TRIGGER_ACCESS）。

Quartz数据库核心表如下：

QRTZ_CRON_TRIGGERS 存储CronTrigger，包括Cron表达式和时区信息

QRTZ_FIRED_TRIGGERS 存储与已触发的Trigger相关的状态信息

QRTZ_PAUSED_TRIGGER_GRPS 存储已暂停的Trigger组的信息

QRTZ_SCHEDULER_STATE 存储Schedulers的状态信息

QRTZ_LOCKS 存储程序的悲观锁的信息

QRTZ_JOB_DETAILS 存储Job的详细信息

QRTZ_SIMPLE_TRIGGERS 存储简单的Trigger，包括重复次数、间隔、以及已触的次数

QRTZ_BLOG_TRIGGERS Trigger作为Blob类型存储

QRTZ_TRIGGERS 存储已配置的Trigger的信息，包含下一次调度的时间

二 使用流程

1 quartz集群部署

集群初始化

//从配置文件初始化schedulerFactory
SchedulerFactory schedulerFactory = new StdSchedulerFactory(properties);

//创建scheduler
scheduler = schedulerFactory.getScheduler();

//启动scheduler
scheduler.start();

2 实现Job接口

public class JobImpl implements Job {
  @Override
  //Job被调度时执行的方法
    public void execute(JobExecutionContext context) throws JobExecutionException {
        //bussiness code
   }
}

3 向scheduler注册Job

JobKey jobKey = new JobKey(jobName, jobGroupName);

JobDetail jobDetail = newJob(JobImpl.class).withIdentity(jobKey).build();

scheduler.addJob(jobDetail, false, true);

4 向scheduler注册trigger

TriggerKey triggerKey = new TriggerKey(jobName, jobGroupName);

//有多种Trigger的实现类
CronTrigger cronTrigger = newTrigger().withIdentity(triggerKey)
.startAt(startDate) //trigger的有效时间
.endAt(endDate)
.withSchedule(cronSchedule(cronExpression) //cron表达式                                                      
.withMisfireHandlingInstructionDoNothing()) //misfire策略
.forJob(jobDetail) //关联Job
.build();

scheduler.scheduleJob(cronTrigger); //向scheduler注册

Quartz提供了四种trigger：SimpleTrigger，CronTirgger，DateIntervalTrigger， NthIncludedDayTrigger

三 源码解读

1. 初始化Scheduler

SchedulerFactory.getScheduler()
用来获取一个调度器，并初始化它所依赖的各个组件；

a) 初始化scheduler -> quartzScheduler -> quartzSchedulerThread；

scheduler: quartzScheduler实例的代理
quartzScheduler: quartz的核心部分，用于调度Job和注册JobListener
quartzSchedulerThread: quartzScheduler的成员变量，用于获取/触发Trigger的线程

b) 初始化JobStore,用于quartzScheduler操作Job和Trigger；

有两种实现：
RAMJobStore，Trigger和Job放在内存里；
JobStoreSupport，存在数据库中；通常采用这种方式；

2. 启动quartzScheduler

Scheduler.start()
启动调度器，集群开始工作；

 public void start() throws SchedulerException {
    ```
    // 通知SchedulerListener scheduler开始启动；SchedulerListener用于监听一些Scheduler执行Job的事件，如Job执行完成；
    notifySchedulerListenersStarting();

    //创建并启动clusterManager，用于集群故障检测；
    //创建并启动MisfireHandler，处理misfired job；有不同的策略，简单来说分为：立即触发一次或忽略；PFlow的配置是忽略；定义trigger时配置；
    this.resources.getJobStore().schedulerStarted();           

    //启动插件
    startPlugins();

    //唤醒quartzSchedulerThread，用于具体的调度；
    schedThread.togglePause(false);

    //通知schedulerListener启动已完成
    notifySchedulerListenersStarted();

}

3. quartzScheduler的核心逻辑

QuartzSchedulerThread.run()
从数据库中循环的查找30秒内将要被触发的trigger，异步执行对应的Job，最后释放trigger .

主要逻辑：

 public void run() {
   boolean lastAcquireFailed = false;
   while (!halted.get()) {
    //等待被quartzScheduler启动时nodify
    while (paused && !halted.get()) {
        sigLock.wait(1000L);
    }
     ......

    //检查线程池中的可用线程数. 'will always be true, due to semantics of blockForAvailableThreads'
    int availThreadCount = qsRsrcs.getThreadPool().blockForAvailableThreads();
    if(availThreadCount > 0) {

     ......

     //调度器在trigger队列中寻找30秒内一定数目的trigger(需要保证集群节点的系统时间一致)
     triggers = qsRsrcs.getJobStore().acquireNextTriggers(now + idleWaitTime, Math.min(availThreadCount,qsRsrcs.getMaxBatchSize()), qsRsrcs.getBatchTimeWindow());

    //获取最近的trigger，等待并触发
    long triggerTime = triggers.get(0).getNextFireTime().getTime();
    long timeUntilTrigger = triggerTime - now;
    while(timeUntilTrigger > 2) {
        //假如没有新的更近的trigger fire时间点，就接着等待           
        if (!isCandidateNewTimeEarlierWithinReason(triggerTime, false)) {
            timeUntilTrigger = triggerTime - now;
            if(timeUntilTrigger >= 1)
                sigLock.wait(timeUntilTrigger);
        }

        //假如有更新的trigger就break，并重新获得30秒内将被fire的trigger
        if(releaseIfScheduleChangedSignificantly(triggers, triggerTime)) {
            break;
        }
        timeUntilTrigger = triggerTime - now;
    }
     ......

    //触发trigger, triggers中未满足触发条件的(state!=ACQUIRED)会被过滤
    List res = qsRsrcs.getJobStore().triggersFired(triggers);

    ......

    //释放trigger
    for (int i = 0; i < triggers.size(); i++) {
        qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));
    }
  }               
}

4. QuartzSchedulerThread如何操作Trigger - JobStore

QuartzSchedulerThread对于trigger的操作是通过JobStore来完成的，PFlow使用的实现类是JobStoreTX；

Trigger被持久化至mysql的qrtz_triggers表中；

对Trigger的操作都需要获得TRIGGER_ACCESS锁（mysql的行锁，具体：StdRowLockSemaphore)，以此保证线程安全；

最终调用的都是JobStoreSupport.executeInNonManagedTXLock方法;

例如获取trigger的方法

 public List acquireNextTriggers(final long noLaterThan, final int maxCount, final long timeWindow)
    throws JobPersistenceException {

    String lockName = LOCK_TRIGGER_ACCESS; //获得该锁后才可进行操作
    return executeInNonManagedTXLock(lockName,
            new TransactionCallback>() { //定义的回调函数，获得trigger
                public List execute(Connection conn) {
                    return acquireNextTrigger(conn, noLaterThan, maxCount, timeWindow);
                }
            },
            new TransactionValidator>() {
                    ...
            }
        return false;
    });
}

参考

https://tech.meituan.com/2014/08/31/mt-crm-quartz.html
http://wangtianzhi.cn/2016/01/03/quartz-source-analysis/
https://www.ibm.com/developerworks/cn/opensource/os-cn-quartz/