quartz 官網中給出了一些基本概念，請先閱讀官網相關概念。

下面對最簡單的一個任務排程工作進行分析，下面的程式碼每隔三秒中不斷重複執行任務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的形式被執行。