Quart 学习

quartz版本使用2.2.1

梳理一下其中的流程,可以表示为:

0.调度器线程run()

1.获取待触发trigger

1.1数据库LOCKS表TRIGGER_ACCESS行加锁

1.2读取JobDetail信息

1.3读取trigger表中触发器信息并标记为"已获取"

1.4commit事务,释放锁

2.触发trigger

2.1数据库LOCKS表STATE_ACCESS行加锁

2.2确认trigger的状态

2.3读取trigger的JobDetail信息

2.4读取trigger的Calendar信息

2.3更新trigger信息

2.3commit事务,释放锁

3实例化并执行Job

3.1从线程池获取线程执行JobRunShell的run方法

可以看到,这个过程中有两个相似的过程:同样是对数据表的更新操作,同样是在执行操作前获取锁操作完成后释放锁.这一规则可以看做是quartz解决集群问题的核心思想.

规则流程图:

1.关键接口

Scheduler，任务调度的API；它可以用来启动或者终止任务等。
Job，具体的任务接口；通过实现它，来让任务调度执行具体的任务。
JobDetail ，用来定义Job的实例。
Trigger ，触发器用来定义给定的Job应该如何执行。
JobBuilder ，用来定义/构建Jobdetail实例。
TriggerBuilder ，用来定义/构建Trigger实例。

2.简单例子

下面是一个简单的例子，创建一个简单的任务调度。
创建一个Job，名为HelloQuartzJob：

public class HelloQuartzJob implements Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        System.out.println("Hello, Quartz! "+

                formatter.format(new Date()) + " by " + context.getTrigger());

    }

}

实现Job接口中的execute方法，这个方法中是我们需要任务调度执行的具体内容。

然后我们就可以编写一个测试类，来执行Job。

public class HelloQuartzScheduling {

    public static void main(String[] args) throws SchedulerException {

        //创建JobDetail

        JobDetail jobDetail = JobBuilder.newJob(HelloQuartzJob.class)

                .withIdentity("hello","group1")

                .build();

        //创建Trigger

        Trigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("myTrigger","group1")

                .startNow()

                .withSchedule(

                        SimpleScheduleBuilder.simpleSchedule()

                                //每5s运行一次

                                .withIntervalInSeconds(5)

                                //重复运行3次

                                .withRepeatCount(3)

                ).build();

　　　　//创建Trigger   关联多个trigger

　　　　//Trigger trigger2 = TriggerBuilder.newTrigger()

       //　　　　　.withIdentity("myTrigger3", "test")

      //　　　　   .withSchedule(

      //          　　　　SimpleScheduleBuilder.simpleSchedule()

      //                  　　　　.withIntervalInSeconds(10)

      //                  　　　　.withRepeatCount(10)

      //  )

      //  .forJob(jobDetail)

      //  .build();


        //获取Scheduler，并启动任务

        SchedulerFactory schedulerFactory = new StdSchedulerFactory();

        Scheduler scheduler = schedulerFactory.getScheduler();

        //添加job，以及其关联的trigger

        scheduler.scheduleJob(jobDetail, trigger);

        //启动job

        scheduler.start();

    }

}

　　运行结果，如下：

//创建Trigger

Trigger trigger4 = TriggerBuilder.newTrigger()

        .withIdentity("myTrigger3", "test")

        .withSchedule(

                SimpleScheduleBuilder.simpleSchedule()

                        .withIntervalInSeconds(10)

                        .withRepeatCount(10)

        )

        .forJob(jobDetail2)

        .build();

Jobs与JobDetails

正如第一篇文章看到的那样，实现一个Job是非常简单的，只需要完成execute()方法就行了。
那么Jobs与JobDetails有什么关系呢？简而言之，Job是对任务的一个具体实现；谁执行了这个任务呢？这就需要JobDetail来实现，所以JobDetail就是Job的一个具体实例；如9点上语文课是一个具体任务，而刘老师在9点上语文课就是这个任务的一个具体实例。
Scheduler执行Job时，在调用execute()方法前会先实例化Job；一旦执行结束，该实例就会被丢弃，然后被垃圾回收。
需要注意的是Job必须有一个无参的构造器；另外在Job类中定义数据属性是没有意义的，因为这些属性值并不会在执行期间保存。

当 Trigger 被触发，关联的 JobDetail 将会被加载，并且 Job 类会通过 JobFactory 配置到 Scheduler。默认的 JobFactory 将会简单地调用 Job Class 的 newInstance() 方法，并尝试调用 set 方法将 JobDataMap 中同名的属性设置到 Job 中。

JobDataMap

上面说到Job中无法定义属性来传递数据，那么如果我们需要传递数据该怎么做？就是使用JobDataMap，它是JobDetail的一个属性。JobDataMap是Map接口的一个实现，并且它有一些便利的方法来储存和检索基本类型数据。
修改之前的测试类如下：

//创建JobDetail
JobDetail jobDetail = JobBuilder.newJob(HelloQuartzJob.class)
        .withIdentity("hello","group1")
        .usingJobData("name", "sky")
        .build();

　　添加一个值为sky的name属性。然后在HelloQuartzJob中，我们就可以获取到该属性：

public class HelloQuartzJob implements Job {

    public HelloQuartzJob() {

        System.out.println("Hello, Quartz! ----------------------");

    }

    public void execute(JobExecutionContext context) throws JobExecutionException {

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //使用JobDataMap

        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();

        String name = jobDataMap.getString("name");

        System.out.println("Hello, " + name + " " +

                formatter.format(new Date()) + " by " + context.getTrigger());

    }

}

