幾種任務調度的Java實現(xiàn)方法與比較

yespon 2017-03-07

展開全文

前言

任務調度是指基于給定時間點，給定時間間隔或者給定執(zhí)行次數(shù)自動執(zhí)行任務。本文由淺入深介紹四種任務調度的 Java 實現(xiàn)：
（1）Timer
（2）ScheduledExecutor
（3）開源工具包 Quartz
（4）開源工具包 JCronTab
此外，為結合實現(xiàn)復雜的任務調度，本文還將介紹 Calendar 的一些使用方法。

Timer

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

使用 Timer 進行任務調度：

package com.king.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;        // 從現(xiàn)在開始 1 秒鐘之后，每隔 1 秒鐘執(zhí)行一次 job1        timer.schedule(new TimerTest('job1'), delay1, period1);        long delay2 = 2 * 1000;        long period2 = 2000;        // 從現(xiàn)在開始 2 秒鐘之后，每隔 2 秒鐘執(zhí)行一次 job2        timer.schedule(new TimerTest('job2'), delay2, period2);    }}Output: execute job1 execute job1 execute job2 execute job1 execute job1 execute job2

使用 Timer 實現(xiàn)任務調度的核心類是 Timer 和 TimerTask。其中 Timer 負責設定 TimerTask 的起始與間隔執(zhí)行時間。使用者只需要創(chuàng)建一個 TimerTask 的繼承類，實現(xiàn)自己的 run 方法，然后將其丟給 Timer 去執(zhí)行即可。

Timer 的設計核心是一個 TaskList 和一個 TaskThread。Timer 將接收到的任務丟到自己的 TaskList 中，TaskList 按照 Task 的最初執(zhí)行時間進行排序。TimerThread 在創(chuàng)建 Timer 時會啟動成為一個守護線程。這個線程會輪詢所有任務，找到一個最近要執(zhí)行的任務，然后休眠，當?shù)竭_最近要執(zhí)行任務的開始時間點，TimerThread 被喚醒并執(zhí)行該任務。之后 TimerThread 更新最近一個要執(zhí)行的任務，繼續(xù)休眠。

Timer的主要方法：

// 安排在指定的時間執(zhí)行void schedule(TimerTask task, Date time)// 安排在指定的時間開始以重復的延時執(zhí)行void schedule(TimerTask task, Date firstTime, long period)// 安排在指定的延遲后執(zhí)行void schedule(TimerTask task, long delay)// 安排在指定的延遲后開始以重復的延時執(zhí)行void schedule(TimerTask task, long delay, long period)// 安排在指定的時間開始以重復的速率執(zhí)行void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)// 安排在指定的延遲后開始以重復的速率執(zhí)行void scheduleAtFixedRate(TimerTask task, long delay, long period)

注：重復的延時和重復的速率的區(qū)別在于，前者是在前一個任務的執(zhí)行結束后間隔period時間再開始下一次執(zhí)行；而scheduleAtFixedRate則是會盡量按照任務的初始時間來按照間隔period時間執(zhí)行。如果一次任務執(zhí)行由于某些原因被延遲了，用schedule()調度的后續(xù)任務同樣也會被延遲，而用scheduleAtFixedRate()則會快速的開始兩次或者多次執(zhí)行，使后續(xù)任務的執(zhí)行時間能夠趕上來。

Timer 的優(yōu)點在于簡單易用，但由于所有任務都是由同一個線程來調度，因此所有任務都是串行執(zhí)行的，同一時間只能有一個任務在執(zhí)行，前一個任務的延遲或異常都將會影響到之后的任務。

ScheduledExecutor

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

使用 ScheduledExecutor 進行任務調度：

package com.king.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;        // 從現(xiàn)在開始1秒鐘之后，每隔1秒鐘執(zhí)行一次job1        service.scheduleAtFixedRate(new ScheduledExecutorTest('job1'), initialDelay1, period1, TimeUnit.SECONDS);        long initialDelay2 = 1;        long delay2 = 1;        // 從現(xiàn)在開始2秒鐘之后，每隔2秒鐘執(zhí)行一次job2        service.scheduleWithFixedDelay(new ScheduledExecutorTest('job2'), initialDelay2,delay2, TimeUnit.SECONDS);    }}Output:execute job1execute job1execute job2execute job1execute job1execute job2

