quartz 运行机制分析

quartz主要由：scheduler,job,jobDetail,trigger,jobBuilder(定义和创建jobDetail实例的接口)，triggerBuilder(定义和创建trigger) 组成。当job的一个trigger被触发后，job的 execute()方法会被scheduler的一个工作线程调用；传递给execute()方法的JobExecutionContext对象中保存着该job运行时的一些信息 - 执行job的scheduler的引用，触发job的trigger的引用，JobDetail对象引用，以及一些其它信息。JobDetail对象是在将job加入scheduler时，由客户端程序（你的程序）创建的。它包含job的各种属性设置，以及用于存储job实例状态信息的JobDataMap。Trigger用于触发Job的执行。一个Job可以对应多个Trigger， 但一个Trigger只能对应一个Job。当你准备调度一个job时，你创建一个Trigger的实例，然后设置调度相关的属性。Trigger也有一个相关联的JobDataMap，用于给Job传递一些触发相关的参数。Quartz自带了各种不同类型的Trigger，最常用的主要是SimpleTrigger和CronTrigger。

quartz运行原理，通过schedule线程管理它下面注册的trigger，不断循环执行筛选出需要执行的trigger，交付给线程池进行执行

quartz 运行机制分析：
1、通过schedulerFactory的getScheduler()方法创建scheduler，

	public Scheduler getScheduler() throws SchedulerException {
        if (cfg == null) {
            initialize();
        }


		//SchedulerRepository为一个hashmap用于保存所有的Scheduler
        SchedulerRepository schedRep = SchedulerRepository.getInstance();


        //查看SchedulerRepository是否有该scheduler
        Scheduler sched = schedRep.lookup(getSchedulerName());


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


        //实例化一个Scheduler,过程主要包括
        //1、读取配置属性
        //2、创建线程池
        //3、如果集群，配置DataSource相关信息
        //4、启动 SchedulerPlugins
        //5、启动JobListeners，TriggerListeners
        //6、将以上所有的启动创建的实例都保存到 QuartzSchedulerResources 中，一个schedule对应一个QuartzSchedulerResources
        //7、创建 QuartzScheduler 实例
        //8、通过 QuartzSchedulerResources 和 QuartzScheduler 创建 Scheduler，Scheduler作为一个thread会开始被线程池启动执行
        sched = instantiate();


        return sched;
    }

    2、scheduler.scheduleJob(jobDetail,trigger);将设置好的jobDetail 和 trigger 添加到schedule中，一个job可以对应多个trigger，但是一个trigger只能对应一个job
    

	public Date scheduleJob(JobDetail jobDetail,
            Trigger trigger) throws SchedulerException {
        validateState();


        ...


        if (trigger.getJobKey() == null) {
            trig.setJobKey(jobDetail.getKey());
        } else if (!trigger.getJobKey().equals(jobDetail.getKey())) {
            throw new SchedulerException(
                "Trigger does not reference given job!");
        }


        trig.validate();


        Calendar cal = null;
        if (trigger.getCalendarName() != null) {
            cal = resources.getJobStore().retrieveCalendar(trigger.getCalendarName());
        }
        Date ft = trig.computeFirstFireTime(cal);


        if (ft == null) {
            throw new SchedulerException(
                    "Based on configured schedule, the given trigger '" + trigger.getKey() + "' will never fire.");
        }


        //最重要的步骤，将jobDetail, trig 添加导QuartzSchedulerResources的jobStore中
        //jobstore 中有个 timeTriggers 用于存储即将要执行的trigger
        resources.getJobStore().storeJobAndTrigger(jobDetail, trig);
        notifySchedulerListenersJobAdded(jobDetail);
        notifySchedulerThread(trigger.getNextFireTime().getTime());
        notifySchedulerListenersSchduled(trigger);


        return ft;
    }

     3、scheduler.start(); 主要是将scheduler 中变量paused 设为 FALSE，并唤起阻塞的scheduler线程

    4、重点分析一下schedule.run()方法，方法比较长选取重要部分

	public void run() {
        boolean lastAcquireFailed = false;


        while (!halted.get()) {
            try {
                // check if we're supposed to pause...
                synchronized (sigLock) {


                	//支持对schedule进行暂停，退出操作
                    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();
                    try {


                    	//从timeTriggers根据NextFireTime获取当前时刻需要执行的trigger，其中包括有misfire机制添加进来的trigger。
                        triggers = qsRsrcs.getJobStore().acquireNextTriggers(
                                now + idleWaitTime, Math.min(availThreadCount, qsRsrcs.getMaxBatchSize()), qsRsrcs.getBatchTimeWindow());
                        lastAcquireFailed = false;
                        
                        ...


                    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;
                                }
                                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) {
                                    }
                                }
                            }
                            if(releaseIfScheduleChangedSignificantly(triggers, triggerTime)) {
                                break;
                            }
                            now = System.currentTimeMillis();
                            timeUntilTrigger = triggerTime - now;
                        }


                        // this happens if releaseIfScheduleChangedSignificantly decided to release triggers
                        if(triggers.isEmpty())
                            continue;


                        // set triggers to 'executing'
                        List<TriggerFiredResult> bndles = new ArrayList<TriggerFiredResult>();


                        boolean goAhead = true;
                        synchronized(sigLock) {
                            goAhead = !halted.get();
                        }
                        if(goAhead) {
                            try {
                            	//更新trigger中的NextFireTime值，如果NextFireTime不为空则添加进timeTriggers中，作为下次筛选执行的依据
                                List<TriggerFiredResult> res = qsRsrcs.getJobStore().triggersFired(triggers);
                                if(res != null)
                                    bndles = res;
                            } 
                            ...


                            //依次执行要trigger中的的job
                        for (int i = 0; i < bndles.size(); i++) {
                            TriggerFiredResult result =  bndles.get(i);
                            TriggerFiredBundle bndle =  result.getTriggerFiredBundle();
                            Exception exception = result.getException();


                            if (exception instanceof RuntimeException) {
                                getLog().error("RuntimeException while firing trigger " + triggers.get(i), exception);
                                qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));
                                continue;
                            }


                            // it's possible to get 'null' if the triggers was paused,
                            // blocked, or other similar occurrences that prevent it being
                            // fired at this time...  or if the scheduler was shutdown (halted)
                            if (bndle == null) {
                                qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));
                                continue;
                            }


                            JobRunShell shell = null;
                            try {
                            	//构造要执行的jobRunShell线程
                                shell = qsRsrcs.getJobRunShellFactory().createJobRunShell(bndle);
                                shell.initialize(qs);
                            } 
                            ...


                            //将要执行的job放入线程池中去执行
                            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);
                            }


                        }


                        continue; // while (!halted)
                    }
                } else { // if(availThreadCount > 0)
                    // should never happen, if threadPool.blockForAvailableThreads() follows contract
                    continue; // while (!halted)
                }


                ....
    }

