Quartz-QuartzSchedulerThread详解

QuartzSchedulerThread详解

QuartzSchedulerThread是一个线程类，负责查询并触发Triggers。

public class QuartzSchedulerThread extends Thread {
    QuartzSchedulerThread(QuartzScheduler qs, QuartzSchedulerResources qsRsrcs, boolean setDaemon, int threadPrio) {
        super(qs.getSchedulerThreadGroup(), qsRsrcs.getThreadName());
        ........
        paused = true;
        halted = new AtomicBoolean(false);
    }
}

该线程类的主要工作分为以下几个步骤：

• 等待QuartzScheduler启动
• 查询待触发的Trigger
• 等待Trigger触发时间到来
• 触发Trigger
• 循环上述步骤

/*-----------------run()方法有删减----------------------*/
public void run() {
    while (!halted.get()) {
        // -------------------------------
        // 1 等待QuartzScheduler启动
        // -------------------------------
        synchronized (sigLock) {
            while (paused && !halted.get()) {
                // wait until togglePause(false) is called...
                sigLock.wait(1000L);
            }
        }

        // -------------------------------
        // 2 查询待触发的Trigger
        // -------------------------------
        int availThreadCount = qsRsrcs.getThreadPool().blockForAvailableThreads();
        if(availThreadCount > 0) { // will always be true, due to semantics of blockForAvailableThreads...
            // 查询未来（now + idletime）时间内待触发的Triggers
            // triggers是按触发时间由近及远排序的集合
            List<OperableTrigger> triggers = qsRsrcs.getJobStore().acquireNextTriggers(
                    now + idleWaitTime, Math.min(availThreadCount, qsRsrcs.getMaxBatchSize()), qsRsrcs.getBatchTimeWindow());
            if (triggers != null && !triggers.isEmpty()) {
                now = System.currentTimeMillis();
                long triggerTime = triggers.get(0).getNextFireTime().getTime();
                long timeUntilTrigger = triggerTime - now;
                // 通过循环阻塞，等待第一个Trigger触发时间
                while(timeUntilTrigger > 2) {
                    synchronized (sigLock) {
                        if (halted.get()) {
                            break;
                        }
                    }
                    now = System.currentTimeMillis();
                    timeUntilTrigger = triggerTime - now;
                }
            // 通知JobStore，这些Triggers将要被触发
            List<TriggerFiredResult> res = qsRsrcs.getJobStore().triggersFired(triggers);
            if(res != null)
                bndles = res;
            }
            // -------------------------------
            // 3 触发Triggers
            // -------------------------------
            for (int i = 0; i < bndles.size(); i++) {
                TriggerFiredResult result =  bndles.get(i);
                TriggerFiredBundle bndle =  result.getTriggerFiredBundle();
                JobRunShell shell = qsRsrcs.getJobRunShellFactory().createJobRunShell(bndle);
                shell.initialize(qs);
                qsRsrcs.getThreadPool().runInThread(shell);
            }
            continue; // while (!halted)
        } else { // if(availThreadCount > 0)
            // should never happen, if threadPool.blockForAvailableThreads() follows contract
            continue; // while (!halted)
        }
    } // while (!halted)
}

1 等待QuartzScheduler启动

synchronized (sigLock) {
    while (paused && !halted.get()) {
        // wait until togglePause(false) is called...
        sigLock.wait(1000L);
    }
}

循环检查paused && !halted.get()条件是否满足，否则释放sigLock对象的锁，并等待，一秒后重试。
当QuartzScheduler对象创建并调用start()方法时，将唤醒QuartzSchedulerThread线程，即可跳出阻塞块，继续执行。

/*QuartzScheduler*/
public void start() throws SchedulerException {
    ....
    schedThread.togglePause(false);
    ....
}

/*QuartzSchedulerThread*/
void togglePause(boolean pause) {
    synchronized (sigLock) {
        // 更改暂停状态
        paused = pause;
        if (paused) {
            signalSchedulingChange(0);
        } else {
            // 唤醒在sigLock上等待的所有线程
            sigLock.notifyAll();
        }
    }
}

2 查询待触发的Trigger

