如何用 Java 實現 Web 應用中的定時任務

定時任務，是指定一個未來的時間範圍執行一定任務的功能。在當前WEB應用中，多數應用都具備任務調度功能，針對不同的語音，不同的操作系統， 都有其自己的語法及解決方案，windows操作系統把它叫做任務計劃，linux中cron服務都提供了這個功能，在我們開發業務系統中很多時候會涉及到這個功能。本場chat將使用java語言完成日常開發工作中常用定時任務的使用，希望給大家工作及學習帶來幫助。

一、定時任務場景

（1）驅動處理工作流程

作為一個新的預支付訂單被初始化放置，如果該訂單在指定時間內未進行支付，則將被認為超時訂單進行關閉處理；電商系統中應用較多，用戶購買商品產生訂單，但未進行支付，訂單產生30分鐘內未支付將關閉訂單（且滿足該場景數量龐大），不可能採用人工干預。

（2）系統維護

調度工作將獲取系統異常日誌，及某些關鍵點數據存儲到資料庫中，每個工作日（節假日除外平日）在11:30 PM轉儲到資料庫，且生成一個XML文件發送至某位員工郵箱。

（3）在應用程式內提供提醒服務。

系統定時提醒登錄用戶某時間點執行相關工作。

（4）定時對賬任務

公司與三方公司（運營商，銀行等）業務，每天零點後進行當天業務的對賬，將對賬信息結果數據發送至相關負責人郵箱，第二天工作時間進行處理不匹配數據。

（5）數據統計

數據記錄較多，實時從資料庫讀取查詢會產生一定時間，為客戶體驗及性能需要，故每周（天，小時）將數據進行彙總，從而在展示數據時能夠快速的呈現數據。

使用定時任務的場景還有很多... 看來定時任務在我們日常的開發中真的應用很廣泛...

二、主流定時任務技術講解 Timer

相信大家都已經非常熟悉 java.util.Timer 了，它是最簡單的一種實現任務調度的方法，下麵給出一個具體的例子：

package com.ibm.scheduler; 
 import java.util.Timer; 
 import java.util.TimerTask; 

 public class TimerTest extends TimerTask { 

 private String jobName = ""; 

 public TimerTest(String jobName) { 
     super(); 
     this.jobName = jobName; 
 } 

 @Override 
 public void run() { 
 System.out.println("execute " + jobName); 
 } 

 public static void main(String[] args) { 
     Timer timer = new Timer(); 
     long delay1 = 1 * 1000; 
     long period1 = 1000; 
     // 從現在開始 1 秒鐘之後，每隔 1 秒鐘執行一次 job1 
     timer.schedule(new TimerTest("job1"), delay1, period1); 
     long delay2 = 2 * 1000; 
     long period2 = 2000; 
     // 從現在開始 2 秒鐘之後，每隔 2 秒鐘執行一次 job2 
     timer.schedule(new TimerTest("job2"), delay2, period2); 
     } 
 }java學習群669823128

/**
輸出結果: 
execute job1 
execute job1 
execute job2 
execute job1 
execute job1 
execute job2 
*/

使用 Timer 實現任務調度的核心類是 Timer 和 TimerTask。其中 Timer 負責設定 TimerTask 的起始與間隔執行時間。使用者只需要創建一個 TimerTask 的繼承類，實現自己的 run 方法，然後將其丟給 Timer 去執行即可。Timer 的設計核心是一個 TaskList 和一個 TaskThread。Timer 將接收到的任務丟到自己的 TaskList 中，TaskList 按照 Task 的最初執行時間進行排序。TimerThread 在創建 Timer 時會啟動成為一個守護線程。這個線程會輪詢所有任務，找到一個最近要執行的任務，然後休眠，當到達最近要執行任務的開始時間點，TimerThread 被喚醒並執行該任務。之後 TimerThread 更新最近一個要執行的任務，繼續休眠。

Timer 的優點在於簡單易用，但由於所有任務都是由同一個線程來調度，因此所有任務都是串列執行的，同一時間只能有一個任務在執行，前一個任務的延遲或異常都將會影響到之後的任務（這點需要註意）。

ScheduledExecutor

鑒於 Timer 的上述缺陷，Java 5 推出了基於線程池設計的 ScheduledExecutor。其設計思想是，每一個被調度的任務都會由線程池中一個線程去執行，因此任務是併發執行的，相互之間不會受到干擾。需 要註意的是，只有當任務的執行時間到來時，ScheduedExecutor 才會真正啟動一個線程，其餘時間 ScheduledExecutor 都是在輪詢任務的狀態。

package com.ibm.scheduler;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorTest implements Runnable {
    private String jobName = "";

    public ScheduledExecutorTest(String jobName) {
        super();
        this.jobName = jobName;
    }

    @Override
    public void run() {
        System.out.println("execute " + jobName);
    }

    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);

        long initialDelay1 = 1;
        long period1 = 1;
        // 從現在開始1秒鐘之後，每隔1秒鐘執行一次job1
        service.scheduleAtFixedRate(
                new ScheduledExecutorTest("job1"), initialDelay1,
                period1, TimeUnit.SECONDS);

        long initialDelay2 = 1;
        long delay2 = 1;
        // 從現在開始2秒鐘之後，每隔2秒鐘執行一次job2
        service.scheduleWithFixedDelay(
                new ScheduledExecutorTest("job2"), initialDelay2,
                delay2, TimeUnit.SECONDS);
    }
}

