廢話的前言
以前憑藉年輕，凡事都靠腦記。現在工作幾年後發現，很多以前看過、用過的東西，再次拿起的時候總覺得記不牢靠。”好記性不如爛筆頭”應該是某位上了年紀的大叔的切膚之痛（僅次於上了年紀的難言之癮）。

我覺得這事得怪怪中國的應試教育，中國的考試方式就是要求把腦袋當資料庫，以前中學那點知識，確實還能裝得下。但現在所需的知識量再一次性裝入大腦，就是記憶體溢位的節奏。另，再相信什麼人腦只開發5%的蠢話了（「人腦只用了不到 5%」 的說法是否確有科學依據？）。更可行的方式，應該學學資料庫，大腦只記憶知識的索引，而把知識的本身定義在外部的儲存中（比如筆記）。基於這個理念，現在準備學著寫點總結性的筆記。

那為什麼不能基於google學習呢？因為google的索引不是你自己，不能精確找到你想要的東西。但它的好處是更海量，能給你原本壓根不知道東西。所以，配合使用，療效更好。

Quartz可以用來做什麼？
Quartz是一個任務排程框架。比如你遇到這樣的問題

想每月25號，信用卡自動還款
想每年4月1日自己給當年暗戀女神發一封匿名賀卡
想每隔1小時，備份一下自己的愛情動作片 學習筆記到雲盤
這些問題總結起來就是：在某一個有規律的時間點幹某件事。並且時間的觸發的條件可以非常複雜（比如每月最後一個工作日的17:50），複雜到需要一個專門的框架來幹這個事。 Quartz就是來幹這樣的事，你給它一個觸發條件的定義，它負責到了時間點，觸發相應的Job起來幹活。

一個簡單的示例
這裡面的所有例子都是基於Quartz 2.2.1

package com.test.quartz;

import static org.quartz.DateBuilder.newDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

import java.util.GregorianCalendar;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.calendar.AnnualCalendar;