上述代碼，展示了 ScheduledExecutorService 中兩種最常用的調度方法 ScheduleAtFixedRate 和 ScheduleWithFixedDelay。

ScheduledThreadPoolExecutor的主要方法：

// 在指定的延遲后執(zhí)行ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit)// 在指定的延遲后執(zhí)行ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit)// 在指定的延遲后以固定速率執(zhí)行(類似Timer.scheduleAtFixedRate())ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)// 在指定的延遲后以固定間隔執(zhí)行(類似Timer.schedule())ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

ScheduleAtFixedRate：每次執(zhí)行時間為上一次任務開始起向后推一個時間間隔，即每次執(zhí)行時間為 :initialDelay, initialDelay+period, initialDelay+2*period, …；

ScheduleWithFixedDelay：每次執(zhí)行時間為上一次任務結束起向后推一個時間間隔，即每次執(zhí)行時間為：initialDelay, initialDelay+executeTime+delay, initialDelay+2executeTime+2delay；

由此可見，ScheduleAtFixedRate 是基于固定時間間隔進行任務調度，ScheduleWithFixedDelay 取決于每次任務執(zhí)行的時間長短，是基于不固定時間間隔進行任務調度。

使用Timer與ScheduledExecutor比較

（1）Timer對調度的支持是基于絕對時間的，因此任務對系統(tǒng)時間的改變是敏感的；而ScheduledThreadPoolExecutor支持相對時間。
（2）Timer使用單線程方式來執(zhí)行所有的TimerTask，如果某個TimerTask很耗時則會影響到其他TimerTask的執(zhí)行；而ScheduledThreadPoolExecutor則可以構造一個固定大小的線程池來執(zhí)行任務。
（3）Timer不會捕獲由TimerTask拋出的未檢查異常，故當有異常拋出時，Timer會終止，導致未執(zhí)行完的TimerTask不再執(zhí)行，新的TimerTask也不能被調度；ScheduledThreadPoolExecutor對這個問題進行了妥善的處理，不會影響其他任務的執(zhí)行。

用 ScheduledExecutor 和 Calendar 實現(xiàn)復雜任務調度

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

使用 ScheduledExcetuor 和 Calendar 進行任務調度：

