定時任務,是指定一個未來的時間範圍執行一定任務的功能。在當前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); } } /**
輸出結果:
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 job1execute job1execute job2execute job1execute job1execute 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 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*/
上述代碼實現了每星期二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相關的builderimport static org.quartz.JobBuilder.*;//trigger相關的builderimport static org.quartz.TriggerBuilder.*;import static org.quartz.SimpleScheduleBuilder.*;import static org.quartz.CronScheduleBuilder.*;import static org.quartz.DailyTimeIntervalScheduleBuilder.*;import static org.quartz.CalendarIntervalScheduleBuilder.*;//日期相關的builderimport 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:00java.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//定義一個TriggerTrigger 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 屬性的都是同理。
例子:
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 | , - * ? / LWC |
| 5 | 月份 | 1-12 | , - * / |
| 6 | 星期 | 1-7 | , - * ? / LC # |
| 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
•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 = DefaultQuartzSchedulerorg.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPoolorg.quartz.threadPool.threadCount = 10 org.quartz.threadPool.threadPriority = 5org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = trueorg.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" />
配置jobDetail,指定job對象:
<!-- 配置jobDetail,指定job對象--> <bean id="accountJobDetail"> <property name="targetObject"> <ref bean="accountJob" /> </property> <property name="targetMethod"> <value>work</value> </property> </bean>
配置一個trigger,需要指定一個cron表達式,指定任務的執行時機:
<!-- accountTrigger 的配置--> <bean id="accountTrigger" > <property name="jobDetail"> <ref bean="accountJobDetail" /> </property> <property name="cronExpression"> <value>0/3 * * * * ?</value> </property> </bean>
配置調度工廠:
<!-- 啟動觸發器的配置開始--> <bean name="startQuertz" lazy-init="false" autowire="no" > <property name="triggers"> <list> <ref bean="myJobTrigger" /> </list> </property> </bean> <!-- 啟動觸發器的配置結束-->
項目啟動,定時器開始執行。
四、分析不同定時任務優缺點,尋找一種符合你項目需求的定時任務Timer管理延時任務的缺陷
以前在項目中也經常使用定時器,比如每隔一段時間清理項目中的一些垃圾文件,每隔一段時間進行日誌清理;然而Timer是存在一些缺陷的,因為Timer在執行定時任務時只會創建一個線程,所以如果存在多個任務,且任務時間過長,超過了兩個任務的間隔時間,會發生一些缺陷
Timer當任務拋出異常時的缺陷
如果TimerTask拋出RuntimeException,Timer會停止所有任務的運行
Timer執行週期任務時依賴系統時間
Timer執行週期任務時依賴系統時間,如果當前系統時間發生變化會出現一些執行上的變化,ScheduledExecutorService基於時間的延遲,不會由於系統時間的改變發生執行變化。
對異常的處理
Quartz的某次執行任務過程中拋出異常,不影響下一次任務的執行,當下一次執行時間到來時,定時器會再次執行任務;而TimerTask則不同,一旦某個任務在執行過程中拋出異常,則整個定時器生命週期就結束,以後永遠不會再執行定時器任務。
精確到和功能
Quartz每次執行任務都創建一個新的任務類對象,而TimerTask則每次使用同一個任務類對象。 Quartz可以通過cron表達式精確到特定時間執行,而TimerTask不能。 Quartz擁有TimerTask所有的功能,而TimerTask則沒有上述,基本說明了在以後的開發中盡可能使用ScheduledExecutorService(JDK1.5以後)替代Timer。
五、cron 在線表達式生成器http://cron.qqe2.com/附錄cron 表達式
cron表達式用於配置cronTrigger的實例。 cron表達式實際上是由七個子表達式組成。這些表達式之間用空格分隔。
•Seconds (秒)
•Minutes(分)
•Hours(小時)
•Day-of-Month (天)
•Month(月)
•Day-of-Week (週)
•Year(年)
例:"0 0 12 ? * WED” 意思是:每個星期三的中午12點執行。個別子表達式可以包含範圍或者列表。例如:上面例子中的WED可以換成"MON-FRI","MON,WED,FRI",甚至"MON-WED,SAT"。子表達式範圍:
•Seconds (0~59)
•Minutes (0~59)
•Hours (0~23)
•Day-of-Month (1~31,但是要注意有些月份沒有31天)
•Month (0~11,或者"JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV,DEC")
•Day-of-Week (1~7,1=SUN 或者"SUN, MON, TUE, WED, THU, FRI, SAT”)
•Year (1970~2099)
Cron表達式的格式:秒分時日月週年(可選)。
字段名| 允許的值| 允許的特殊字符------- | ------ | ------ | ------ 秒| 0-59 | , - * / 分| 0-59 | , - * / 小時| 0-23 | , - * / 日| 1-31 | , - * ? / LWC 月| 1-12 or JAN-DEC | , - * / 週幾| 1-7 or SUN-SAT | , - * ? / LC # 年(可選字段) | empty 1970-2099 | , - * /
字符含義:
•*:代表所有可能的值。因此,“*”在Month中表示每個月,在Day-of-Month中表示每天,在Hours表示每小時
•-:表示指定範圍。
•,:表示列出枚舉值。例如:在Minutes子表達式中,“5,20”表示在5分鐘和20分鐘觸發。
•/:被用於指定增量。例如:在Minutes子表達式中,“0/15”表示從0分鐘開始,每15分鐘執行一次。 "3/20"表示從第三分鐘開始,每20分鐘執行一次。和"3,23,43"(表示第3,23,43分鐘觸發)的含義一樣。
•?:用在Day-of-Month和Day-of-Week中,指“沒有具體的值”。當兩個子表達式其中一個被指定了值以後,為了避免衝突,需要將另外一個的值設為“?”。例如:想在每月20日觸發調度,不管20號是星期幾,只能用如下寫法:0 0 0 20 * ?,其中最後以為只能用“?”,而不能用“*”。
•L:用在day-of-month和day-of-week字串中。它是單詞“last”的縮寫。它在兩個子表達式中的含義是不同的。
•在day-of-month中,“L”表示一個月的最後一天,一月31號,3月30號。
•在day-of-week中,“L”表示一個星期的最後一天,也就是“7”或者“SAT”
•如果“L”前有具體內容,它就有其他的含義了。例如:“6L”表示這個月的倒數第六天。 “FRIL”表示這個月的最後一個星期五。
•注意:在使用“L”參數時,不要指定列表或者範圍,這樣會出現問題。
•W:“Weekday”的縮寫。只能用在day-of-month字段。用來描敘最接近指定天的工作日(週一到週五)。例如:在day-of-month字段用“15W”指“最接近這個月第15天的工作日”,即如果這個月第15天是周六,那麼觸發器將會在這個月第14天即周五觸發;如果這個月第15天是周日,那麼觸發器將會在這個月第16天即周一觸發;如果這個月第15天是周二,那麼就在觸發器這天觸發。注意一點:這個用法只會在當前月計算值,不會越過當前月。 “W”字符僅能在day-of-month指明一天,不能是一個範圍或列表。也可以用“LW”來指定這個月的最後一個工作日,即最後一個星期五。
•# :只能用在day-of-week字段。用來指定這個月的第幾個週幾。例:在day-of-week字段用"6#3" or "FRI#3"指這個月第3個週五(6指周五,3指第3個)。如果指定的日期不存在,觸發器就不會觸發。
表達式例子:
0 * * * * ? 每1分鐘觸發一次
0 0 * * * ? 每天每1小時觸發一次
0 0 10 * * ? 每天10點觸發一次
0 * 14 * * ? 在每天下午2點到下午2:59期間的每1分鐘觸發
0 30 9 1 * ? 每月1號上午9點半
0 15 10 15 * ? 每月15日上午10:15觸發
*/5 * * * * ? 每隔5秒執行一次
0 */1 * * * ? 每隔1分鐘執行一次
0 0 5-15 * * ? 每天5-15點整點觸發
0 0/3 * * * ? 每三分鐘觸發一次
0 0-5 14 * * ? 在每天下午2點到下午2:05期間的每1分鐘觸發
0 0/5 14 * * ? 在每天下午2點到下午2:55期間的每5分鐘觸發
0 0/5 14,18 * * ? 在每天下午2點到2:55期間和下午6點到6:55期間的每5分鐘觸發
0 0/30 9-17 * * ? 朝九晚五工作時間內每半小時
0 0 10,14,16 * * ? 每天上午10點,下午2點,4點
0 0 12 ? * WED 表示每個星期三中午12點
0 0 17 ? * TUES,THUR,SAT 每週二、四、六下午五點
0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44觸發
0 15 10 ? * MON-FRI 週一至週五的上午10:15觸發
0 0 23 L * ? 每月最後一天23點執行一次
0 15 10 L * ? 每月最後一日的上午10:15觸發
0 15 10 ? * 6L 每月的最後一個星期五上午10:15觸發
0 15 10 * * ? 2005 2005年的每天上午10:15觸發
0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最後一個星期五上午10:15觸發
0 15 10 ? * 6#3 每月的第三個星期五上午10:15觸發
以上這篇Java實現Web應用中的定時任務(實例講解)就是小編分享給大家的全部內容了,希望能給大家一個參考,也希望大家多多支持武林網。