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

時間 2019-11-11

標籤如何 java 實現 web 應用定時任務欄目 Java 简体版

原文原文鏈接

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

1、定時任務場景linux

（1）驅動處理工做流程算法

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

（2）系統維護數據庫

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

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

系統定時提醒登陸用戶某時間點執行相關工做。ruby

（4）定時對帳任務併發

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

（5）數據統計

數據記錄較多，實時從數據庫讀取查詢會產生必定時間，爲客戶體驗及性能須要，故每週（天，小時）將數據進行彙總，從而在展現數據時可以快速的呈現數據。

使用定時任務的場景還有不少... 看來定時任務在咱們平常的開發中真的應用很普遍...

2、主流定時任務技術講解 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小時等於多少毫秒。二、支持不是固定長度的間隔，好比間隔爲月和年。但劣勢是精度只能到秒。它適合的任務相似於：9:00 開始執行，而且之後每週 9:00 執行一次。它的屬性有:

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

例子：

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

DailyTimeIntervalTrigger

指定天天的某個時間段內，以必定的時間間隔執行任務。而且它能夠支持指定星期。它適合的任務相似於：指定天天9:00 至 18:00 ，每隔70秒執行一次，而且只要週一至週五執行。它的屬性有:

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

例子:

dailyTimeIntervalSchedule()
    .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)) //第天9：00開始 .endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 0)) //16：00 結束 .onDaysOfTheWeek(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY) //週一至週五執行 .withIntervalInHours(1) //每間隔1小時執行一次 .withRepeatCount(100) //最多重複100次（實際執行100+1次） .build(); dailyTimeIntervalSchedule() .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)) //第天9：00開始 .endingDailyAfterCount(10) //天天執行10次，這個方法實際上根據 startTimeOfDay+interval*count 算出 endTimeOfDay .onDaysOfTheWeek(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY) //週一至週五執行 .withIntervalInHours(1) //每間隔1小時執行一次 .build();

CronTrigger

適合於更復雜的任務，它支持類型於Linux Cron的語法（而且更強大）。基本上它覆蓋了以上三個Trigger的絕大部分能力（但不是所有）—— 固然，也更難理解。它適合的任務相似於：天天0:00,9:00,18:00各執行一次。它的屬性只有：

Cron表達式

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

cronSchedule("0 0/2 8-17 * * ?") // 天天8:00-17:00，每隔2分鐘執行一次 .build(); cronSchedule("0 30 9 ? * MON") // 每週一，9:30執行一次 .build(); weeklyOnDayAndHourAndMinute(MONDAY,9, 30) //等同於 0 30 9 ? * MON .build();

Cron表達式

位置	時間域	容許值	特殊值
1	秒	0-59	, - * /
2	分鐘	0-59	, - * /
3	小時	0-23	, - * /
4	日期	1-31	, - * ? / L W C
5	月份	1-12	, - * /
6	星期	1-7	, - * ? / L C #
7	年份（可選）	1-31	, - * /