public class QuartzTest {

public static void main(String[] args) {
    try {
        //建立scheduler
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        //定義一個Trigger
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1") //定義name/group
            .startNow()//一旦加入scheduler，立即生效
            .withSchedule(simpleSchedule() //使用SimpleTrigger
                .withIntervalInSeconds(1) //每隔一秒執行一次
                .repeatForever()) //一直執行，奔騰到老不停歇
            .build();

        //定義一個JobDetail
        JobDetail job = newJob(HelloQuartz.class) //定義Job類為HelloQuartz類，這是真正的執行邏輯所在
            .withIdentity("job1", "group1") //定義name/group
            .usingJobData("name", "quartz") //定義屬性
            .build();

        //加入這個排程
        scheduler.scheduleJob(job, trigger);

        //啟動之
        scheduler.start();

        //執行一段時間後關閉
        Thread.sleep(10000);
        scheduler.shutdown(true);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

}
package com.test.quartz;

import java.util.Date;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloQuartz implements Job {
public void execute(JobExecutionContext context) throws JobExecutionException {
JobDetail detail = context.getJobDetail();
String name = detail.getJobDataMap().getString(“name”);
System.out.println(“say hello to ” + name + ” at ” + new Date());
}
}
這個例子很好的覆蓋了Quartz最重要的3個基本要素：

Scheduler：排程器。所有的排程都是由它控制。
Trigger： 定義觸發的條件。例子中，它的型別是SimpleTrigger，每隔1秒中執行一次（什麼是SimpleTrigger下面會有詳述）。
JobDetail & Job： JobDetail 定義的是任務資料，而真正的執行邏輯是在Job中，例子中是HelloQuartz。 為什麼設計成JobDetail + Job，不直接使用Job？這是因為任務是有可能併發執行，如果Scheduler直接使用Job，就會存在對同一個Job例項併發訪問的問題。而JobDetail & Job 方式，sheduler每次執行，都會根據JobDetail建立一個新的Job例項，這樣就可以規避併發訪問的問題。
Quartz API
Quartz的API的風格在2.x以後，採用的是DSL風格（通常意味著fluent interface風格），就是示例中newTrigger()那一段東西。它是通過Builder實現的，就是以下幾個。（* 下面大部分程式碼都要引用這些Builder * )

//job相關的builder
import static org.quartz.JobBuilder.*;

//trigger相關的builder
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;
import static org.quartz.CronScheduleBuilder.*;
import static org.quartz.DailyTimeIntervalScheduleBuilder.*;
import static org.quartz.CalendarIntervalScheduleBuilder.*;

//日期相關的builder
import static org.quartz.DateBuilder.*;
DSL風格寫起來會更加連貫，暢快，而且由於不是使用setter的風格，語義上會更容易理解一些。對比一下：

JobDetail jobDetail=new JobDetailImpl(“jobDetail1”,”group1”,HelloQuartz.class);
jobDetail.getJobDataMap().put(“name”, “quartz”);

SimpleTriggerImpl trigger=new SimpleTriggerImpl(“trigger1”,”group1”);
trigger.setStartTime(new Date());
trigger.setRepeatInterval(1);
trigger.setRepeatCount(-1);
關於name和group
JobDetail和Trigger都有name和group。

name是它們在這個sheduler裡面的唯一標識。如果我們要更新一個JobDetail定義，只需要設定一個name相同的JobDetail例項即可。

group是一個組織單元，sheduler會提供一些對整組操作的API，比如 scheduler.resumeJobs()。

Trigger
在開始詳解每一種Trigger之前，需要先了解一下Trigger的一些共性。

StartTime & EndTime
startTime和endTime指定的Trigger會被觸發的時間區間。在這個區間之外，Trigger是不會被觸發的。

* 所有Trigger都會包含這兩個屬性 *

優先順序（Priority）
當scheduler比較繁忙的時候，可能在同一個時刻，有多個Trigger被觸發了，但資源不足（比如執行緒池不足）。那麼這個時候比剪刀石頭布更好的方式，就是設定優先順序。優先順序高的先執行。

需要注意的是，優先順序只有在同一時刻執行的Trigger之間才會起作用，如果一個Trigger是9:00，另一個Trigger是9:30。那麼無論後一個優先順序多高，前一個都是先執行。

優先順序的值預設是5，當為負數時使用預設值。最大值似乎沒有指定，但建議遵循Java的標準，使用1-10，不然鬼才知道看到【優先順序為10】是時，上頭還有沒有更大的值。

Misfire(錯失觸發）策略
類似的Scheduler資源不足的時候，或者機器崩潰重啟等，有可能某一些Trigger在應該觸發的時間點沒有被觸發，也就是Miss Fire了。這個時候Trigger需要一個策略來處理這種情況。每種Trigger可選的策略各不相同。

這裡有兩個點需要重點注意：

MisFire的觸發是有一個閥值，這個閥值是配置在JobStore的。比RAMJobStore是org.quartz.jobStore.misfireThreshold。只有超過這個閥值，才會算MisFire。小於這個閥值，Quartz是會全部重新觸發。
所有MisFire的策略實際上都是解答兩個問題：

已經MisFire的任務還要重新觸發嗎？
如果發生MisFire，要調整現有的排程時間嗎？
比如SimpleTrigger的MisFire策略有：

MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY

這個不是忽略已經錯失的觸發的意思，而是說忽略MisFire策略。它會在資源合適的時候，重新觸發所有的MisFire任務，並且不會影響現有的排程時間。

比如，SimpleTrigger每15秒執行一次，而中間有5分鐘時間它都MisFire了，一共錯失了20個，5分鐘後，假設資源充足了，並且任務允許併發，它會被一次性觸發。

這個屬性是所有Trigger都適用。

MISFIRE_INSTRUCTION_FIRE_NOW

忽略已經MisFire的任務，並且立即執行排程。這通常只適用於只執行一次的任務。

MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

將startTime設定當前時間，立即重新排程任務，包括的MisFire的

MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT

類似MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT，區別在於會忽略已經MisFire的任務

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT

在下一次排程時間點，重新開始排程任務，包括的MisFire的

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT

類似於MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT，區別在於會忽略已經MisFire的任務。

MISFIRE_INSTRUCTION_SMART_POLICY

所有的Trigger的MisFire預設值都是這個，大致意思是“把處理邏輯交給聰明的Quartz去決定”。基本策略是，

如果是隻執行一次的排程，使用MISFIRE_INSTRUCTION_FIRE_NOW
如果是無限次的排程(repeatCount是無限的)，使用MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
否則，使用MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
MisFire的東西挺繁雜的，可以參考這篇

Calendar
這裡的Calendar不是jdk的java.util.Calendar，不是為了計算日期的。它的作用是在於補充Trigger的時間。可以排除或加入某一些特定的時間點。

以”每月25日零點自動還卡債“為例，我們想排除掉每年的2月25號零點這個時間點（因為有2.14，所以2月一定會破產）。這個時間，就可以用Calendar來實現。

例子：

AnnualCalendar cal = new AnnualCalendar(); //定義一個每年執行Calendar，精度為天，即不能定義到2.25號下午2:00
java.util.Calendar excludeDay = new GregorianCalendar();
excludeDay.setTime(newDate().inMonthOnDay(2, 25).build());
cal.setDayExcluded(excludeDay, true); //設定排除2.25這個日期
scheduler.addCalendar(“FebCal”, cal, false, false); //scheduler加入這個Calendar

//定義一個Trigger
Trigger trigger = newTrigger().withIdentity(“trigger1”, “group1”)
.startNow()//一旦加入scheduler，立即生效
.modifiedByCalendar(“FebCal”) //使用Calendar !!
.withSchedule(simpleSchedule()
.withIntervalInSeconds(1)
.repeatForever())
.build();
Quartz體貼地為我們提供以下幾種Calendar，注意，所有的Calendar既可以是排除，也可以是包含，取決於：

HolidayCalendar。指定特定的日期，比如20140613。精度到天。
DailyCalendar。指定每天的時間段（rangeStartingTime, rangeEndingTime)，格式是HH:MM[:SS[:mmm]]。也就是最大精度可以到毫秒。
WeeklyCalendar。指定每星期的星期幾，可選值比如為java.util.Calendar.SUNDAY。精度是天。
MonthlyCalendar。指定每月的幾號。可選值為1-31。精度是天
AnnualCalendar。 指定每年的哪一天。使用方式如上例。精度是天。
CronCalendar。指定Cron表示式。精度取決於Cron表示式，也就是最大精度可以到秒。
Trigger實現類
Quartz有以下幾種Trigger實現:

SimpleTrigger
指定從某一個時間開始，以一定的時間間隔（單位是毫秒）執行的任務。

它適合的任務類似於：9:00 開始，每隔1小時，執行一次。

它的屬性有：

repeatInterval 重複間隔
repeatCount 重複次數。實際執行次數是 repeatCount+1。因為在startTime的時候一定會執行一次。* 下面有關repeatCount 屬性的都是同理。　*
例子：

simpleSchedule()
.withIntervalInHours(1) //每小時執行一次
.repeatForever() //次數不限
.build();

simpleSchedule()
.withIntervalInMinutes(1) //每分鐘執行一次
.withRepeatCount(10) //次數為10次
.build();
CalendarIntervalTrigger
類似於SimpleTrigger，指定從某一個時間開始，以一定的時間間隔執行的任務。 但是不同的是SimpleTrigger指定的時間間隔為毫秒，沒辦法指定每隔一個月執行一次（每月的時間間隔不是固定值），而CalendarIntervalTrigger支援的間隔單位有秒，分鐘，小時，天，月，年，星期。

相較於SimpleTrigger有兩個優勢：1、更方便，比如每隔1小時執行，你不用自己去計算1小時等於多少毫秒。 2、支援不是固定長度的間隔，比如間隔為月和年。但劣勢是精度只能到秒。

它適合的任務類似於：9:00 開始執行，並且以後每週 9:00 執行一次

它的屬性有:

interval 執行間隔
intervalUnit 執行間隔的單位（秒，分鐘，小時，天，月，年，星期）
例子:

calendarIntervalSchedule()
.withIntervalInDays(1) //每天執行一次
.build();

calendarIntervalSchedule()
.withIntervalInWeeks(1) //每週執行一次
.build();
DailyTimeIntervalTrigger
指定每天的某個時間段內，以一定的時間間隔執行任務。並且它可以支援指定星期。

它適合的任務類似於：指定每天9:00 至 18:00 ，每隔70秒執行一次，並且只要週一至週五執行。

它的屬性有:

startTimeOfDay 每天開始時間
endTimeOfDay 每天結束時間
daysOfWeek 需要執行的星期
interval 執行間隔
intervalUnit 執行間隔的單位（秒，分鐘，小時，天，月，年，星期）
repeatCount 重複次數
例子:

dailyTimeIntervalSchedule()
.startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)) //第天9：00開始
.endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 0)) //16：00 結束
.onDaysOfTheWeek(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY) //週一至週五執行
.withIntervalInHours(1) //每間隔1小時執行一次
.withRepeatCount(100) //最多重複100次（實際執行100+1次）
.build();