quartz 的集群实现原理： 

通过使用事务，对Lock_table 表中的数据使用 select... for update 的方式进行加锁。获得锁后，保存到threadLocal 变量中，执行job中的execute 方法。执行完成提交事务，释放锁 （remove threadLocal 中的锁变量）

quartz misfire(错过job的处理策略):
MISFIRE_INSTRUCTION_SMART_POLICY
智能根据trigger属性选择策略：
repeatCount为0，则策略同MISFIRE_INSTRUCTION_FIRE_NOW
repeatCount为REPEAT_INDEFINITELY，则策略同MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
否则策略同MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
MISFIRE_INSTRUCTION_FIRE_NOW
以当前时间为触发频率立即触发执行
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
以当前时间为触发频率立即触发执行
以总次数-已执行次数作为剩余周期次数，重新计算FinalTime
调整后的FinalTime会略大于根据starttime计算的到的FinalTime值
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT
以当前时间为触发频率立即触发执行
保持FinalTime不变，重新计算剩余周期次数(相当于错过的当做已执行)
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT
不触发立即执行
等待下次触发频率周期时刻执行
以总次数-已执行次数作为剩余周期次数，重新计算FinalTime
调整后的FinalTime会略大于根据starttime计算的到的FinalTime值
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
不触发立即执行
等待下次触发频率周期时刻，执行至FinalTime的剩余周期次数
保持FinalTime不变，重新计算剩余周期次数(相当于错过的当做已执行)
总结一下：
1、带有_NOW字样的策略，就是立即执行；反之，带有_NEXT的策略，则会等到下一个触发周期才会执行。
2、带有WITH_EXISTING_REPEAT_COUNT字样的，则是确保周期总数不变，用周期总数-已执行数作为剩余周期数，因此FinalTime会适当延后；
例如，repeatCount为3次（总计4次），已执行1次，错过2次，则后续仍会执行4-1=3次。
3、带有WITH_REMAINING_COUNT则是按原定计划执行，FinalTime不变，已错过的忽略。
例如，repeatCount为3次（总计4次），已执行1次，错过2次，则后续会执行4-1-2=1次。