1.Quartz 体系结构

Quartz 设计有四个核心类，分别是Scheduler(调度器)、Job(任务) 、Trigger（触发器）、JobDetail(任务详情)，他们是使用Quartz的关键。

1.1 Job

Job：定义需要执行的任务，该类是一个接口，只定义了一个方法execute(JobExecutionContext context),在实现类的execute方法中编写所需要定时执行的Job(任务)，JobExcutionContext类提供了调度应用的一些信息。Job运行时的信息保存在JobDataMap实例中。

1.2 Trigger

Trigger：负责设置调度策略。该类是一个接口，描述触发job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当且仅当需调度一次或者以固定时间间隔周期执行调度，SimpleTrigger 是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如在周一到周五的15:00 ~ 16:00 执行调度等。

1.3 Scheduler

Scheduler：调度器就相当于一个容器，装载着任务和触发器。该类是一个接口。代表一个Quartz的独立运行容器。Trigger和JobDetail可以注册到Scheduler中，两者在Scheduler中拥有各自的组及名称，组及名称是Scheduler查找定位容器中某一对象的依据。

1.4 JobDetail

JobDetail:描述Job的实现类及其它相关的静态信息，如：Job名字、描述、关联监听器等信息。Quartz每次调度Job时，都重新创建一个Job实例，它接受一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。

1.5 ThreadPool

Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提高运行效率。
Job有一个 StatefulJob 子接口（Quartz2后用@PersistJobDataAfterExecution注解代替），代表有状态的任务，改接口是一个没有方法的标签接口，其目的是让Quartz知道任务的类型，以便采用不同的执行方案。

• 无状态任务在执行时拥有自己的 JobDataMap 拷贝，对 JobDataMap 的更改不会影响下次的执行。

• 有状态任务共享同一个 JobDataMap 实例，每次任务执行对 JobDataMap 所做的更改会保存下来，后面的执行可以看到这个更改，也即每次执行任务后都会对后面的执行发生影响。

正因为这个原因，无状态的Job能并发执行，而有状态的StatefulJob不能并发执行。

1.6 Listener

Listener:Quartz拥有完善的事件和监听体系，大部分组件都拥有事件，如：JobListener监听任务执行前事件、任务执行后事件；TriggerListener监听触发前事件，出发后事件；TriggerListener监听调度开始事件,关闭事件等等，可以注册响应的监听器处理感兴趣的事件。

2.cronExpression 表达式

格式：[秒][分][时][每月的第几日][月][每周的第几日][年]

特殊字符说明：

注意：字符不区分大小写，MON,mon相同。

2.1 cornExpression示例

``

3.Listener示例

3.1注册对特定作业的JobListener

scheduler.getListenerManager().addJobListener(
          new MyJobListener(),KeyMatcher.keyEquals(new JobKey("job1","group1")));

3.2注册对特定组的所有作业的JobListener

scheduler.getListenManager().addJobListener(
          new MyJobListener(),GroupMatcher.jobGroupEquals("group1"));

3.3注册对两个特定组的所有作业的JobListener

scheduler.getListenManager().addJobListener(
          new MyJobListener(),OrMatcher.or(
                  GroupMatcher.jobGroupEquals("group1"),
                  GroupMatcher.jobGroupEquals("group2")));

3.4 注册一个对所有作业的JobListener

sched.getListenerManager().addJobListener(
          new MyJobListener(),EverythingMatcher.allJobs());

3.5 JobListener 实现类

public class MyJobListener implements JobListener {