星號()：可用在全部字段中，表示對應時間域的每個時刻，例如，在分鐘字段時，表示「每分鐘」；
問號（?）：該字符只在日期和星期字段中使用，它一般指定爲「無心義的值」，至關於點位符；
減號(-)：表達一個範圍，如在小時字段中使用「10-12」，則表示從10到12點，即10,11,12；
逗號(,)：表達一個列表值，如在星期字段中使用「MON,WED,FRI」，則表示星期一，星期三和星期五；
斜槓(/)：x/y表達一個等步長序列，x爲起始值，y爲增量步長值。如在分鐘字段中使用0/15，則表示爲0,15,30和45秒，而5/15在分鐘字段中表示5,20,35,50，你也可使用*/y，它等同於0/y；
L：該字符只在日期和星期字段中使用，表明「Last」的意思，但它在兩個字段中意思不一樣。L在日期字段中，表示這個月份的最後一天，如一月的31號，非閏年二月的28號；若是L用在星期中，則表示星期六，等同於7。可是，若是L出如今星期字段裏，並且在前面有一個數值X，則表示「這個月的最後X天」，例如，6L表示該月的最後星期五；
W：該字符只能出如今日期字段裏，是對前導日期的修飾，表示離該日期最近的工做日。例如15W表示離該月15號最近的工做日，若是該月15號是星期六，則匹配14號星期五；若是15日是星期日，則匹配16號星期一；若是15號是星期二，那結果就是15號星期二。但必須注意關聯的匹配日期不可以跨月，如你指定1W，若是1號是星期六，結果匹配的是3號星期一，而非上個月最後的那天。W字符串只能指定單一日期，而不能指定日期範圍；
LW組合：在日期字段能夠組合使用LW，它的意思是當月的最後一個工做日；井號(#)：該字符只能在星期字段中使用，表示當月某個工做日。如6#3表示當月的第三個星期五(6表示星期五，#3表示當前的第三個)，而4#5表示當月的第五個星期三，假設當月沒有第五個星期三，忽略不觸發；
C：該字符只在日期和星期字段中使用，表明「Calendar」的意思。它的意思是計劃所關聯的日期，若是日期沒有被關聯，則至關於日曆中全部日期。例如5C在日期字段中就至關於日曆5日之後的第一天。1C在星期字段中至關於星期往後的第一天。

Cron表達式對特殊字符的大小寫不敏感，對錶明星期的縮寫英文大小寫也不敏感。一些例子：

表示式	說明
0 0 12 * * ?	天天12點運行
0 15 10 ? * *	天天10:15運行
0 15 10 * * ?	天天10:15運行
0 15 10 * * ? *	天天10:15運行
0 15 10 * * ? 2008	在2008年的天天10：15運行
0 * 14 * * ?	天天14點到15點之間每分鐘運行一次，開始於14:00，結束於14:59。
0 0/5 14 * * ?	天天14點到15點每5分鐘運行一次，開始於14:00，結束於14:55。
0 0/5 14,18 * * ?	天天14點到15點每5分鐘運行一次，此外天天18點到19點每5鍾也運行一次。
0 0-5 14 * * ?	天天14:00點到14:05，每分鐘運行一次。
0 10,44 14 ? 3 WED	3月每週三的14:10分到14:44，每分鐘運行一次。
0 15 10 ? * MON-FRI	每週一，二，三，四，五的10:15分運行。
0 15 10 15 * ?	每個月15日10:15分運行。
0 15 10 L * ?	每個月最後一天10:15分運行。
0 15 10 ? * 6L	每個月最後一個星期五10:15分運行。
0 15 10 ? * 6L 2007-2009	在2007,2008,2009年每月的最後一個星期五的10:15分運行。
0 15 10 ? * 6#3	每個月第三個星期五的10:15分運行。

JobDetail & Job

JobDetail是任務的定義，而Job是任務的執行邏輯。在JobDetail裏會引用一個Job Class定義。一個最簡單的例子：

public class JobTest { public static void main(String[] args) throws SchedulerException, IOException { JobDetail job=newJob() .ofType(DoNothingJob.class) //引用Job Class .withIdentity("job1", "group1") //設置name/group .withDescription("this is a test job") //設置描述 .usingJobData("age", 18) //加入屬性到ageJobDataMap .build(); job.getJobDataMap().put("name", "quertz"); //加入屬性name到JobDataMap //定義一個每秒執行一次的SimpleTrigger Trigger trigger=newTrigger() .startNow() .withIdentity("trigger1") .withSchedule(simpleSchedule() .withIntervalInSeconds(1) .repeatForever()) .build(); Scheduler sche=StdSchedulerFactory.getDefaultScheduler(); sche.scheduleJob(job, trigger); sche.start(); System.in.read(); sche.shutdown(); } } public class DoNothingJob implements Job { public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("do nothing"); } }

從上例咱們能夠看出，要定義一個任務，須要幹幾件事：

建立一個org.quartz.Job的實現類，並實現實現本身的業務邏輯。好比上面的DoNothingJob。
定義一個JobDetail，引用這個實現類
加入scheduleJob Quartz調度一次任務，會幹以下的事：
JobClass jobClass=JobDetail.getJobClass()
Job jobInstance=jobClass.newInstance()。因此Job實現類，必須有一個public的無參構建方法。
jobInstance.execute(JobExecutionContext context)。JobExecutionContext是Job運行的上下文，能夠得到Trigger、Scheduler、JobDetail的信息。

也就是說，每次調度都會建立一個新的Job實例，這樣的好處是有些任務併發執行的時候，不存在對臨界資源的訪問問題——固然，若是須要共享JobDataMap的時候，仍是存在臨界資源的併發訪問的問題。

JobDataMap

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

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

咱們能夠在定義JobDetail，加入屬性值，方式有二：

newJob().usingJobData("age", 18) //加入屬性到ageJobDataMap
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

3、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" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="myJobTrigger" /> </list> </property> </bean> <!-- 啓動觸發器的配置結束 -->

項目啓動，定時器開始執行。

4、分析不一樣定時任務優缺點，尋找一種符合你項目需求的定時任務 Timer管理延時任務的缺陷

之前在項目中也常用定時器，好比每隔一段時間清理項目中的一些垃圾文件，每隔一段時間進行日誌清理；然而Timer是存在一些缺陷的，由於Timer在執行定時任務時只會建立一個線程，因此若是存在多個任務，且任務時間過長，超過了兩個任務的間隔時間，會發生一些缺陷

Timer當任務拋出異常時的缺陷

若是TimerTask拋出RuntimeException，Timer會中止全部任務的運行

Timer執行週期任務時依賴系統時間

Timer執行週期任務時依賴系統時間，若是當前系統時間發生變化會出現一些執行上的變化，ScheduledExecutorService基於時間的延遲，不會因爲系統時間的改變發生執行變化。

對異常的處理

Quartz的某次執行任務過程當中拋出異常，不影響下一次任務的執行，當下一次執行時間到來時，定時器會再次執行任務；而TimerTask則不一樣，一旦某個任務在執行過程當中拋出異常，則整個定時器生命週期就結束，之後永遠不會再執行定時器任務。

精確到和功能

Quartz每次執行任務都建立一個新的任務類對象，而TimerTask則每次使用同一個任務類對象。 Quartz能夠經過cron表達式精確到特定時間執行，而TimerTask不能。Quartz擁有TimerTask全部的功能，而TimerTask則沒有上述，基本說明了在之後的開發中儘量使用ScheduledExecutorService(JDK1.5之後)替代Timer。

5、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 | , - * ? / L W C 月 | 1-12 or JAN-DEC | , - * / 周幾 | 1-7 or SUN-SAT | , - * ? / L C # 年(可選字段) | 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個）。若是指定的日期不存在，觸發器就不會觸發。