　　然后运行测试类：

如果在Job类中定义与JobDataMap中键值一致的set和get方法，那么Quartz会自动将这些属性注入。如：

public class HelloQuartzJob implements Job {

    String name;

    public HelloQuartzJob() {

        System.out.println("Hello, Quartz! ----------------------");

    }

    public void execute(JobExecutionContext context) throws JobExecutionException {

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //使用JobDataMap

//        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();

//        String name = jobDataMap.getString("name");

        System.out.println("Hello, " + name + " " +

                formatter.format(new Date()) + " by " + context.getTrigger());

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

另外Trigger中也可以设置JobDataMap属性，这是为了在多个Trigger中使用相同的Job。JobExecutionContext 将会合并JobDetail与Trigger的JobDataMap，如果其中属性名相同，后者将覆盖前者。可以使用context.getMergedJobDataMap()方法来获取合并后的JobDataMap。

Job的状态与并发

@DisallowConcurrentExecution，如果使用该注解，那么同一时间将只有一个Job实例被执行。如，ReportJob有个实例为ReportForJoe，那么同一时间只有一个ReportForJoe被执行。而ReportForMike等都可以执行。
@PersistJobDataAfterExecution，如果使用该注解，在Job被执行结束后，将会更新JobDataMap，这样下次Job执行后就会使用新的值而不是初始值。
如果使用@PersistJobDataAfterExecution注解，推荐也使用@DisallowConcurrentExecution注解，这是为了避免并发问题导致数据紊乱。

其它属性

Durability，持久性；如果Job是非持久性的，一旦没有Trigger与其相关联，它就会从Scheduler中被删除。也就是说Job的生命周期和其Trigger是关联的。
　　　　jobDetail.storeDurably(); schedule.addJob(JobDetail jobdetail, boolean replace [, boolean storeNonDurableWhileAwaitingScheduling] );
RequestsRecovery，如果为true，那么在Scheduler异常中止或者系统异常关闭后，当Scheduler重启后，Job会被重新执行。

JobExecutionException

execute()方法只允许抛出JobExecutionException异常

Job与JobDetail是Quartz用来定义具体任务的，而Trigger则是用来定义任务如何执行的。Quartz提供了Trigger接口来定义公共属性，使用TriggerBuilder可以创建具体类型的Trigger；最常见的两种Trigger分别是SimpleTrigger、CronTrigger。

Trigger的公共属性：

key，该属性是为了标识Trigger的。
startTime，Trigger第一次被Scheduler触发的时间；该属性的值是指定某个时间点的java.util.Date对象。
endTime，Trigger不再被执行的时间。
priority，优先级；通过设置优先级属性可以控制Trigger被执行的顺序，该属性默认值是5，可以为正整数也可以为负整数。需要注意的是，只有在触发时间相同时，优先级属性才会有效；比如10:59执行的任务总是会在11:00执行的任务之前执行；另外，如果Trigger是可恢复的，那么恢复后，优先级是不会改变的。
misfire，如果因为某些原因，错过触发时间，就需要使用该属性来调整。不同类型的Trigger拥有不同的misfire，但是默认的是smart policy，这种情况下会根据Trigger的类型与配置来动态的调整行为。
Calendars，该属性并不是java.util.Calendar类型，它的作用是排除某些时间，比如在周末不执行任务。Quratz的Calendar对象是一个实现了Calendar接口的序列化对象，Calendars接口如下：

package org.quartz;

public interface Calendar {

  public boolean isTimeIncluded(long timeStamp);

  public long getNextIncludedTime(long timeStamp);

}

　　这两个方法都是精确到毫秒的；如果只是排除以天为单位的时间，可以使用HolidayCalendar。
Calendars必须实例化，然后通过Scheduler的addCalendar()方法注册。Calendars可以重复使用，如下代码：

Trigger trigger1 = TriggerBuilder.newTrigger()

                .withIdentity("trigger1", "test")

                .startAt(DateBuilder.futureDate(3, IntervalUnit.SECOND))

                .withSchedule(SimpleScheduleBuilder.simpleSchedule()

                        .withIntervalInMilliseconds(5000)

                        .withIntervalInSeconds(5)

                        .withRepeatCount(5))

                .modifiedByCalendar("holidayCalendar")

                .build();

        Trigger trigger2 = TriggerBuilder.newTrigger()

                .withIdentity("trigger2", "test")

                .startAt(DateBuilder.futureDate(3, IntervalUnit.SECOND))

                .withSchedule(SimpleScheduleBuilder.simpleSchedule()

                        .withIntervalInMilliseconds(5000)

                        .withIntervalInSeconds(5)

                        .withRepeatCount(5))

                .modifiedByCalendar("holidayCalendar")

                .build();

SimpleTrigger

下面来看SimpleTrigger。通过之前的例子可以看到如何创建Trigger，首先通过TriggerBuilder.newTrigger()方法建立一个TriggerBuilder对象，然后通过withSchedule()方法指定了SimpleScheduleBuilder，最后build()方法构建出了SimpleTrigger对象。
SimpleTrigger很简单，之前例子中创建的都是SimpleTrigger，任务启动后每隔5s运行一次，总共运行5次。Quartz提供了DateBuilder工具类来方便设置时间，里面提供了很多方法，如上面Trigger2设置的启动时间就是3秒后启动任务。

CronTrigger

CronTrigger使用cron表达式来设置触发时间。CronTrigger创建方式：

Trigger trigger3 = TriggerBuilder.newTrigger()

                .withIdentity("cron trigger", "test")

                .withSchedule(

                    //每5秒执行一次

                    CronScheduleBuilder.cronSchedule("0/5 * * ? * *")

                ).build();

cron表达式

cron表达式的格式为：秒分时日月周年；其中年是可选的，其它为必填。

附：cronExpression配置说明

字段允许值允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选）留空, 1970-2099 , - * /

表达式意义
"0 0 12 * * ?" 每天中午12点触发
"0 15 10 ? * *" 每天上午10:15触发
"0 15 10 * * ?" 每天上午10:15触发
"0 15 10 * * ? *" 每天上午10:15触发
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
"0 15 10 15 * ?" 每月15日上午10:15触发
"0 15 10 L * ?" 每月最后一日的上午10:15触发
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发

特殊字符意义
* 表示所有值；
? 表示未说明的值，即不关心它为何值；
- 表示一个指定的范围；
, 表示附加一个可能值；
/ 符号前表示开始时间，符号后表示每次递增的值；
L("last") ("last") "L" 用在day-of-month字段意思是 "这个月最后一天"；用在 day-of-week字段, 它简单意思是 "7" or "SAT"。如果在day-of-week字段里和数字联合使用，它的意思就是 "这个月的最后一个星期几" – 例如： "6L" means "这个月的最后一个星期五". 当我们用“L”时，不指明一个列表值或者范围是很重要的，不然的话，我们会得到一些意想不到的结果。
W("weekday") 只能用在day-of-month字段。用来描叙最接近指定天的工作日（周一到周五）。例如：在day-of-month字段用“15W”指“最接近这个月第15天的工作日”，即如果这个月第15天是周六，那么触发器将会在这个月第14天即周五触发；如果这个月第15天是周日，那么触发器将会在这个月第16天即周一触发；如果这个月第15天是周二，那么就在触发器这天触发。注意一点：这个用法只会在当前月计算值，不会越过当前月。“W”字符仅能在day-of-month指明一天，不能是一个范围或列表。也可以用“LW”来指定这个月的最后一个工作日。
# 只能用在day-of-week字段。用来指定这个月的第几个周几。例：在day-of-week字段用"6#3"指这个月第3个周五（6指周五，3指第3个）。如果指定的日期不存在，触发器就不会触发。
C 指和calendar联系后计算过的值。例：在day-of-month 字段用“5C”指在这个月第5天或之后包括calendar的第一天；在day-of-week字段用“1C”指在这周日或之后包括calendar的第一天

下图为每个属性允许使用的符号：

通过研读Quartz的源代码，和本实例，终于悟出了Quartz的工作原理。

1、scheduler是一个计划调度器容器（总部），容器里面可以盛放众多的JobDetail和trigger，当容器启动后，里面的每个JobDetail都会根据trigger按部就班自动去执行。

2、JobDetail是一个可执行的工作，它本身可能是有状态的。

3、Trigger代表一个调度参数的配置，什么时候去调。

4、当JobDetail和Trigger在scheduler容器上注册后，形成了装配好的作业（JobDetail和Trigger所组成的一对儿），就可以伴随容器启动而调度执行了。

5、scheduler是个容器，容器中有一个线程池，用来并行调度执行每个作业，这样可以提高容器效率。

6、将上述的结构用一个图来表示，如下：

Scheduler 调度线程主要有两个：执行常规调度的线程，和执行 misfired trigger 的线程。常规调度线程轮询存储的所有 trigger，如果有需要触发的 trigger，即到达了下一次触发的时间，则从任务执行线程池获取一个空闲线程，执行与该 trigger 关联的任务。Misfire 线程是扫描所有的 trigger，查看是否有 misfired trigger，如果有的话根据 misfire 的策略分别处理。下图描述了这两个线程的基本流程：

工作原理

Quartz是通过对用户暴露出Scheduler来进行任务的操作，它可以把任务JobDetail和触发器Trigger加入任务池中，可以把任务删除，也可以把任务停止，scheduler把这些任务和触发器放到一个JobStore中，这里jobStore有内存形式的也有持久化形式的，当然也可以自定义扩展成独立的服务。

它内部会通过一个调度线程QuartzSchedulerThread不断到JobStore中找出下次需要执行的任务，并把这些任务封装放到一个线程池ThreadPool中运行，它的组件结构如下图：

1.Job就是自定义业务的接口，里面就一个execute方法，线程运行Job时会把JobDataMap封装到JobExecutionContext里作为execute方法的参数，jobdetail是对job的封装，里面有Job的class，对应的数据，名称，分组等
2.Trigger是触发器，job下次什么时候执行存放在trigger中
3.QuartzSchedulerResources相当于调度的资源存放器，包含了JobStore, ThreadPool等资源，调度都是通过QuartzSchedulerResources获取相关属性的。
4.jobStore是任务和触发器存储地方，它里面提供大量类似于增删改的操作任务方法。
5.QuartzSchedulerThread是一个调度线程，ThreadPool是一个执行线程池

QuartzSchedulerThread线程

先获取线程池中的可用线程数量（若没有可用的会阻塞，直到有可用的）；
获取30m内要执行的trigger(即acquireNextTriggers)：
获取trigger的锁，通过select …for update方式实现；获取30m内（可配置）要执行的triggers（需要保证集群节点的时间一致），若@ConcurrentExectionDisallowed且列表存在该条trigger则跳过，否则更新trigger状态为ACQUIRED(刚开始为WAITING)；插入firedTrigger表，状态为ACQUIRED;（注意：在RAMJobStore中，有个timeTriggers，排序方式是按触发时间nextFireTime排的；JobStoreSupport从数据库取出triggers时是按照nextFireTime排序）;
等待直到获取的trigger中最先执行的trigger在2ms内；
triggersFired：
1）更新firedTrigger的status=EXECUTING;
2）更新trigger下一次触发的时间；
3）更新trigger的状态：无状态的trigger->WAITING，有状态的trigger->BLOCKED，若nextFireTime==null ->COMPLETE；
4） commit connection,释放锁；
针对每个要执行的trigger，创建JobRunShell，并放入线程池执行：
1）execute:执行job
2）获取TRIGGER_ACCESS锁
3）若是有状态的job：更新trigger状态：BLOCKED->WAITING,PAUSED_BLOCKED->BLOCKED
4）若@PersistJobDataAfterExecution，则updateJobData
5）删除firedTrigger
6）commit connection，释放锁

代码跟踪

转自集群调度机制调研及源码分析

StdSchedulerFactory的getScheduler()方法:

public Scheduler getScheduler() throws SchedulerException {

        if (cfg == null) {

            initialize();

        }

        SchedulerRepository schedRep = SchedulerRepository.getInstance();

        //从"调度器仓库"中根据properties的SchedulerName配置获取一个调度器实例

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

        if (sched != null) {

            if (sched.isShutdown()) {

                schedRep.remove(getSchedulerName());

            } else {

                return sched;

            }

        }

        //初始化调度器

        sched = instantiate();

        return sched;

    }

跟进初始化调度器方法sched = instantiate();发现是一个700多行的初始化方法,涉及到

读取配置资源,
生成QuartzScheduler对象,
创建该对象的运行线程,并启动线程;
初始化JobStore,QuartzScheduler,DBConnectionManager等重要组件,
至此,调度器的初始化工作已完成,初始化工作中quratz读取了数据库中存放的对应当前调度器的锁信息,对应CRM中的表QRTZ2_LOCKS,中的STATE_ACCESS,TRIGGER_ACCESS两个LOCK_NAME.

public void initialize(ClassLoadHelper loadHelper,

            SchedulerSignaler signaler) throws SchedulerConfigException {

        if (dsName == null) {

            throw new SchedulerConfigException("DataSource name not set.");

        }

        classLoadHelper = loadHelper;

        if(isThreadsInheritInitializersClassLoadContext()) {

            log.info("JDBCJobStore threads will inherit ContextClassLoader of thread: " + Thread.currentThread().getName());

            initializersLoader = Thread.currentThread().getContextClassLoader();

        }

        this.schedSignaler = signaler;

        // If the user hasn't specified an explicit lock handler, then

        // choose one based on CMT/Clustered/UseDBLocks.

        if (getLockHandler() == null) {

            // If the user hasn't specified an explicit lock handler,

            // then we *must* use DB locks with clustering

            if (isClustered()) {

                setUseDBLocks(true);

            }

            if (getUseDBLocks()) {

                if(getDriverDelegateClass() != null && getDriverDelegateClass().equals(MSSQLDelegate.class.getName())) {

                    if(getSelectWithLockSQL() == null) {

                        //读取数据库LOCKS表中对应当前调度器的锁信息

                        String msSqlDflt = "SELECT * FROM {0}LOCKS WITH (UPDLOCK,ROWLOCK) WHERE " + COL_SCHEDULER_NAME + " = {1} AND LOCK_NAME = ?";

                        getLog().info("Detected usage of MSSQLDelegate class - defaulting 'selectWithLockSQL' to '" + msSqlDflt + "'.");

                        setSelectWithLockSQL(msSqlDflt);

                    }

                }

                getLog().info("Using db table-based data access locking (synchronization).");

                setLockHandler(new StdRowLockSemaphore(getTablePrefix(), getInstanceName(), getSelectWithLockSQL()));

            } else {

                getLog().info(

                    "Using thread monitor-based data access locking (synchronization).");

                setLockHandler(new SimpleSemaphore());

            }

        }

    }

当调用sch.start();方法时,scheduler做了如下工作:

1.通知listener开始启动

2.启动调度器线程

3.启动plugin

4.通知listener启动完成

public void start() throws SchedulerException {

        if (shuttingDown|| closed) {

            throw new SchedulerException(

                    "The Scheduler cannot be restarted after shutdown() has been called.");

        }

        // QTZ-212 : calling new schedulerStarting() method on the listeners

        // right after entering start()

        //通知该调度器的listener启动开始

        notifySchedulerListenersStarting();

        if (initialStart == null) {

            initialStart = new Date();

            //启动调度器的线程

            this.resources.getJobStore().schedulerStarted();

            //启动plugins

            startPlugins();

        } else {

            resources.getJobStore().schedulerResumed();

        }

        schedThread.togglePause(false);

        getLog().info(

                "Scheduler " + resources.getUniqueIdentifier() + " started.");

        //通知该调度器的listener启动完成

        notifySchedulerListenersStarted();

    }

调度过程

调度器启动后,调度器的线程就处于运行状态了,开始执行quartz的主要工作–调度任务.

前面已介绍过,任务的调度过程大致分为三步:

1.获取待触发trigger

2.触发trigger

3.实例化并执行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();

                    try {

                        //调度器在trigger队列中寻找30秒内一定数目的trigger准备执行调度,

                        //参数1:nolaterthan = now+3000ms,参数2 最大获取数量,大小取线程池线程剩余量与定义值得较小者

                        //参数3 时间窗口 默认为0,程序会在nolaterthan后加上窗口大小来选择trigger

                        triggers = qsRsrcs.getJobStore().acquireNextTriggers(

                                now + idleWaitTime, Math.min(availThreadCount, qsRsrcs.getMaxBatchSize()), qsRsrcs.getBatchTimeWindow());

                        //上一步获取成功将失败标志置为false;

                        lastAcquireFailed = false;

                        if (log.isDebugEnabled())

                            log.debug("batch acquisition of " + (triggers == null ? 0 : triggers.size()) + " triggers");

                    } catch (JobPersistenceException jpe) {

                        if(!lastAcquireFailed) {

                            qs.notifySchedulerListenersError(

                                "An error occurred while scanning for the next triggers to fire.",

                                jpe);

                        }

                        //捕捉到异常则值标志为true,再次尝试获取

                        lastAcquireFailed = true;

                        continue;

                    } catch (RuntimeException e) {

                        if(!lastAcquireFailed) {

                            getLog().error("quartzSchedulerThreadLoop: RuntimeException "

                                    +e.getMessage(), e);

                        }

                        lastAcquireFailed = true;

                        continue;

                    }

                    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;

                                }