package com.king.scheduler;import java.util.Calendar;import java.util.Date;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;public class ScheduledExecutorCalendarTest implements Runnable {    private String jobName = '';    public ScheduledExecutorCalendarTest(String jobName) {        super();        this.jobName = jobName;    }    @Override    public void run() {        System.out.println('Date = ' + new Date() + ', execute ' + jobName);    }    /**     * 計算從當前時間currentDate開始，滿足條件dayOfWeek, hourOfDay,     * minuteOfHour, secondOfMinute的最近時間     * @return     */    public Calendar getEarliestDate(Calendar currentDate, int dayOfWeek, int hourOfDay, int minuteOfHour, int secondOfMinute) {        //計算當前時間的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相等時，如果輸入條件中的                    //secondOfMinute小于當前日期的currentSecond，                    //則WEEK_OF_YEAR需要推遲一周                    if (secondOfMinute < 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, secondOfMinute);        return currentDate;    }    public static void main(String[] args) throws Exception {        ScheduledExecutorCalendarTest test = new ScheduledExecutorCalendarTest('job1');        //獲取當前時間        Calendar currentDate = Calendar.getInstance();        long currentDateLong = currentDate.getTime().getTime();        System.out.println('Current Date = ' + currentDate.getTime().toString());        //計算滿足條件的最近一次執(zhí)行時間        Calendar earliestDate = test.getEarliestDate(currentDate, 3, 16, 38, 10);        long earliestDateLong = earliestDate.getTime().getTime();        System.out.println('Earliest Date = ' + earliestDate.getTime().toString());        //計算從當前時間到最近一次執(zhí)行時間的時間間隔        long delay = earliestDateLong - currentDateLong;        //計算執(zhí)行周期為一星期        long period = 7 * 24 * 60 * 60 * 1000;        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);        //從現(xiàn)在開始delay毫秒之后，每隔一星期執(zhí)行一次job1        service.scheduleAtFixedRate(test, delay, period, TimeUnit.MILLISECONDS);    }}Output:Current Date = Wed Feb 02 17:32:01 CST 2011Earliest Date = Tue Feb 8 16:38:10 CST 2011Date = Tue Feb 8 16:38:10 CST 2011, execute job1Date = Tue Feb 15 16:38:10 CST 2011, execute job1

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

YEAR + MONTH + DAY_OF_MONTHYEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEKYEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEKYEAR + DAY_OF_YEARYEAR + DAY_OF_WEEK + WEEK_OF_YEAR

上述組合分別加上 HOUR_OF_DAY + MINUTE + SECOND 即為一個完整的時間標識。本例采用了最后一種組合方式。輸入為 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, 則繼續(xù)比較 HOUR_OF_DAY；如果大于當前的 DAY_OF_WEEK，則直接調用 java.util.calenda 的 calendar.set(field, value) 函數(shù)將當前日期的 DAY_OF_WEEK, HOUR_OF_DAY, MINUTE, SECOND 賦值為輸入值，依次類推，直到比較至 SECOND。讀者可以根據(jù)輸入需求選擇不同的組合方式來計算最近執(zhí)行時間。

可以看出，用上述方法實現(xiàn)該任務調度比較麻煩，這就需要一個更加完善的任務調度框架來解決這些復雜的調度問題。幸運的是，開源工具包 Quartz 與 JCronTab 提供了這方面強大的支持。

Quartz

Quartz 可以滿足更多更復雜的調度需求，首先讓我們看看如何用 Quartz 實現(xiàn)每星期二 16:38:10 的調度安排。

使用 Quartz 進行任務調度：

public class QuartzTest implements Job {    //該方法實現(xiàn)需要執(zhí)行的任務    @Override    public void execute(JobExecutionContext arg0) throws JobExecutionException {        System.out.println('Generating report - '                + arg0.getJobDetail().getJobDataMap().get('name') + ', group ='                + arg0.getJobDetail().getJobDataMap().get('group') + ', type ='                + arg0.getJobDetail().getJobDataMap().get('type'));        System.out.println(new Date().toString());    }    public static void main(String[] args) throws SchedulerException {        // 創(chuàng)建一個Scheduler        SchedulerFactory schedulerFactory = new StdSchedulerFactory();        Scheduler scheduler = schedulerFactory.getScheduler();        // 創(chuàng)建一個JobDetail，指明name，groupName，以及具體的Job類名，        // 該Job負責定義需要執(zhí)行任務        JobDetail jobDetail = JobBuilder.newJob(QuartzTest.class).withIdentity('Quartz Job1', 'Quartz Group1').build();        jobDetail.getJobDataMap().put('type', 'Quartz');        // 創(chuàng)建一個每周觸發(fā)的Trigger，指明星期幾幾點幾分執(zhí)行        Trigger trigger = TriggerBuilder.newTrigger().withIdentity('Quartz Trigger1', 'Quartz Group1').startNow().build();        scheduler.scheduleJob(jobDetail, trigger);        scheduler.start();    }}

非常簡潔地實現(xiàn)了一個上述復雜的任務調度。Quartz 設計的核心類包括 Scheduler, Job 以及 Trigger。其中，Job 負責定義需要執(zhí)行的任務，Trigger 負責設置調度策略，Scheduler 將二者組裝在一起，并觸發(fā)任務開始執(zhí)行。

Job

使用者只需要創(chuàng)建一個 Job 的繼承類，實現(xiàn) execute 方法。JobDetail 負責封裝 Job 以及 Job 的屬性，并將其提供給 Scheduler 作為參數(shù)。每次 Scheduler 執(zhí)行任務時，首先會創(chuàng)建一個 Job 的實例，然后再調用 execute 方法執(zhí)行。Quartz 沒有為 Job 設計帶參數(shù)的構造函數(shù)，因此需要通過額外的 JobDataMap 來存儲 Job 的屬性。JobDataMap 可以存儲任意數(shù)量的 Key，Value 對，例如：

為 JobDataMap 賦值：

jobDetail.getJobDataMap().put('myDescription', 'my job description');jobDetail.getJobDataMap().put('myValue', 1998);ArrayList list = new ArrayList();list.add('item1');jobDetail.getJobDataMap().put('myArray', list);

獲取 JobDataMap 的值：

public class JobDataMapTest implements Job {    @Override    public void execute(JobExecutionContext context) throws JobExecutionException {        //從context中獲取instName，groupName以及dataMap        String instName = context.getJobDetail().getName();        String groupName = context.getJobDetail().getGroup();        JobDataMap dataMap = context.getJobDetail().getJobDataMap();        //從dataMap中獲取myDescription，myValue以及myArray        String myDescription = dataMap.getString('myDescription');        int myValue = dataMap.getInt('myValue');        ArrayList myArray = (ArrayListlt;Strin>) dataMap.get('myArray');        System.out.println('Instance =' + instName + ', group = ' + groupName                + ', description = ' + myDescription + ', value =' + myValue                + ', array item0 = ' + myArray.get(0));    }}Output：Instance = myJob, group = myJobGroup,description = my job description,value =1998, array item0 = item1

Trigger

Trigger 的作用是設置調度策略。Quartz 設計了多種類型的 Trigger，其中最常用的是 SimpleTrigger 和 CronTrigger。

SimpleTrigger：適用于在某一特定的時間執(zhí)行一次，或者在某一特定的時間以某一特定時間間隔執(zhí)行多次。上述功能決定了 SimpleTrigger 的參數(shù)包括 start-time, end-time, repeat count, 以及 repeat interval

Repeat count ：取值為大于或等于零的整數(shù)，或者常量 SimpleTrigger.REPEAT_INDEFINITELY。
Repeat interval ：取值為大于或等于零的長整型。當 Repeat interval 取值為零并且 Repeat count 取值大于零時，將會觸發(fā)任務的并發(fā)執(zhí)行。
Start-time 與 end-time：取值為 java.util.Date。當同時指定 end-time 與 repeat count 時，優(yōu)先考慮 end-time。一般地，可以指定 end-time，并設定 repeat count 為 REPEAT_INDEFINITELY。

以下是 SimpleTrigger 的構造方法：

public SimpleTrigger(String name,                       String group,                       Date startTime,                       Date endTime,                       int repeatCount,                       long repeatInterval)

CronTrigger：其用途更廣，相比基于特定時間間隔進行調度安排的 SimpleTrigger，CronTrigger 主要適用于基于日歷的調度安排。例如：每星期二的 16:38:10 執(zhí)行，每月一號執(zhí)行，以及更復雜的調度安排等。

CronTrigger 同樣需要指定 start-time 和 end-time，其核心在于 Cron 表達式，由七個字段組成：

SecondsMinutesHoursDay-of-MonthMonthDay-of-WeekYear (Optional field)

舉例如下：

創(chuàng)建一個每三小時執(zhí)行的 CronTrigger，且從每小時的整點開始執(zhí)行：0 0 0/3 * * ?
創(chuàng)建一個每十分鐘執(zhí)行的 CronTrigger，且從每小時的第三分鐘開始執(zhí)行：0 3/10 * * * ?
創(chuàng)建一個每周一，周二，周三，周六的晚上 20:00 到 23:00，每半小時執(zhí)行一次的 CronTrigger：0 0/30 20-23 ? * MON-WED,SAT
創(chuàng)建一個每月最后一個周四，中午 11:30-14:30，每小時執(zhí)行一次的 trigger：0 30 11-14/1 ? * 5L

解釋一下上述例子中各符號的含義：
首先所有字段都有自己特定的取值，例如，Seconds 和 Minutes 取值為 0 到 59，Hours 取值為 0 到 23，Day-of-Month 取值為 0-31, Month 取值為 0-11，或者 JAN，F(xiàn)EB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC，Days-of-Week 取值為 1-7 或者 SUN, MON, TUE, WED, THU, FRI, SAT。每個字段可以取單個值，多個值，或一個范圍，例如 Day-of-Week 可取值為“MON，TUE，SAT”,“MON-FRI”或者“TUE-THU，SUN”。

*：表示該字段可接受任何可能取值。例如 Month 字段賦值 * 表示每個月，Day-of-Week 字段賦值 * 表示一周的每天。
/：表示開始時刻與間隔時段。例如 Minutes 字段賦值 2/10 表示在一個小時內每 20 分鐘執(zhí)行一次，從第 2 分鐘開始。
：僅適用于 Day-of-Month 和 Day-of-Week。? 表示對該字段不指定特定值。適用于需要對這兩個字段中的其中一個指定值，而對另一個不指定值的情況。一般情況下，這兩個字段只需對一個賦值。
L：僅適用于 Day-of-Month 和 Day-of-Week。L 用于 Day-of-Month 表示該月最后一天。L 單獨用于 Day-of-Week 表示周六，否則表示一個月最后一個星期幾，例如 5L 或者 THUL 表示該月最后一個星期四。
W：僅適用于 Day-of-Month，表示離指定日期最近的一個工作日，例如 Day-of-Month 賦值為 10W 表示該月離 10 號最近的一個工作日
#：僅適用于 Day-of-Week，表示該月第 XXX 個星期幾。例如 Day-of-Week 賦值為 5#2 或者 THU#2，表示該月第二個星期四。

Job 與 Trigger 的松耦合設計是 Quartz 的一大特點，其優(yōu)點在于同一個 Job 可以綁定多個不同的 Trigger，同一個 Trigger 也可以調度多個 Job，靈活性很強。

Listener

除了上述基本的調度功能，Quartz 還提供了 listener 的功能。主要包含三種 listener：JobListener，TriggerListener 以及 SchedulerListener。當系統(tǒng)發(fā)生故障，相關人員需要被通知時，Listener 便能發(fā)揮它的作用。最常見的情況是，當任務被執(zhí)行時，系統(tǒng)發(fā)生故障，Listener 監(jiān)聽到錯誤，立即發(fā)送郵件給管理員。下面給出 JobListener 的實例：

JobListener 的實現(xiàn)：

public class MyListener implements JobListener {    @Override    public String getName() {        return 'My Listener';    }    @Override    public void jobToBeExecuted(JobExecutionContext context) {        System.out.println('job to be executed');    }    @Override    public void jobExecutionVetoed(JobExecutionContext context) {        System.out.println('job execution vetoed');    }    @Override    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {        if(jobException != null){            try {                //停止Scheduler                context.getScheduler().shutdown();                System.out.println('Error occurs when executing jobs, shut down the scheduler ');                // 給管理員發(fā)送郵件…            } catch (SchedulerException e) {                e.printStackTrace();            }        }    }}

使用者只需要創(chuàng)建一個 JobListener 的繼承類，重載需要觸發(fā)的方法即可。當然，需要將 listener 的實現(xiàn)類注冊到 Scheduler 和 JobDetail 中：

sched.addJobListener(new MyListener());jobDetail.addJobListener('My Listener'); // listener 的名字

使用者也可以將 listener 注冊為全局 listener，這樣便可以監(jiān)聽 scheduler 中注冊的所有任務 :

sched.addGlobalJobListener(new MyListener());

JobStores

Quartz 的另一顯著優(yōu)點在于持久化，即將任務調度的相關數(shù)據(jù)保存下來。這樣，當系統(tǒng)重啟后，任務被調度的狀態(tài)依然存在于系統(tǒng)中，不會丟失。默認情況下，Quartz 采用的是 org.quartz.simpl.RAMJobStore，在這種情況下，數(shù)據(jù)僅能保存在內存中，系統(tǒng)重啟后會全部丟失。若想持久化數(shù)據(jù)，需要采用 org.quartz.simpl.JDBCJobStoreTX。

實現(xiàn)持久化的第一步，是要創(chuàng)建 Quartz 持久化所需要的表格。在 Quartz 的發(fā)布包 docs/dbTables 中可以找到相應的表格創(chuàng)建腳本。Quartz 支持目前大部分流行的數(shù)據(jù)庫。本文以 DB2 為例，所需要的腳本為 tables_db2.sql。

第二步，配置數(shù)據(jù)源。數(shù)據(jù)源與其它所有配置，例如 ThreadPool，均放在 quartz.properties 里：
Quartz 配置文件

 # Configure ThreadPool org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool org.quartz.threadPool.threadCount =  5 org.quartz.threadPool.threadPriority = 4  # Configure Datasources org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate org.quartz.jobStore.dataSource = db2DS org.quartz.jobStore.tablePrefix = QRTZ_  org.quartz.dataSource.db2DS.driver = com.ibm.db2.jcc.DB2Driver org.quartz.dataSource.db2DS.URL = jdbc:db2://localhost:50001/sched org.quartz.dataSource.db2DS.user = quartz org.quartz.dataSource.db2DS.password = passw0rd org.quartz.dataSource.db2DS.maxConnections = 5

使用時只需要將 quatz.properties 放在 classpath 下面，不用更改一行代碼，再次運行之前的任務調度實例，trigger、job 等信息便會被記錄在數(shù)據(jù)庫中。

JCronTab

習慣使用 unix/linux 的開發(fā)人員應該對 crontab 都不陌生。Crontab 是一個非常方便的用于 unix/linux 系統(tǒng)的任務調度命令。JCronTab 則是一款完全按照 crontab 語法編寫的 java 任務調度工具。

首先簡單介紹一下 crontab 的語法，與上面介紹的 Quartz 非常相似，但更加簡潔 , 集中了最常用的語法。主要由六個字段組成（括弧中標識了每個字段的取值范圍）：

Minutes （0-59）
Hours （0-23）
Day-of-Month （1-31）
Month （1-12/JAN-DEC）
Day-of-Week （0-6/SUN-SAT）
Command

與 Quartz 相比，省略了 Seconds 與 Year，多了一個 command 字段，即為將要被調度的命令。JCronTab 中也包含符號“*”與“/”, 其含義與 Quartz 相同。
舉例如下：

每天 12 點到 15 點 , 每隔 1 小時執(zhí)行一次 Date 命令：0 12-15/1 * * * Date
每月 2 號凌晨 1 點發(fā)一封信給 zhjingbj@cn.ibm.com：0 1 2 * * mail -s “good” zhjingbj@cn.ibm.com
每周一，周二，周三，周六的晚上 20:00 到 23:00，每半小時打印“normal”：0/30 20-23 * * MON-WED,SAT echo “normal”

JCronTab 借鑒了 crontab 的語法，其區(qū)別在于 command 不再是 unix/linux 的命令，而是一個 Java 類。如果該類帶參數(shù)，例如“com.ibm.scheduler.JCronTask2#run”，則定期執(zhí)行 run 方法；如果該類不帶參數(shù)，則默認執(zhí)行 main 方法。此外，還可以傳參數(shù)給 main 方法或者構造函數(shù)，例如“com.ibm.scheduler.JCronTask2#run Hello World“表示傳兩個參數(shù) Hello 和 World 給構造函數(shù)。

JCronTab 與 Quartz 相比，其優(yōu)點在于，第一，支持多種任務調度的持久化方法，包括普通文件、數(shù)據(jù)庫以及 XML 文件進行持久化；第二，JCronTab 能夠非常方便地與 Web 應用服務器相結合，任務調度可以隨 Web 應用服務器的啟動自動啟動；第三，JCronTab 還內置了發(fā)郵件功能，可以將任務執(zhí)行結果方便地發(fā)送給需要被通知的人。

JCronTab 與 Web 應用服務器的結合非常簡單，只需要在 Web 應用程序的 web.xml 中添加如下行：

 <servlet>   <servlet-name>LoadOnStartupServletservlet-name>   <servlet-class>org.jcrontab.web.loadCrontabServletservlet-class>   <init-param> <param-name>PROPERTIES_FILEparam-name> <param-value>D:/Scheduler/src/jcrontab.propertiesparam-value>   init-param>   <load-on-startup>1load-on-startup> servlet>  <servlet-mapping>   <servlet-name>LoadOnStartupServletservlet-name> <url-pattern>/Startupurl-pattern> servlet-mapping>

需要注意兩點：第一，必須指定 servlet-class 為 org.jcrontab.web.loadCrontabServlet，因為它是整個任務調度的入口；第二，必須指定一個參數(shù)為 PROPERTIES_FILE，才能被 loadCrontabServlet 識別。

接下來，需要撰寫 D:/Scheduler/src/jcrontab.properties 的內容，其內容根據(jù)需求的不同而改變。

當采用普通文件持久化時，jcrontab.properties 的內容主要包括：

org.jcrontab.data.file = D:/Scheduler/src/crontaborg.jcrontab.data.datasource = org.jcrontab.data.FileSource

其中數(shù)據(jù)來源 org.jcrontab.data.datasource 被描述為普通文件，即 org.jcrontab.data.FileSource。具體的文件即 org.jcrontab.data.file 指明為 D:/Scheduler/src/crontab。

Crontab 描述了任務的調度安排：

*/2 * * * * com.ibm.scheduler.JCronTask1 * * * * * com.ibm.scheduler.JCronTask2#run Hello World

其中包含了兩條任務的調度，分別是每兩分鐘執(zhí)行一次 JCronTask1 的 main 方法，每一分鐘執(zhí)行一次 JCronTask2 的 run 方法。

package com.king.scheduler;import java.util.Date;public class JCronTask1 {    private static int count = 0;    public static void main(String[] args) {        System.out.println('--------------Task1-----------------');        System.out.println('Current Time = ' + new Date() + ', Count = ' + count++);    }}package com.king.scheduler;import java.util.Date;public class JCronTask2 implements Runnable {    private static int count = 0;    private static String[] args;    public JCronTask2(String[] args) {        System.out.println('--------------Task2-----------------');        System.out.println('Current Time = ' + new Date() + ', Count = ' + count++);        JCronTask2.args = args;    }    @Override    public void run() {        System.out.println('enter into run method');        if (args != null && args.length > 0) {            for (int i = 0; i < args.length; i++) {                            System.out.print('This is arg ' + i + ' ' + args[i] + '\n');            }        }    }}

到此為止，基于普通文件持久化的 JCronTab 的實例就全部配置好了。啟動 Web 應用服務器，便可以看到任務調度的輸出結果。

 --------------Task2----------------- Current Time = Tue Feb 15 09:22:00 CST 2011, Count = 0 enter into run method This is arg 0 Hello This is arg 1 World --------------Task1----------------- Current Time = Tue Feb 15 09:22:00 CST 2011, Count = 0 --------------Task2----------------- Current Time = Tue Feb 15 09:23:00 CST 2011, Count = 1 enter into run method This is arg 0 Hello This is arg 1 World --------------Task2----------------- Current Time = Tue Feb 15 09:24:00 CST 2011, Count = 2 enter into run method This is arg 0 Hello This is arg 1 World --------------Task1----------------- Current Time = Tue Feb 15 09:24:00 CST 2011, Count = 1

通過修改 jcrontab.properties 中 datasource，可以選擇采用數(shù)據(jù)庫或 xml 文件持久化，感興趣的讀者可以參考進階學習 JCronTab。
此外，JCronTab 還內置了發(fā)郵件功能，可以將任務執(zhí)行結果方便地發(fā)送給需要被通知的人。其配置非常簡單，只需要在 jcontab.properties 中添加幾行配置即可：

 org.jcrontab.sendMail.to= Ther email you want to send to org.jcrontab.sendMail.from=The email you want to send from org.jcrontab.sendMail.smtp.host=smtp server org.jcrontab.sendMail.smtp.user=smtp username org.jcrontab.sendMail.smtp.password=smtp password