/**
輸出結果:
execute job1
execute job1
execute job2
execute job1
execute job1
execute job2
*/

上述代碼展示了 ScheduledExecutorService 中兩種最常用的調度方法 ScheduleAtFixedRate 和 ScheduleWithFixedDelay。ScheduleAtFixedRate 每次執行時間為上一次任務開始起向後推一個時間間隔，即每次執行時間為 :initialDelay, initialDelay+period, initialDelay+2*period, … ScheduleWithFixedDelay每次執行時間為上一次任務結束起向後推一個時間間隔，即每次執行時間為：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay。由此可見，ScheduleAtFixedRate 是基於固定時間間隔進行任務調度，ScheduleWithFixedDelay 取決於每次任務執行的時間長短，是基於不固定時間間隔進行任務調度。

用 ScheduledExecutor 和 Calendar 實現複雜任務調度

Timer 和 ScheduledExecutor 都僅能提供基於開始時間與重覆間隔的任務調度，不能勝任更加複雜的調度需求。比如，設置每星期二的 16:38:10 執行任務。該功能使用 Timer 和 ScheduledExecutor 都不能直接實現，但我們可以藉助 Calendar 間接實現該功能。

package com.ibm.scheduler;

import java.util.Calendar;
import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExceutorTest2 extends TimerTask {

    private String jobName = "";

    public ScheduledExceutorTest2(String jobName) {
        super();
        this.jobName = jobName;
    }

    @Override
    public void run() {
        System.out.println("Date = "+new Date()+", execute " + jobName);
    }

    /**
     * 計算從當前時間currentDate開始，滿足條件dayOfWeek, hourOfDay, 
     * minuteOfHour, secondOfMinite的最近時間
     * @return
     */
    public Calendar getEarliestDate(Calendar currentDate, int dayOfWeek,
            int hourOfDay, int minuteOfHour, int secondOfMinite) {
        //計算當前時間的WEEK_OF_YEAR,DAY_OF_WEEK, HOUR_OF_DAY, MINUTE,SECOND等各個欄位值
        int currentWeekOfYear = currentDate.get(Calendar.WEEK_OF_YEAR);
        int currentDayOfWeek = currentDate.get(Calendar.DAY_OF_WEEK);
        int currentHour = currentDate.get(Calendar.HOUR_OF_DAY);
        int currentMinute = currentDate.get(Calendar.MINUTE);
        int currentSecond = currentDate.get(Calendar.SECOND);

        //如果輸入條件中的dayOfWeek小於當前日期的dayOfWeek,則WEEK_OF_YEAR需要推遲一周
        boolean weekLater = false;
        if (dayOfWeek < currentDayOfWeek) {
            weekLater = true;
        } else if (dayOfWeek == currentDayOfWeek) {
            //當輸入條件與當前日期的dayOfWeek相等時，如果輸入條件中的
            //hourOfDay小於當前日期的
            //currentHour，則WEEK_OF_YEAR需要推遲一周    
            if (hourOfDay < currentHour) {
                weekLater = true;
            } else if (hourOfDay == currentHour) {
                 //當輸入條件與當前日期的dayOfWeek, hourOfDay相等時，
                 //如果輸入條件中的minuteOfHour小於當前日期的
                //currentMinute，則WEEK_OF_YEAR需要推遲一周
                if (minuteOfHour < currentMinute) {
                    weekLater = true;
                } else if (minuteOfHour == currentSecond) {
                     //當輸入條件與當前日期的dayOfWeek, hourOfDay， 
                     //minuteOfHour相等時，如果輸入條件中的
                    //secondOfMinite小於當前日期的currentSecond，
                    //則WEEK_OF_YEAR需要推遲一周
                    if (secondOfMinite < currentSecond) {
                        weekLater = true;
                    }
                }
            }
        }
        if (weekLater) {
            //設置當前日期中的WEEK_OF_YEAR為當前周推遲一周
            currentDate.set(Calendar.WEEK_OF_YEAR, currentWeekOfYear + 1);
        }
        // 設置當前日期中的DAY_OF_WEEK,HOUR_OF_DAY,MINUTE,SECOND為輸入條件中的值。
        currentDate.set(Calendar.DAY_OF_WEEK, dayOfWeek);
        currentDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
        currentDate.set(Calendar.MINUTE, minuteOfHour);
        currentDate.set(Calendar.SECOND, secondOfMinite);
        return currentDate;

    }

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

        ScheduledExceutorTest2 test = new ScheduledExceutorTest2("job1");
        //獲取當前時間
        Calendar currentDate = Calendar.getInstance();
        long currentDateLong = currentDate.getTime().getTime();
        System.out.println("Current Date = " + currentDate.getTime().toString());
        //計算滿足條件的最近一次執行時間
        Calendar earliestDate = test
                .getEarliestDate(currentDate, 3, 16, 38, 10);
        long earliestDateLong = earliestDate.getTime().getTime();
        System.out.println("Earliest Date = "
                + earliestDate.getTime().toString());
        //計算從當前時間到最近一次執行時間的時間間隔
        long delay = earliestDateLong - currentDateLong;
        //計算執行周期為一星期
        long period = 7 * 24 * 60 * 60 * 1000;
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        //從現在開始delay毫秒之後，每隔一星期執行一次job1
        service.scheduleAtFixedRate(test, delay, period,
                TimeUnit.MILLISECONDS);
    }
}