dailyTimeIntervalSchedule()
.startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)) //第天9：00開始
.endingDailyAfterCount(10) //每天執行10次，這個方法實際上根據 startTimeOfDay+interval*count 算出 endTimeOfDay
.onDaysOfTheWeek(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY) //週一至週五執行
.withIntervalInHours(1) //每間隔1小時執行一次
.build();
CronTrigger
適合於更復雜的任務，它支援型別於Linux Cron的語法（並且更強大）。基本上它覆蓋了以上三個Trigger的絕大部分能力（但不是全部）—— 當然，也更難理解。

它適合的任務類似於：每天0:00,9:00,18:00各執行一次。

它的屬性只有:

Cron表示式。但這個表示式本身就夠複雜了。下面會有說明。
例子：

cronSchedule(“0 0/2 8-17 * * ?”) // 每天8:00-17:00，每隔2分鐘執行一次
.build();

cronSchedule(“0 30 9 ? * MON”) // 每週一，9:30執行一次
.build();

weeklyOnDayAndHourAndMinute(MONDAY,9, 30) //等同於 0 30 9 ? * MON
.build();
Cron表示式
位置 時間域 允許值 特殊值
1 秒 0-59 , - * /
2 分鐘 0-59 , - * /
3 小時 0-23 , - * /
4 日期 1-31 , - * ? / L W C
5 月份 1-12 , - * /
6 星期 1-7 , - * ? / L C #
7 年份（可選） 1-31 , - * /
星號()：可用在所有欄位中，表示對應時間域的每一個時刻，例如， 在分鐘欄位時，表示“每分鐘”；