    @Override
    public String getName() {
        return "MyJobListener"; // 一定要设置名称
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {

    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {

    }

    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        if (jobException != null) {
            try {
                // 立即关闭调度器
                context.getScheduler().shutdown();
                System.out.println("Error occurs when executing jobs, shut down the scheduler.");
                // 给管理员发送邮件...
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    }
}

4.SchedulerListener 示例

SchedulerListener 在调度程序的Scheduler中注册。SchedulerListener 可以运行任何实现 org.quartz.SchedulerListener 接口的对象。

4.1 添加调度器的 SchedulerListener：

scheduler.getListenerManager().addSchedulerListener(mySchedListener);

4.2 删除调度器的 SchedulerListener：

scheduler.getListenerManager().removeSchedulerListener(mySchedListener);

5.多线程并发执行与数据共享

5.1禁止同一个JobDetail中的多个实例并发执行

Quartz定时任务默认都是并发执行的。不会等待上一次任务执行完毕，只要间隔时间到了就会执行，如果定时任务执行太长，会长时间占用资源。导致其它任务堵塞。（quartz是用一个线程池去执行的。线程池有大小。如果同一任务并发执行过多。影响线程池其它任务执行）

禁止并发执行的意思并不是不能同时执行多个Job，而是不能并发执行同一个Job Definition(由JobDetail定义)，但是可以同时执行多个不同的JobDetail，举例说明，我们有一个Job类，叫做SayHelloJob，并在这个Job上加了@DisallowConcurrentExecution注解，然后再这个Job上定义了很多JobDetail，如sayHelloTomJobDetail，sayHelloMikeJobDetail，那么当scheduler启动时，不会并发执行多个sayHelloTomJobDetail 或者sayHelloMikeJobDetail 但可以同时执行 sayHelloTomJobDetail跟sayHelloMikeJobDetail。

5.2 同一个JobDetail中多个实例的数据共享

@PersistJobDataAfterExecution 是用在Job实现类上，表示一个有状态的任务，意思是当正常执行完Job后，JobDataMap中的数据会保存 给下一次调用使用。

注意：当使用@persistJobDataAfterExecution注解时，为了避免并发时，存储数据造成混乱，强烈建议吧@DisallolwConcurrentExecution 注解也加上。

示例

假设定时任务的时间间隔为 3 秒，但 job 执行时间是 10 秒。当设置 @DisallowConcurrentExecution 以后程序会等任务执行完毕后再去执行，否则会在 3 秒时再启动新的线程执行。

当设置 @PersistJobDataAfterExecution 时，在执行完 Job 的 execution 方法后保存 JobDataMap 当中固定数据，以便任务在重复执行的时候具有相同的 JobDataMap；在默认情况下也就是没有设置 @PersistJobDataAfterExecution 的时候每个 job 都拥有独立 JobDataMap。

6.Quartz 异常与中断

6.1 作业异常

org.quartz.JobExecutionException会在Scheduler(调度器)运行错误时，由Job(作业)实现类抛出。

在我们捕获异常并解决异常后，可以调用JobExecutionException#setRefireImmediately(true) 立即重新执行作业。
假设我们有一个会抛出异常的job实现类，job实现类的代码片段如下

try {
    // 一个异常例子，假设第一次传入的 denominator 为 0，那么将会抛出异常
    calculation = 4815 / denominator;
} catch (Exception e) {
    JobExecutionException e2 = new JobExecutionException(e);

    // 在第一次异常后，修改 denominator 参数为 1，那么后面的执行就不会出错了
    dataMap.put("denominator", "1");

    // true 表示立即重新执行作业
    e2.setRefireImmediately(true);
    throw e2;
}

上面的作乐会在第一次执行时抛出java.lang.ArithmeticException: / by zero异常后，马上又会执行一次，之后都可以正常执行作业。

注意：为了共享在同一个JobDetail中的JobDataMap，我们需要再上面这个Job实现类上加入@PersistJobDataAfterExecution 和 @DisallowconcurrentExecution注解。

6.3 捕获异常，取消所有触发器

在我们捕获异常时，可以调用JobExecutionException#setUnscheduleAllTriggers(true)取消所有与这个作业有关的触发器。
假设我们有一个会爆出一场的job实现类，job实现类代码片段如下：

try {
    // 一个异常例子
    int zero = 0;
    calculation = 4815 / zero;
} catch (Exception e) {
    JobExecutionException e2 = new JobExecutionException(e);
    // true 表示 Quartz 会自动取消所有与这个 job 有关的 trigger，从而避免再次运行 job
    e2.setUnscheduleAllTriggers(true);
    throw e2;
}

上面的作业会在抛出异常后，就不再执行任何有关该作业的触发器了。

6.3 作业中断

org.quartz.InterruptableJob接口提供了一种中断机制，这个接口只有一个方法interrupt() 这个方法会在用户发出中断请求到Scheduler(调度器)时触发(即调用Scheduler#interrupt(JobDetail#getKey())方法时触发)

其中InterruptableJob接口又继承了Job接口，所以当我们使用时，只需要实现InterruptableJob接口，重写其中的execute和interrupt方法即可。