                                //如果这时调度器发生了改变,新的trigger添加进来,那么有可能新添加的trigger比当前待执行的trigger

                                //更急迫,那么需要放弃当前trigger重新获取,然而,这里存在一个值不值得的问题,如果重新获取新trigger

                                //的时间要长于当前时间到新trigger出发的时间,那么即使放弃当前的trigger,仍然会导致xntrigger获取失败,

                                //但我们又不知道获取新的trigger需要多长时间,于是,我们做了一个主观的评判,若jobstore为RAM,那么

                                //假定获取时间需要7ms,若jobstore是持久化的,假定其需要70ms,当前时间与新trigger的触发时间之差小于

                                // 这个值的我们认为不值得重新获取,返回false

                                //这里判断是否有上述情况发生,值不值得放弃本次trigger,若判定不放弃,则线程直接等待至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) {

                                    }

                                }

                            }

                            //该方法调用了上面的判定方法,作为再次判定的逻辑

                            //到达这里有两种情况1.决定放弃当前trigger,那么再判定一次,如果仍然有放弃,那么清空triggers列表并

                            // 退出循环 2.不放弃当前trigger,且线程已经wait到trigger触发的时刻,那么什么也不做

                            if(releaseIfScheduleChangedSignificantly(triggers, triggerTime)) {

                                break;

                            }

                            now = System.currentTimeMillis();

                            timeUntilTrigger = triggerTime - now;

                            //这时触发器已经即将触发,值会<2

                        }

                        // 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 {

                                //触发triggers,结果付给bndles,注意,从这里返回后,trigger在数据库中已经经过了锁定,解除锁定,这一套过程

                                //所以说,quratz定不是等到job执行完才释放trigger资源的占有,而是读取完本次触发所需的信息后立即释放资源

                                //然后再执行jobs

                                List<TriggerFiredResult> res = qsRsrcs.getJobStore().triggersFired(triggers);

                                if(res != null)

                                    bndles = res;

                            } catch (SchedulerException se) {

                                qs.notifySchedulerListenersError(

                                        "An error occurred while firing triggers '"

                                                + triggers + "'", se);

                                //QTZ-179 : a problem occurred interacting with the triggers from the db

                                //we release them and loop again

                                for (int i = 0; i < triggers.size(); i++) {

                                    qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));

                                }

                                continue;

                            }

                        }

                        //迭代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)

                            //在特殊情况下,bndle可能为null,看triggerFired方法可以看到,当从数据库获取trigger时,如果status不是

                            //STATE_ACQUIRED,那么会直接返回空.quratz这种情况下本调度器启动重试流程,重新获取4次,若仍有问题,

                            // 则抛出异常.

                            if (bndle == null) {

                                qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));

                                continue;

                            }

                            //执行job

                            JobRunShell shell = null;

                            try {

                                //创建一个job的Runshell

                                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;

                            }

                            //把runShell放在线程池里跑

                            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)

                }

                //保证负载平衡的方法,每次执行一轮触发后,本scheduler会等待一个随机的时间,这样就使得其他节点上的scheduler可以得到资源.

                long now = System.currentTimeMillis();

                long waitTime = now + getRandomizedIdleWaitTime();

                long timeUntilContinue = waitTime - now;

                synchronized(sigLock) {

                    try {

                      if(!halted.get()) {

                        // QTZ-336 A job might have been completed in the mean time and we might have

                        // missed the scheduled changed signal by not waiting for the notify() yet

                        // Check that before waiting for too long in case this very job needs to be

                        // scheduled very soon

                        if (!isScheduleChanged()) {

                          sigLock.wait(timeUntilContinue);

                        }

                      }

                    } catch (InterruptedException ignore) {

                    }

                }

            } catch(RuntimeException re) {

                getLog().error("Runtime error occurred in main trigger firing loop.", re);

            }

        } // while (!halted)

        // drop references to scheduler stuff to aid garbage collection...

        qs = null;

        qsRsrcs = null;

    }