問號（?）：該字元只在日期和星期欄位中使用，它通常指定為“無意義的值”，相當於點位符；

減號(-)：表達一個範圍，如在小時欄位中使用“10-12”，則表示從10到12點，即10,11,12；

逗號(,)：表達一個列表值，如在星期欄位中使用“MON,WED,FRI”，則表示星期一，星期三和星期五；

斜槓(/)：x/y表達一個等步長序列，x為起始值，y為增量步長值。如在分鐘欄位中使用0/15，則表示為0,15,30和45秒，而5/15在分鐘欄位中表示5,20,35,50，你也可以使用*/y，它等同於0/y；

L：該字元只在日期和星期欄位中使用，代表“Last”的意思，但它在兩個欄位中意思不同。L在日期欄位中，表示這個月份的最後一天，如一月的31號，非閏年二月的28號；如果L用在星期中，則表示星期六，等同於7。但是，如果L出現在星期欄位裡，而且在前面有一個數值X，則表示“這個月的最後X天”，例如，6L表示該月的最後星期五；

W：該字元只能出現在日期欄位裡，是對前導日期的修飾，表示離該日期最近的工作日。例如15W表示離該月15號最近的工作日，如果該月15號是星期六，則匹配14號星期五；如果15日是星期日，則匹配16號星期一；如果15號是星期二，那結果就是15號星期二。但必須注意關聯的匹配日期不能夠跨月，如你指定1W，如果1號是星期六，結果匹配的是3號星期一，而非上個月最後的那天。W字串只能指定單一日期，而不能指定日期範圍；

LW組合：在日期欄位可以組合使用LW，它的意思是當月的最後一個工作日；

