定時器的實現 Quartz

在我們的項目中，經常需要用到定時器來解決一些需要定時執行或者重複執行的工作，之前會選擇用線程來達到定時的效果

1.線程實現定時：

public class QuartzThread extends Thread{
	private Date date;
	@Override
	public void run() {		
		while(true){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			date=new Date();
			System.out.println(date);
		}
	}
}

輸出結果：類似於定時一秒執行一次操作

Fri Aug 18 20:53:22 CST 2017
Fri Aug 18 20:53:23 CST 2017
Fri Aug 18 20:53:24 CST 2017
Fri Aug 18 20:53:25 CST 2017
Fri Aug 18 20:53:26 CST 2017
Fri Aug 18 20:53:27 CST 2017
Fri Aug 18 20:53:28 CST 2017

當利用線程實現一些較爲複雜的定時工作時，程序會面臨崩潰，使用定時器是一個很好的選擇

2.java中常見的定時器有兩種：

 （1）藉助java.util.Timer類來實現（Timer類線程安全）

 （2）藉助Quartz定時器實現

2.1 給出用Timer實現定時器的代碼

Timer是一個定時器工具，它可以在後臺線程計劃執行指定的任務，可以執行一次也可以多次

TimerTask的子類就是需要執行的具體任務，繼承TimerTask時需要實現run方法，裏面寫具體的任務邏輯

創建Time類的實例，創建後臺線程，實例化任務對象，制定執行計劃，time.schedule(TimerTask對象, 開始執行前的定時時間);

如下面代碼所示

public class TimerTask1 extends TimerTask{
	@Override
	public void run() {
		System.out.println("執行任務1");
	}
}

public class TimerTask2 extends TimerTask{
	@Override
	public void run() {
		System.out.println("執行任務2");
	}
}

public class Test {
	Timer time=new Timer();
	public static void main(String[] args) {		
		new Test().time.schedule(new TimerTask1(), 1000);
		new Test().time.schedule(new TimerTask2(), 4000);
	}
}

打印結果：任務一1秒後執行，任務2緊接着任務1 在4秒後執行

執行任務1
執行任務2

將程序改成如下就可以實現一個具體時間的定時

Timer time=new Timer();
	public static void main(String[] args) {		
		new Test().time.schedule(new TimerTask1(), getCanlder());
		new Test().time.schedule(new TimerTask2(), getCanlder());
	}
	
	public static Date getCanlder(){
		Calendar c=Calendar.getInstance();
		c.set(Calendar.HOUR_OF_DAY, 21);
		c.set(Calendar.MINUTE, 2);
		c.set(Calendar.SECOND, 1);
		Date time = c.getTime();
		return time;
	}

注：只要一個程序的Timer線程在運行，那這個程序就無法停止，介紹4種終止Timer線程的方法

（1）調用Timer的cancel()方法，可以在任何地方調用，甚至是在TimerTask的run方法中；

（2）創建Timer對象時賦值爲true，Timer time=new Timer(true);使Timer線程成爲一個daemon線程，這樣當程序只有daemon線程時，就會自動終止運行。

（3）當所有任務執行完成後，將timer對象的引用置爲null，timer線程終止

TimerTask1 task1=new TimerTask1();
TimerTask2 task2=new TimerTask2();
new Test().time.schedule(task1, 1000);		
new Test().time.schedule(task2, 2000);
new Test().time=null;

（4）調用System.exit(0);方法，讓整個程序終止（所有線程都停止）；

使用Timer定時器的缺點：

沒有持久化機制

日程管理部靈活（只能設置開始時間，重複時間間隔，特定的日期和時間）

沒有使用線程池（一個Timer是一個獨立的線程）

需要自己完成有關任務的相關措施，沒有切實的管理方案

2.2 Quartz定時器的實現

（1） Quartz的核心概念

Job：表示一個工作，要實現的具體任務，此接口只有一個實現方法public void execute(JobExecutionContext context) throws JobExecutionException

JobDetail：表示一個具體的可執行的調度程序，Job是JobDetail執行的具體內容，JobDetail還包括了任務調度的方案和策略。

Trigger：調度參數的配置，比如什麼時候去調

Scheduler：調度容器，一個調度容器中可以註冊多個Trigger和JobDetail，當JobDetail和Trigger組合，就可以被Scheduler調度使用了。

（2）具體代碼

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完成，在這裏指Job的實現類HelloQuartz，
	            //使用JobDetail和Job避免併發訪問的問題，Scheduler每次執行的時候，都會根據JobDetail創建一個Job實例
	            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();
	        }
	    }
	}

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());
	    }
}

scheduler是個容器，scheduler控制jobDetail的執行，控制的策略是通過trigger。

當scheduler容器啓動後，jobDetail才能根據關聯的trigger策略去執行。當scheduler容器關閉後，所有的jobDetail都停止執行。

1、scheduler是一個計劃調度器容器（總部），容器裏面可以盛放衆多的JobDetail和trigger，當容器啓動後，裏面的每個JobDetail都會根據trigger按部就班自動去執行。

2、JobDetail是一個可執行的工作，它本身可能是有狀態的。

3、Trigger代表一個調度參數的配置，什麼時候去調。

4、當JobDetail和Trigger在scheduler容器上註冊後，形成了裝配好的作業（JobDetail和Trigger所組成的一對兒），就可以伴隨容器啓動而調度執行了。

5、scheduler是個容器，容器中有一個線程池，用來並行調度執行每個作業，這樣可以提高容器效率。

總結：
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，這樣就能產生動態的調度。

（3）關於name和group

JobDetail和Trigger都有name和group

name：是它們在調度容器Scheduler裏的唯一標識，當我們想更新一個JObDetail的定義時，只需要設置一個name相同的JobDetail實例即可。

group：是一個組織單元，調度容器scheduler會提供對整組操作的API，如：scheduler.resumeJobs()；

（4）

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的策略實際上都是解答兩個問題：

1. 已經MisFire的任務還要重新觸發嗎？
2. 如果發生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去決定”。基本策略是，

  1. 如果是隻執行一次的調度，使用MISFIRE_INSTRUCTION_FIRE_NOW
  2. 如果是無限次的調度(repeatCount是無限的)，使用MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
  3. 否則，使用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");
    }
}

從上例我們可以看出，要定義一個任務，需要幹幾件事：

1. 創建一個org.quartz.Job的實現類，並實現實現自己的業務邏輯。比如上面的DoNothingJob。
2. 定義一個JobDetail，引用這個實現類
3. 加入scheduleJob

Quartz調度一次任務，會幹如下的事：

1. JobClass jobClass=JobDetail.getJobClass()
2. Job jobInstance=jobClass.newInstance()。所以Job實現類，必須有一個public的無參構建方法。
3. 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的創建接口

public void createScheduler(String schedulerName,
            String schedulerInstanceId, ThreadPool threadPool, JobStore jobStore)
        throws SchedulerException;