调度器每次获取到的trigger是30s内需要执行的,所以要等待一段时间至trigger执行前2ms.在等待过程中涉及到一个新加进来更紧急的trigger的处理逻辑.分析写在注释中,不再赘述.

可以看到调度器的只要在运行状态,就会不停地执行调度流程.值得注意的是,在流程的最后线程会等待一个随机的时间.这就是quartz自带的负载平衡机制.

以下是三个步骤的跟进:

触发器的获取

调度器调用:

triggers = qsRsrcs.getJobStore().acquireNextTriggers(now + idleWaitTime, Math.min(availThreadCount, qsRsrcs.getMaxBatchSize()), qsRsrcs.getBatchTimeWindow());

　　在数据库中查找一定时间范围内将会被触发的trigger.参数的意义如下:参数1:nolaterthan = now+3000ms,即未来30s内将会被触发.参数2 最大获取数量,大小取线程池线程剩余量与定义值得较小者.参数3 时间窗口默认为0,程序会在nolaterthan后加上窗口大小来选择trigger.quratz会在每次触发trigger后计算出trigger下次要执行的时间,并在数据库QRTZ2_TRIGGERS中的NEXT_FIRE_TIME字段中记录.查找时将当前毫秒数与该字段比较,就能找出下一段时间内将会触发的触发器.查找时,调用在JobStoreSupport类中的方法:

public List<OperableTrigger> acquireNextTriggers(final long noLaterThan, final int maxCount, final long timeWindow)

        throws JobPersistenceException {

        String lockName;

        if(isAcquireTriggersWithinLock() || maxCount > 1) {

            lockName = LOCK_TRIGGER_ACCESS;

        } else {

            lockName = null;

        }

        return executeInNonManagedTXLock(lockName,

                new TransactionCallback<List<OperableTrigger>>() {

                    public List<OperableTrigger> execute(Connection conn) throws JobPersistenceException {

                        return acquireNextTrigger(conn, noLaterThan, maxCount, timeWindow);

                    }

                },

                new TransactionValidator<List<OperableTrigger>>() {

                    public Boolean validate(Connection conn, List<OperableTrigger> result) throws JobPersistenceException {

                        //...异常处理回调方法

                    }

                });

    }

　　该方法关键的一点在于执行了executeInNonManagedTXLock()方法,这一方法指定了一个锁名,两个回调函数.在开始执行时获得锁,在方法执行完毕后随着事务的提交锁被释放.在该方法的底层,使用 for update语句,在数据库中加入行级锁,保证了在该方法执行过程中,其他的调度器对trigger进行获取时将会等待该调度器释放该锁.此方法是前面介绍的quartz集群策略的的具体实现,这一模板方法在后面的trigger触发过程还会被使用.