井號(#)：該字元只能在星期欄位中使用，表示當月某個工作日。如6#3表示當月的第三個星期五(6表示星期五，#3表示當前的第三個)，而4#5表示當月的第五個星期三，假設當月沒有第五個星期三，忽略不觸發；

C：該字元只在日期和星期欄位中使用，代表“Calendar”的意思。它的意思是計劃所關聯的日期，如果日期沒有被關聯，則相當於日曆中所有日期。例如5C在日期欄位中就相當於日曆5日以後的第一天。1C在星期欄位中相當於星期日後的第一天。

Cron表示式對特殊字元的大小寫不敏感，對代表星期的縮寫英文大小寫也不敏感。

一些例子：

表示式 說明
0 0 12 * * ? 每天12點執行
0 15 10 ? * * 每天10:15執行
0 15 10 * * ? 每天10:15執行
0 15 10 * * ? * 每天10:15執行
0 15 10 * * ? 2008 在2008年的每天10：15執行
0 * 14 * * ? 每天14點到15點之間每分鐘執行一次，開始於14:00，結束於14:59。
0 0/5 14 * * ? 每天14點到15點每5分鐘執行一次，開始於14:00，結束於14:55。
0 0/5 14,18 * * ? 每天14點到15點每5分鐘執行一次，此外每天18點到19點每5鍾也執行一次。
0 0-5 14 * * ? 每天14:00點到14:05，每分鐘執行一次。
0 10,44 14 ? 3 WED 3月每週三的14:10分到14: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 2007-2009 在2007,2008,2009年每個月的最後一個星期五的10:15分執行。
0 15 10 ? * 6#3 每月第三個星期五的10:15分執行。
JobDetail & Job
JobDetail是任務的定義，而Job是任務的執行邏輯。在JobDetail裡會引用一個Job Class定義。一個最簡單的例子

public class JobTest {
public static void main(String[] args) throws SchedulerException, IOException {
JobDetail job=newJob()
.ofType(DoNothingJob.class) //引用Job Class
.withIdentity(“job1”, “group1”) //設定name/group
.withDescription(“this is a test job”) //設定描述
.usingJobData(“age”, 18) //加入屬性到ageJobDataMap
.build();

       job.getJobDataMap().put("name", "quertz"); //加入屬性name到JobDataMap

       //定義一個每秒執行一次的SimpleTrigger
       Trigger trigger=newTrigger()
               .startNow()
               .withIdentity("trigger1")
               .withSchedule(simpleSchedule()
                   .withIntervalInSeconds(1)
                   .repeatForever())
               .build();

       Scheduler sche=StdSchedulerFactory.getDefaultScheduler();
       sche.scheduleJob(job, trigger);

       sche.start();

       System.in.read();

       sche.shutdown();
}

}

public class DoNothingJob implements Job {
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println(“do nothing”);
}
}
從上例我們可以看出，要定義一個任務，需要幹幾件事：

建立一個org.quartz.Job的實現類，並實現實現自己的業務邏輯。比如上面的DoNothingJob。
定義一個JobDetail，引用這個實現類
加入scheduleJob
Quartz排程一次任務，會幹如下的事：

JobClass jobClass=JobDetail.getJobClass()
Job jobInstance=jobClass.newInstance()。所以Job實現類，必須有一個public的無參構建方法。
jobInstance.execute(JobExecutionContext context)。JobExecutionContext是Job執行的上下文，可以獲得Trigger、Scheduler、JobDetail的資訊。
也就是說，每次排程都會建立一個新的Job例項，這樣的好處是有些任務併發執行的時候，不存在對臨界資源的訪問問題——當然，如果需要共享JobDataMap的時候，還是存在臨界資源的併發訪問的問題。

JobDataMap
Job都次都是newInstance的例項，那我怎麼傳值給它？ 比如我現在有兩個傳送郵件的任務，一個是發給”liLei”,一個發給”hanmeimei”,不能說我要寫兩個Job實現類LiLeiSendEmailJob和HanMeiMeiSendEmailJob。實現的辦法是通過JobDataMap。

每一個JobDetail都會有一個JobDataMap。JobDataMap本質就是一個Map的擴充套件類，只是提供了一些更便捷的方法，比如getString()之類的。

我們可以在定義JobDetail，加入屬性值，方式有二：

newJob().usingJobData(“age”, 18) //加入屬性到ageJobDataMap

or

job.getJobDataMap().put(“name”, “quertz”); //加入屬性name到JobDataMap
然後在Job中可以獲取這個JobDataMap的值，方式同樣有二：