Quartz未雨绸缪，从JobStore中获取当前时间后移一段时间内（idle time + time window）将要触发的Triggers，以及在当前时间前移一段时间内（misfireThreshold）错过触发的Triggers(这里仅查询Trigger的主要信息)。被查询到的Trggers状态变化：STATE_WAITING-->STATE_ACQUIRED。结果集是以触发时间升序、优先级降序的集合。

public List<TriggerKey> selectTriggerToAcquire(Connection conn, long noLaterThan, long noEarlierThan, int maxCount)
        throws SQLException {
}

SELECT
    TRIGGER_NAME,
    TRIGGER_GROUP,
    NEXT_FIRE_TIME,
    PRIORITY
FROM
    QRTZ_TRIGGERS
WHERE
    SCHED_NAME = 'TestScheduler'
AND TRIGGER_STATE = ?
AND NEXT_FIRE_TIME <= ?
AND (
    MISFIRE_INSTR = - 1
    OR (
        MISFIRE_INSTR != - 1
        AND NEXT_FIRE_TIME >= ?
    )
)
ORDER BY
    NEXT_FIRE_TIME ASC,
    PRIORITY DESC

3 等待Trigger触发时间到来

因为上一步取得的Triggers是按时间排序的集合，所以取集合中的第一个，即触发时间最早的Trigger，等待其触发时间的到来。老套路while循环+wait实现。
不过需要注意的是，在此期间，可能有一些新的情况发生，比如说，新增了一个Trigger，并且该新增的Trigger比前面获取的触发时间都早，那么就需要将上面获取的Trigger释放掉(状态变化:STATE_ACQUIRED-->STATE_WAITING)，然后重新查询Trggers

now = System.currentTimeMillis();
long triggerTime = triggers.get(0).getNextFireTime().getTime();
long timeUntilTrigger = triggerTime - now;
// 当触发时间距当前时间<=2 ms时，结束循环
while(timeUntilTrigger > 2) {
    synchronized (sigLock) {
        if (halted.get()) {
            break;
        }
        // 判断在此过程中是否有新增的并且触发时间更早的Trigger
        // 但是此处有个权衡，为了一个新增的的Trigger而丢弃当前已获取的是否值得？
        // 丢弃当前获取的Trigger并重新获取需要花费一定的时间，时间的长短与JobStore的实现有关。
        // 所以此处做了主观判断，如果使用的是数据库存储，查询时间假定为70ms，内存存储假定为7ms
        // 如果当前时间距已获得的第一个Trigger触发时间小于查询时间，则认为丢弃是不合算的。
        if (!isCandidateNewTimeEarlierWithinReason(triggerTime, false)) {
            try {
                // we could have blocked a long while
                // on 'synchronize', so we must recompute
                now = System.currentTimeMillis();
                timeUntilTrigger = triggerTime - now;
                // 距触发时间太早，先休息会吧
                if(timeUntilTrigger >= 1)
                    sigLock.wait(timeUntilTrigger);
            } catch (InterruptedException ignore) {
            }
        }
    }
    // 如果有新增的且触发时间更早的Trigger过来搅局，则释放上面已获取的Trigger，等待下一波查询
    if(releaseIfScheduleChangedSignificantly(triggers, triggerTime)) {
        break;
    }
    now = System.currentTimeMillis();
    timeUntilTrigger = triggerTime - now;
}

4 触发Trigger

前面提到过，先前只是获取Trigger的主要信息，其关联的Job、Calendar等信息是在触发前获取的。待Trigger所需信息验证、关联完成后，先行将Trigger的状态改为STATE_ACQUIRED-->STATE_COMPLETE。而后将Trigger封装后的TriggerFiredResult对象交由JobRunShell执行。

List<TriggerFiredResult> res = qsRsrcs.getJobStore().triggersFired(triggers);
for (int i = 0; i < bndles.size(); i++) {
    TriggerFiredResult result =  bndles.get(i);
    TriggerFiredBundle bndle =  result.getTriggerFiredBundle();
    JobRunShell shell = qsRsrcs.getJobRunShellFactory().createJobRunShell(bndle);
    shell.initialize(qs);
    qsRsrcs.getThreadPool().runInThread(shell);
}