public static final String SELECT_FOR_LOCK = "SELECT * FROM "

            + TABLE_PREFIX_SUBST + TABLE_LOCKS + " WHERE " + COL_SCHEDULER_NAME + " = " + SCHED_NAME_SUBST

            + " AND " + COL_LOCK_NAME + " = ? FOR UPDATE";

进一步解释:quratz在获取数据库资源之前,先要以for update方式访问LOCKS表中相应LOCK_NAME数据将改行锁定.如果在此前该行已经被锁定,那么等待,如果没有被锁定,那么读取满足要求的trigger,并把它们的status置为STATE_ACQUIRED,如果有tirgger已被置为STATE_ACQUIRED,那么说明该trigger已被别的调度器实例认领,无需再次认领,调度器会忽略此trigger.调度器实例之间的间接通信就体现在这里.

JobStoreSupport.acquireNextTrigger()方法中:

int rowsUpdated = getDelegate().updateTriggerStateFromOtherState(conn, triggerKey, STATE_ACQUIRED, STATE_WAITING);

最后释放锁,这时如果下一个调度器在排队获取trigger的话,则仍会执行相同的步骤.这种机制保证了trigger不会被重复获取.按照这种算法正常运行状态下调度器每次读取的trigger中会有相当一部分已被标记为被获取.

获取trigger的过程进行完毕.

触发trigger:

QuartzSchedulerThread line336:

List<TriggerFiredResult> res = qsRsrcs.getJobStore().triggersFired(triggers);

调用JobStoreSupport类的triggersFired()方法:

public List<TriggerFiredResult> triggersFired(final List<OperableTrigger> triggers) throws JobPersistenceException {

        return executeInNonManagedTXLock(LOCK_TRIGGER_ACCESS,

                new TransactionCallback<List<TriggerFiredResult>>() {

                    public List<TriggerFiredResult> execute(Connection conn) throws JobPersistenceException {

                        List<TriggerFiredResult> results = new ArrayList<TriggerFiredResult>();

                        TriggerFiredResult result;

                        for (OperableTrigger trigger : triggers) {

                            try {

                              TriggerFiredBundle bundle = triggerFired(conn, trigger);

                              result = new TriggerFiredResult(bundle);

                            } catch (JobPersistenceException jpe) {

                                result = new TriggerFiredResult(jpe);

                            } catch(RuntimeException re) {

                                result = new TriggerFiredResult(re);

                            }

                            results.add(result);

                        }

                        return results;

                    }

                },

                new TransactionValidator<List<TriggerFiredResult>>() {

                    @Override

                    public Boolean validate(Connection conn, List<TriggerFiredResult> result) throws JobPersistenceException {

                        //...异常处理回调方法

                    }

                });

    }

　　此处再次用到了quratz的行为规范:executeInNonManagedTXLock()方法,在获取锁的情况下对trigger进行触发操作.其中的触发细节如下:

protected TriggerFiredBundle triggerFired(Connection conn,

            OperableTrigger trigger)

        throws JobPersistenceException {

        JobDetail job;

        Calendar cal = null;

        // Make sure trigger wasn't deleted, paused, or completed...

        try { // if trigger was deleted, state will be STATE_DELETED

            String state = getDelegate().selectTriggerState(conn,

                    trigger.getKey());

            if (!state.equals(STATE_ACQUIRED)) {

                return null;

            }

        } catch (SQLException e) {

            throw new JobPersistenceException("Couldn't select trigger state: "

                    + e.getMessage(), e);

        }

        try {

            job = retrieveJob(conn, trigger.getJobKey());

            if (job == null) { return null; }

        } catch (JobPersistenceException jpe) {

            try {

                getLog().error("Error retrieving job, setting trigger state to ERROR.", jpe);

                getDelegate().updateTriggerState(conn, trigger.getKey(),

                        STATE_ERROR);

            } catch (SQLException sqle) {

                getLog().error("Unable to set trigger state to ERROR.", sqle);

            }

            throw jpe;

        }

        if (trigger.getCalendarName() != null) {

            cal = retrieveCalendar(conn, trigger.getCalendarName());

            if (cal == null) { return null; }

        }

        try {

            getDelegate().updateFiredTrigger(conn, trigger, STATE_EXECUTING, job);

        } catch (SQLException e) {

            throw new JobPersistenceException("Couldn't insert fired trigger: "

                    + e.getMessage(), e);

        }

        Date prevFireTime = trigger.getPreviousFireTime();

        // call triggered - to update the trigger's next-fire-time state...

        trigger.triggered(cal);

        String state = STATE_WAITING;

        boolean force = true;

        if (job.isConcurrentExectionDisallowed()) {

            state = STATE_BLOCKED;

            force = false;

            try {

                getDelegate().updateTriggerStatesForJobFromOtherState(conn, job.getKey(),

                        STATE_BLOCKED, STATE_WAITING);

                getDelegate().updateTriggerStatesForJobFromOtherState(conn, job.getKey(),

                        STATE_BLOCKED, STATE_ACQUIRED);

                getDelegate().updateTriggerStatesForJobFromOtherState(conn, job.getKey(),

                        STATE_PAUSED_BLOCKED, STATE_PAUSED);

            } catch (SQLException e) {

                throw new JobPersistenceException(

                        "Couldn't update states of blocked triggers: "

                                + e.getMessage(), e);

            }

        }

        if (trigger.getNextFireTime() == null) {

            state = STATE_COMPLETE;

            force = true;

        }

        storeTrigger(conn, trigger, job, true, state, force, false);

        job.getJobDataMap().clearDirtyFlag();

        return new TriggerFiredBundle(job, trigger, cal, trigger.getKey().getGroup()

                .equals(Scheduler.DEFAULT_RECOVERY_GROUP), new Date(), trigger

                .getPreviousFireTime(), prevFireTime, trigger.getNextFireTime());

    }

该方法做了以下工作:

1.获取trigger当前状态

2.通过trigger中的JobKey读取trigger包含的Job信息

3.将trigger更新至触发状态

4.结合calendar的信息触发trigger,涉及多次状态更新

5.更新数据库中trigger的信息,包括更改状态至STATE_COMPLETE,及计算下一次触发时间.

6.返回trigger触发结果的数据传输类TriggerFiredBundle

从该方法返回后,trigger的执行过程已基本完毕.回到执行quratz操作规范的executeInNonManagedTXLock方法,将数据库锁释放.

trigger触发操作完成

Job执行过程:

再回到线程类QuartzSchedulerThread的 line353这时触发器都已出发完毕,job的详细信息都已就位

QuartzSchedulerThread line:368

qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));

shell.initialize(qs);

为每个Job生成一个可运行的RunShell,并放入线程池运行.

在最后调度线程生成了一个随机的等待时间,进入短暂的等待,这使得其他节点的调度器都有机会获取数据库资源.如此就实现了quratz的负载平衡.

这样一次完整的调度过程就结束了.调度器线程进入下一次循环.

总结:

简单地说,quartz的分布式调度策略是以数据库为边界资源的一种异步策略.各个调度器都遵守一个基于数据库锁的操作规则保证了操作的唯一性.同时多个节点的异步运行保证了服务的可靠.但这种策略有自己的局限性.摘录官方文档中对quratz集群特性的说明:

Only one node will fire the job for each firing. What I mean by that is, if the job has a repeating trigger that tells it to fire every 10 seconds, then at 12:00:00 exactly one node will run the job, and at 12:00:10 exactly one node will run the job, etc. It won't necessarily be the same node each time - it will more or less be random which node runs it. The load balancing mechanism is near-random for busy schedulers (lots of triggers) but favors the same node for non-busy (e.g. few triggers) schedulers. 