public class HelloQuartz implements Job {
private String name;

public void execute(JobExecutionContext context) throws JobExecutionException {
    JobDetail detail = context.getJobDetail();
    JobDataMap map = detail.getJobDataMap(); //方法一：獲得JobDataMap
    System.out.println("say hello to " + name + "[" + map.getInt("age") + "]" + " at "
                       + new Date());
}

//方法二：屬性的setter方法，會將JobDataMap的屬性自動注入
public void setName(String name) { 
    this.name = name;
}

}
對於同一個JobDetail例項，執行的多個Job例項，是共享同樣的JobDataMap，也就是說，如果你在任務裡修改了裡面的值，會對其他Job例項（併發的或者後續的）造成影響。

除了JobDetail，Trigger同樣有一個JobDataMap，共享範圍是所有使用這個Trigger的Job例項。

Job併發
Job是有可能併發執行的，比如一個任務要執行10秒中，而排程演算法是每秒中觸發1次，那麼就有可能多個任務被併發執行。

有時候我們並不想任務併發執行，比如這個任務要去”獲得資料庫中所有未傳送郵件的名單“，如果是併發執行，就需要一個數據庫鎖去避免一個數據被多次處理。這個時候一個@DisallowConcurrentExecution解決這個問題。

就是這樣

public class DoNothingJob implements Job {
@DisallowConcurrentExecution
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println(“do nothing”);
}
}
注意，@DisallowConcurrentExecution是對JobDetail例項生效，也就是如果你定義兩個JobDetail，引用同一個Job類，是可以併發執行的。

JobExecutionException
Job.execute()方法是不允許丟擲除JobExecutionException之外的所有異常的（包括RuntimeException)，所以編碼的時候，最好是try-catch住所有的Throwable，小心處理。

其他屬性
Durability(耐久性？)

如果一個任務不是durable，那麼當沒有Trigger關聯它的時候，它就會被自動刪除。

RequestsRecovery

如果一個任務是”requests recovery”，那麼當任務執行過程非正常退出時（比如程序崩潰，機器斷電，但不包括丟擲異常這種情況），Quartz再次啟動時，會重新執行一次這個任務例項。

可以通過JobExecutionContext.isRecovering()查詢任務是否是被恢復的。

Scheduler
Scheduler就是Quartz的大腦，所有任務都是由它來設施。

Schduelr包含一個兩個重要元件: JobStore和ThreadPool。

JobStore是會來儲存執行時資訊的，包括Trigger,Schduler,JobDetail，業務鎖等。它有多種實現RAMJob(記憶體實現)，JobStoreTX(JDBC，事務由Quartz管理），JobStoreCMT(JDBC，使用容器事務)，ClusteredJobStore(叢集實現)、TerracottaJobStore(什麼是Terractta)。

ThreadPool就是執行緒池，Quartz有自己的執行緒池實現。所有任務的都會由執行緒池執行。

SchedulerFactory
SchdulerFactory，顧名思義就是來用建立Schduler了，有兩個實現：DirectSchedulerFactory和 StdSchdulerFactory。前者可以用來在程式碼裡定製你自己的Schduler引數。後者是直接讀取classpath下的quartz.properties（不存在就都使用預設值）配置來例項化Schduler。通常來講，我們使用StdSchdulerFactory也就足夠了。

SchdulerFactory本身是支援建立RMI stub的，可以用來管理遠端的Scheduler，功能與本地一樣，可以遠端提交個Job什麼的。

DirectSchedulerFactory的建立介面

/**
 * Same as
 * {@link DirectSchedulerFactory#createScheduler(ThreadPool threadPool, JobStore jobStore)},
 * with the addition of specifying the scheduler name and instance ID. This
 * scheduler can only be retrieved via
 * {@link DirectSchedulerFactory#getScheduler(String)}
 *
 * @param schedulerName
 *          The name for the scheduler.
 * @param schedulerInstanceId
 *          The instance ID for the scheduler.
 * @param threadPool
 *          The thread pool for executing jobs
 * @param jobStore
 *          The type of job store
 * @throws SchedulerException
 *           if initialization failed
 */
public void createScheduler(String schedulerName,
        String schedulerInstanceId, ThreadPool threadPool, JobStore jobStore)
    throws SchedulerException;

StdSchdulerFactory的配置例子， 更多配置，參考Quartz配置指南：

org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
這裡未講的稍微高階的主題
JobStore 介紹、配置
叢集: 介紹、配置
RMI
監聽器 TriggerListeners and JobListeners、SchedulerListeners
外掛