/**
輸出結果:
Current Date = Wed Feb 02 17:32:01 CST 2011
Earliest Date = Tue Feb 8 16:38:10 CST 2011
Date = Tue Feb 8 16:38:10 CST 2011, execute job1
Date = Tue Feb 15 16:38:10 CST 2011, execute job1
*/

上述代碼實現了每星期二 16:38:10 調度任務的功能。其核心在於根據當前時間推算出最近一個星期二 16:38:10 的絕對時間，然後計算與當前時間的時間差，作為調用 ScheduledExceutor 函數的參數。計算最近時間要用到 java.util.calendar 的功能。首先需要解釋 calendar 的一些設計思想。Calendar 有以下幾種唯一標識一個日期的組合方式：

引用

YEAR + MONTH + DAY_OF_MONTH

YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK

YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK

YEAR + DAY_OF_YEAR

YEAR + DAY_OF_WEEK + WEEK_OF_YEAR

上述組合分別加上 HOUROFDAY + MINUTE + SECOND 即為一個完整的時間標識。

上述DEMO採用了最後一種組合方式。輸入為 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 以及當前日期 , 輸出為一個滿足 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 並且距離當前日期最近的未來日期。計算的原則是從輸入的 DAY_OF_WEEK 開始比較，如果小於當前日期的 DAY_OF_WEEK，則需要向 WEEK_OF_YEAR 進一， 即將當前日期中的 WEEK_OF_YEAR 加一併覆蓋舊值；如果等於當前的 DAY_OF_WEEK, 則繼續比較 HOUR_OF_DAY；如果大於當前的 DAY_OF_WEEK，則直接調用 java.util.calenda 的 calendar.set(field, value) 函數將當前日期的 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 賦值為輸入值，依次類推，直到比較至 SECOND。我們可以根據輸入需求選擇不同的組合方式來計算最近執行時間。

用上述方法實現該任務調度比較繁瑣，期待需要一個更加完善的任務調度工具來解決這些複雜的調度問題。幸運的是，開源工具包 Quartz 在這方面展現了強大的能力。

Quartz

OpenSymphony開源組織在Job scheduling領域又一個開源項目，它可以與J2EE與J2SE應用程式相結合也可以單獨使用。Quartz可以用來創建簡單或為運行十個，百個，甚至是好幾萬個Jobs這樣複雜的程式。

先來看一個例子吧：

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 類似MISFIREINSTRUCTIONRESCHEDULENOWWITHEXISTINGREPEAT_COUNT，區別在於會忽略已經MisFire的任務。
• MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT 在下一次調度時間點，重新開始調度任務，包括的MisFire的。
• MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT 類似於MISFIREINSTRUCTIONRESCHEDULENEXTWITHEXISTINGCOUNT，區別在於會忽略已經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表達式

• 星號()：可用在所有欄位中，表示對應時間域的每一個時刻，例如， 在分鐘欄位時，表示“每分鐘”；
• 問號（?）：該字元只在日期和星期欄位中使用，它通常指定為“無意義的值”，相當於點位符；
• 減號(-)：表達一個範圍，如在小時欄位中使用“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表達式對特殊字元的大小寫不敏感，對代表星期的縮寫英文大小寫也不敏感。一些例子：

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
• 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

三、Quartz 集成 Spring

開發一個job類，普通java類，需要有一個執行的方法：

package com.tgb.lk.demo.quartz;
import java.util.Date;
public class MyJob {
        public void work() {
            System.out.println("date:" + new Date().toString());
        }
}

把類放到spring容器中，可以使用配置也可以使用註解：

<bean id="myJob" class="com.tgb.lk.demo.quartz.MyJob" />

配置jobDetail，指定job對象：

<!-- 配置jobDetail，指定job對象 -->
    <bean id="accountJobDetail"   class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject">
            <ref bean="accountJob" />
        </property>
        <property name="targetMethod">
            <value>work</value>
        </property>
    </bean>

配置一個trigger，需要指定一個cron表達式，指定任務的執行時機：

<!-- accountTrigger 的配置 -->
        <bean id="accountTrigger"
            class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
            <property name="jobDetail">
                <ref bean="accountJobDetail" />
            </property>
            <property name="cronExpression">
                <value>0/3 * * * * ?</value>
            </property>
        </bean>

配置調度工廠：

<!-- 啟動觸發器的配置開始 -->
    <bean name="startQuertz" lazy-init="false"