The clustering feature works best for scaling out long-running and/or cpu-intensive jobs (distributing the work-load over multiple nodes). If you need to scale out to support thousands of short-running (e.g 1 second) jobs, consider partitioning the set of jobs by using multiple distinct schedulers (including multiple clustered schedulers for HA). The scheduler makes use of a cluster-wide lock, a pattern that degrades performance as you add more nodes (when going beyond about three nodes - depending upon your database's capabilities, etc.).

说明指出,集群特性对于高cpu使用率的任务效果很好,但是对于大量的短任务,各个节点都会抢占数据库锁,这样就出现大量的线程等待资源.这种情况随着节点的增加会越来越严重.

附：

通讯图中关键步骤的主要sql语句：

3.

select TRIGGER_ACCESS from QRTZ2_LOCKS for update

4.

SELECT TRIGGER_NAME,

TRIGGER_GROUP,

NEXT_FIRE_TIME,

PRIORITY

FROM QRTZ2_TRIGGERS

WHERE SCHEDULER_NAME = 'CRMscheduler'

AND TRIGGER_STATE = 'ACQUIRED'

AND NEXT_FIRE_TIME <= '{timekey 30s latter}'

AND ( MISFIRE_INSTR = -1

OR ( MISFIRE_INSTR != -1

AND NEXT_FIRE_TIME >= '{timekey now}' ) )

ORDER BY NEXT_FIRE_TIME ASC,

PRIORITY DESC;

5.

SELECT *

FROM QRTZ2_JOB_DETAILS

WHERE SCHEDULER_NAME = CRMscheduler

AND JOB_NAME = ?

AND JOB_GROUP = ?;

6.

UPDATE TQRTZ2_TRIGGERS

SET TRIGGER_STATE = 'ACQUIRED'

WHERE SCHED_NAME = 'CRMscheduler'

AND TRIGGER_NAME = '{triggerName}'

AND TRIGGER_GROUP = '{triggerGroup}'

AND TRIGGER_STATE = 'waiting';

7.

INSERT INTO QRTZ2_FIRED_TRIGGERS

(SCHEDULER_NAME,

ENTRY_ID,

TRIGGER_NAME,

TRIGGER_GROUP,

INSTANCE_NAME,

FIRED_TIME,

SCHED_TIME,

STATE,

JOB_NAME,

JOB_GROUP,

IS_NONCONCURRENT,

REQUESTS_RECOVERY,

PRIORITY)

VALUES( 'CRMscheduler', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);

8.

commit;

12.

select STAT_ACCESS from QRTZ2_LOCKS for update

13.

SELECT TRIGGER_STATE FROM QRTZ2_TRIGGERS WHERE SCHEDULER_NAME = 'CRMscheduler' AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?;

14.

SELECT TRIGGER_STATE

FROM QRTZ2_TRIGGERS

WHERE SCHEDULER_NAME = 'CRMscheduler'

AND TRIGGER_NAME = ?

AND TRIGGER_GROUP = ?;

14.

SELECT *

FROM QRTZ2_JOB_DETAILS

WHERE SCHEDULER_NAME = CRMscheduler

AND JOB_NAME = ?

AND JOB_GROUP = ?;

15.

SELECT *

FROM QRTZ2_CALENDARS

WHERE SCHEDULER_NAME = 'CRMscheduler'

AND CALENDAR_NAME = ?;

16.

UPDATE QRTZ2_FIRED_TRIGGERS

SET INSTANCE_NAME = ?,

FIRED_TIME = ?,

SCHED_TIME = ?,

ENTRY_STATE = ?,

JOB_NAME = ?,

JOB_GROUP = ?,

IS_NONCONCURRENT = ?,

REQUESTS_RECOVERY = ?

WHERE SCHEDULER_NAME = 'CRMscheduler'

AND ENTRY_ID = ?;

17.

UPDATE TQRTZ2_TRIGGERS

SET TRIGGER_STATE = ?

WHERE SCHED_NAME = 'CRMscheduler'

AND TRIGGER_NAME = '{triggerName}'

AND TRIGGER_GROUP = '{triggerGroup}'

AND TRIGGER_STATE = ？;

18.

UPDATE QRTZ2_TRIGGERS

SET JOB_NAME = ?,

JOB_GROUP = ?,

DESCRIPTION = ?,

NEXT_FIRE_TIME = ?,

PREV_FIRE_TIME = ?,

TRIGGER_STATE = ?,

TRIGGER_TYPE = ?,

START_TIME = ?,

END_TIME = ?,

CALENDAR_NAME = ?,

MISFIRE_INSTRUCTION = ?,

PRIORITY = ?,

JOB_DATAMAP = ?

WHERE SCHEDULER_NAME = SCHED_NAME_SUBST

AND TRIGGER_NAME = ?

AND TRIGGER_GROUP = ?;

19.

commit;

总结

1、搞清楚了上Quartz容器执行作业的的原理和过程，以及作业形成的方式，作业注册到容器的方法。就认识明白了Quartz的核心原理。

2、Quartz虽然很庞大，但是一切都围绕这个核心转，为了配置强大时间调度策略，可以研究专门的CronTrigger。要想灵活配置作业和容器属性，可以通过Quartz的properties文件或者XML来实现。

3、要想调度更多的持久化、结构化作业，可以通过数据库读取作业，然后放到容器中执行。

4、所有的一切都围绕这个核心原理转，搞明白这个了，再去研究更高级用法就容易多了。

5、Quartz与Spring的整合也非常简单，Spring提供一组Bean来支持：MethodInvokingJobDetailFactoryBean、SimpleTriggerBean、SchedulerFactoryBean，看看里面需要注入什么属性即可明白了。Spring会在Spring容器启动时候，启动Quartz容器。

6、Quartz容器的关闭方式也很简单，如果是Spring整合，则有两种方法，一种是关闭Spring容器，一种是获取到SchedulerFactoryBean实例，然后调用一个shutdown就搞定了。如果是Quartz独立使用，则直接调用scheduler.shutdown(true);

7、Quartz的JobDetail、Trigger都可以在运行时重新设置，并且在下次调用时候起作用。这就为动态作业的实现提供了依据。你可以将调度时间策略存放到数据库，然后通过数据库数据来设定Trigger，这样就能产生动态的调度。

转：http://blog.csdn.net/a4307515

巴特西