quartz 2.2.x 源码学习 基本执行流程分析

quartz 官网中给出了一些基本概念，请先阅读官网相关概念。

http://www.quartz-scheduler.org/documentation/quartz-2.2.x/tutorials/

下面对最简单的一个任务调度工作进行分析，下面的代码每隔三秒中不断重复执行任务SimpleJob。

public class JobStart {
    public static void main(String[] args) throws SchedulerException {
        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler sched = sf.getScheduler();

        sched.clear();

        String instanceId = sched.getSchedulerInstanceId();
        JobDetail detail = JobBuilder.newJob(SimpleJob.class)
                                     .withIdentity("Ins Id " + instanceId, instanceId)
                                     .requestRecovery()
                                     .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                                        .withIdentity("Ins Id " + instanceId,instanceId)
                                        .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever()).build();

        sched.scheduleJob(detail, trigger);

        sched.start();
    }
}

@DisallowConcurrentExecution
public class SimpleJob implements Job{
    private static Logger _log = LoggerFactory.getLogger(SimpleJob.class);
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        if(context.isRecovering()){
            _log.info("is recovering");
        }else{
            _log.info("not recovering");
        }


        try {
            _log.info("do time consumed job start");
            Thread.sleep(5000);
            _log.info("do time consumed job end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

quartz 执行任务可以总结为创建JobDetail描述待执行任务,创建Trigger描述什么时候去触发任务。最后将JobDetail与Trigger注册在调度器中，调度器启动后遍开始对任务调度。

因此了解其基本过程需要明白 创建调度器完成哪些工作？调度工作什么时候开始？任务如何被执行？

示例代码中，首先获取一个调度器。

Scheduler sched = sf.getScheduler(); 

进入该方法内部

org.quartz.impl.StdSchedulerFactory.getScheduler() 
        if (cfg == null) {
            initialize();
        }

        SchedulerRepository schedRep = SchedulerRepository.getInstance();

        Scheduler sched = schedRep.lookup(getSchedulerName());

        if (sched != null) {
            if (sched.isShutdown()) {
                schedRep.remove(getSchedulerName());
            } else {
                return sched;
            }
        }

        sched = instantiate();
        return sched;

获取调度器对象时，首先查找缓存，如果有就直接拿，若不存在则调用instantiate()方法来创建调度器对象。

进入instantiate方法内部，定义了许多变量。

org.quartz.impl.StdSchedulerFactory.instantiate()
   private Scheduler instantiate() throws SchedulerException {
        if (cfg == null) {
            initialize();
        }

        if (initException != null) {
            throw initException;
        }

        JobStore js = null;
        ThreadPool tp = null;
        QuartzScheduler qs = null;
        DBConnectionManager dbMgr = null;
        String instanceIdGeneratorClass = null;
        Properties tProps = null;
        ......

ThreadPool tp为线程池对象，在该方法内部可以看到该线程池的创建 是通过从属性文件quartz.properties中拿到org.quartz.threadPool所定义的线城池类来创建。本文使用的是 org.quartz.simpl.SimpleThreadPool。而最终任务通过线程池来管理。

 public static final String PROP_THREAD_POOL_PREFIX = "org.quartz.threadPool";

        String tpClass = cfg.getStringProperty(PROP_THREAD_POOL_CLASS, SimpleThreadPool.class.getName());

        if (tpClass == null) {
            initException = new SchedulerException(
                    "ThreadPool class not specified. ");
            throw initException;
        }

        try {
            tp = (ThreadPool) loadHelper.loadClass(tpClass).newInstance();
        } catch (Exception e) {
            initException = new SchedulerException("ThreadPool class '"
                    + tpClass + "' could not be instantiated.", e);
            throw initException;
        }

后续代码中会创建QuartzScheduler对象，最终来启动调动线程。

            qs = new QuartzScheduler(rsrcs, idleWaitTime, dbFailureRetry);

在该构造器内部，会创建QuartzSchedulerThread对象，而QuartzSchedulerThread负责对我们定义的Job进行调度。当创建完后
提交给执行器对象schedThreadExecutor.execute(this.schedThread);准备执行。

    public QuartzScheduler(QuartzSchedulerResources resources, long idleWaitTime, @Deprecated long dbRetryInterval)
        throws SchedulerException {
        this.resources = resources;
        if (resources.getJobStore() instanceof JobListener) {
            addInternalJobListener((JobListener)resources.getJobStore());
        }

        this.schedThread = new QuartzSchedulerThread(this, resources);
        ThreadExecutor schedThreadExecutor = resources.getThreadExecutor();
        schedThreadExecutor.execute(this.schedThread);
        if (idleWaitTime > 0) {
            this.schedThread.setIdleWaitTime(idleWaitTime);
        }

当sf.getScheduler();执行完毕后，线程池，执行器，调度器，负责调度Job的线程都已创建完毕。而任务调度线程QuartzSchedulerThread也准备执行。

可以看到sf.getScheduler();调用完毕后，任务调度线程处于暂停状态，并不断检查状态等待恢复并执行任务。

        org.quartz.core.QuartzSchedulerThread.run()

                while (!halted.get()) {
            try {
                // check if we're supposed to pause...
                synchronized (sigLock) {
                    while (paused && !halted.get()) {
                        try {
                            // wait until togglePause(false) is called...
                            sigLock.wait(1000L);
                        } catch (InterruptedException ignore) {
                        }
                    }

                    if (halted.get()) {
                        break;
                    }
                }

在 QuartzSchedulerThread 构造方法中会设置两个变量初始值。

        paused = true;
        halted = new AtomicBoolean(false);

当我们获取到调度器对象，并指定trigger与detail后，调用start方法。

当调用执行器的 org.quartz.core.QuartzScheduler.start()方法在该方法内部会调用方法 schedThread.togglePause(false);将paused变量设置为false,并唤醒QuartzSchedulerThread线程。随QuartzSchedulerThread线程开始执行调度任务。

        org.quartz.core.QuartzScheduler.start()

            void togglePause(boolean pause) {
        synchronized (sigLock) {
            paused = pause;

            if (paused) {
                signalSchedulingChange(0);
            } else {
                sigLock.notifyAll();
            }
        }

至此任务调度工作准备开始，Job等待被调用。

QuartzSchedulerThread的run方法中检测到变量状态被修改，开始调度工作。

    public void run() {
        boolean lastAcquireFailed = false;

        while (!halted.get()) {
            try {
                // check if we're supposed to pause...
                synchronized (sigLock) {
                    while (paused && !halted.get()) {
                        try {
                            // wait until togglePause(false) is called...
                            sigLock.wait(1000L);
                        } catch (InterruptedException ignore) {
                        }
                    }

                    if (halted.get()) {
                        break;
                    }
                }

                int availThreadCount = qsRsrcs.getThreadPool().blockForAvailableThreads();
                if(availThreadCount > 0) { // will always be true, due to semantics of blockForAvailableThreads...

                    List<OperableTrigger> triggers = null;

                    long now = System.currentTimeMillis();

                    clearSignaledSchedulingChange();
... 省略

run方法中的执行过程可粗略归纳为
1.查找将要触发的Trigger
2.检测条件，等待执行
3.执行任务。
4.释放Trigger

在执行时，任务被包装为JobRunShell来运行。

当qsRsrcs.getThreadPool().runInThread(shell)被调用时，我们自己的Job被提交，并等待线程池调度执行。

        JobRunShell shell = null; 

                                    JobRunShell shell = null;
                            try {
                                shell = qsRsrcs.getJobRunShellFactory().createJobRunShell(bndle);
                                shell.initialize(qs);
                            } catch (SchedulerException se) {
                                qsRsrcs.getJobStore().triggeredJobComplete(triggers.get(i), bndle.getJobDetail(), CompletedExecutionInstruction.SET_ALL_JOB_TRIGGERS_ERROR);
                                continue;
                            }

                            if (qsRsrcs.getThreadPool().runInThread(shell) == false) {
                                // this case should never happen, as it is indicative of the
                                // scheduler being shutdown or a bug in the thread pool or
                                // a thread pool being used concurrently - which the docs
                                // say not to do...
                                getLog().error("ThreadPool.runInThread() return false!");
                                qsRsrcs.getJobStore().triggeredJobComplete(triggers.get(i), bndle.getJobDetail(), CompletedExecutionInstruction.SET_ALL_JOB_TRIGGERS_ERROR);
                            }

在 qsRsrcs.getThreadPool().runInThread(shell)方法中会创建一个线程来运行我们定义的Job，而Job的信息则是通过JobDetail来获取。经过上述过程就形成了quartz 进行任务调度的基本过程。

最后总结，启动时的三个主要方法，及工作概述如下。
Scheduler sched = sf.getScheduler();
完成了线程池创建，调度线程创建，调度线程初始处理暂停状态。
sched.scheduleJob(detail, trigger);
指定JobDetail与Trigger。
sched.start();
修改状态未，使调度线程开始运行。任务以JobRunShell的形式被执行。