2. 程式人生 > >排程框架Quartz

排程框架Quartz

阿新 • • 發佈：2018-12-22

Quartz可以用來做什麼？

Quartz是一個任務排程框架。比如你遇到這樣的問題

  • 想每月25號，信用卡自動還款
  • 想每年4月1日自己給當年暗戀女神發一封匿名賀卡
  • 想每隔1小時，備份一下自己的愛情動作片 學習筆記到雲盤

這些問題總結起來就是：在某一個有規律的時間點幹某件事。並且時間的觸發的條件可以非常複雜（比如每月最後一個工作日的17:50），複雜到需要一個專門的框架來幹這個事。 Quartz就是來幹這樣的事，你給它一個觸發條件的定義，它負責到了時間點，觸發相應的Job起來幹活。

一個簡單的示例

這裡面的所有例子都是基於Quartz 2.2.1

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

  1. 已經MisFire的任務還要重新觸發嗎？
  2. 如果發生MisFire，要調整現有的排程時間嗎？

比如SimpleTrigger的MisFire策略有：

  • MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY

    這個不是忽略已經錯失的觸發的意思，而是說忽略MisFire策略。它會在資源合適的時候，重新觸發所有的MisFire任務，並且不會影響現有的排程時間。

    比如，SimpleTrigger每15秒執行一次，而中間有5分鐘時間它都MisFire了，一共錯失了20個，5分鐘後，假設資源充足了，並且任務允許併發，它會被一次性觸發。

    這個屬性是所有Trigger都適用。

  • MISFIRE_INSTRUCTION_FIRE_NOW

    忽略已經MisFire的任務，並且立即執行排程。這通常只適用於只執行一次的任務。

  • MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

    將startTime設定當前時間，立即重新排程任務，包括的MisFire的

  • MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT

    類似MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT，區別在於會忽略已經MisFire的任務

  • MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT

    在下一次排程時間點，重新開始排程任務，包括的MisFire的

  • MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT

    類似於MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT，區別在於會忽略已經MisFire的任務。

  • MISFIRE_INSTRUCTION_SMART_POLICY

    所有的Trigger的MisFire預設值都是這個，大致意思是“把處理邏輯交給聰明的Quartz去決定”。基本策略是，

    1. 如果是隻執行一次的排程，使用MISFIRE_INSTRUCTION_FIRE_NOW
    2. 如果是無限次的排程(repeatCount是無限的)，使用MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
    3. 否則，使用MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

MisFire的東西挺繁雜的，可以參考這篇

Calendar

這裡的Calendar不是jdk的java.util.Calendar，不是為了計算日期的。它的作用是在於補充Trigger的時間。可以排除或加入某一些特定的時間點。

以”每月25日零點自動還卡債“為例，我們想排除掉每年的2月25號零點這個時間點（因為有2.14，所以2月一定會破產）。這個時間，就可以用Calendar來實現。

例子：

AnnualCalendar cal = new AnnualCalendar(); //定義一個每年執行Calendar，精度為天，即不能定義到2.25號下午2:00
java.util.Calendar excludeDay = new GregorianCalendar();
excludeDay.setTime(newDate().inMonthOnDay(2, 25).build());
cal.setDayExcluded(excludeDay, true);  //設定排除2.25這個日期
scheduler.addCalendar("FebCal", cal, false, false); //scheduler加入這個Calendar

//定義一個Trigger
Trigger trigger = newTrigger().withIdentity("trigger1", "group1") 
    .startNow()//一旦加入scheduler，立即生效
    .modifiedByCalendar("FebCal") //使用Calendar !!
    .withSchedule(simpleSchedule()
        .withIntervalInSeconds(1) 
        .repeatForever()) 
    .build();

Quartz體貼地為我們提供以下幾種Calendar，注意，所有的Calendar既可以是排除，也可以是包含，取決於：

  • HolidayCalendar。指定特定的日期，比如20140613。精度到天。
  • DailyCalendar。指定每天的時間段（rangeStartingTime, rangeEndingTime)，格式是HH:MM[:SS[:mmm]]。也就是最大精度可以到毫秒。
  • WeeklyCalendar。指定每星期的星期幾，可選值比如為java.util.Calendar.SUNDAY。精度是天。
  • MonthlyCalendar。指定每月的幾號。可選值為1-31。精度是天
  • AnnualCalendar。 指定每年的哪一天。使用方式如上例。精度是天。
  • CronCalendar。指定Cron表示式。精度取決於Cron表示式，也就是最大精度可以到秒。

Trigger實現類

Quartz有以下幾種Trigger實現:

SimpleTrigger

指定從某一個時間開始，以一定的時間間隔（單位是毫秒）執行的任務。

它適合的任務類似於：9:00 開始，每隔1小時，執行一次。

它的屬性有：

  • repeatInterval 重複間隔
  • repeatCount 重複次數。實際執行次數是 repeatCount+1。因為在startTime的時候一定會執行一次。** 下面有關repeatCount 屬性的都是同理。　**

例子：

simpleSchedule()
        .withIntervalInHours(1) //每小時執行一次
        .repeatForever() //次數不限
        .build();

simpleSchedule()
    .withIntervalInMinutes(1) //每分鐘執行一次
    .withRepeatCount(10) //次數為10次
    .build();

CalendarIntervalTrigger

類似於SimpleTrigger，指定從某一個時間開始，以一定的時間間隔執行的任務。 但是不同的是SimpleTrigger指定的時間間隔為毫秒，沒辦法指定每隔一個月執行一次（每月的時間間隔不是固定值），而CalendarIntervalTrigger支援的間隔單位有秒，分鐘，小時，天，月，年，星期。

相較於SimpleTrigger有兩個優勢：1、更方便，比如每隔1小時執行，你不用自己去計算1小時等於多少毫秒。 2、支援不是固定長度的間隔，比如間隔為月和年。但劣勢是精度只能到秒。

它適合的任務類似於：9:00 開始執行，並且以後每週 9:00 執行一次

它的屬性有:

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

例子:

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

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

DailyTimeIntervalTrigger

指定每天的某個時間段內，以一定的時間間隔執行任務。並且它可以支援指定星期。

它適合的任務類似於：指定每天9:00 至 18:00 ，每隔70秒執行一次，並且只要週一至週五執行。

它的屬性有:

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

例子:

dailyTimeIntervalSchedule()
    .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)) //第天9：00開始
    .endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 0)) //16：00 結束 
    .onDaysOfTheWeek(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY) //週一至週五執行
    .withIntervalInHours(1) //每間隔1小時執行一次
    .withRepeatCount(100) //最多重複100次（實際執行100+1次）
    .build();

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

CronTrigger

適合於更復雜的任務，它支援型別於Linux Cron的語法（並且更強大）。基本上它覆蓋了以上三個Trigger的絕大部分能力（但不是全部）—— 當然，也更難理解。

它適合的任務類似於：每天0:00,9:00,18:00各執行一次。

它的屬性只有:

  • Cron表示式。但這個表示式本身就夠複雜了。下面會有說明。

例子：

cronSchedule("0 0/2 8-17 * * ?") // 每天8:00-17:00，每隔2分鐘執行一次
    .build();

cronSchedule("0 30 9 ? * MON") // 每週一，9:30執行一次
.build();

weeklyOnDayAndHourAndMinute(MONDAY,9, 30) //等同於 0 30 9 ? * MON 
    .build();

Cron表示式

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

星號()：可用在所有欄位中，表示對應時間域的每一個時刻，例如， 在分鐘欄位時，表示“每分鐘”；

問號（?）：該字元只在日期和星期欄位中使用，它通常指定為“無意義的值”，相當於點位符；

減號(-)：表達一個範圍，如在小時欄位中使用“10-12”，則表示從10到12點，即10,11,12；

逗號(,)：表達一個列表值，如在星期欄位中使用“MON,WED,FRI”，則表示星期一，星期三和星期五；

斜槓(/)：x/y表達一個等步長序列，x為起始值，y為增量步長值。如在分鐘欄位中使用0/15，則表示為0,15,30和45秒，而5/15在分鐘欄位中表示5,20,35,50，你也可以使用*/y，它等同於0/y；

L：該字元只在日期和星期欄位中使用，代表“Last”的意思，但它在兩個欄位中意思不同。L在日期欄位中，表示這個月份的最後一天，如一月的31號，非閏年二月的28號；如果L用在星期中，則表示星期六，等同於7。但是，如果L出現在星期欄位裡，而且在前面有一個數值X，則表示“這個月的最後X天”，例如，6L表示該月的最後星期五；

W：該字元只能出現在日期欄位裡，是對前導日期的修飾，表示離該日期最近的工作日。例如15W表示離該月15號最近的工作日，如果該月15號是星期六，則匹配14號星期五；如果15日是星期日，則匹配16號星期一；如果15號是星期二，那結果就是15號星期二。但必須注意關聯的匹配日期不能夠跨月，如你指定1W，如果1號是星期六，結果匹配的是3號星期一，而非上個月最後的那天。W字串只能指定單一日期，而不能指定日期範圍；

LW組合：在日期欄位可以組合使用LW，它的意思是當月的最後一個工作日；

井號(#)：該字元只能在星期欄位中使用，表示當月某個工作日。如6#3表示當月的第三個星期五(6表示星期五，#3表示當前的第三個)，而4#5表示當月的第五個星期三，假設當月沒有第五個星期三，忽略不觸發；

C：該字元只在日期和星期欄位中使用，代表“Calendar”的意思。它的意思是計劃所關聯的日期，如果日期沒有被關聯，則相當於日曆中所有日期。例如5C在日期欄位中就相當於日曆5日以後的第一天。1C在星期欄位中相當於星期日後的第一天。

Cron表示式對特殊字元的大小寫不敏感，對代表星期的縮寫英文大小寫也不敏感。

一些例子：

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

JobDetail & Job

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

public class JobTest {
    public static void main(String[] args) throws SchedulerException, IOException {
           JobDetail job=newJob()
               .ofType(DoNothingJob.class) //引用Job Class
               .withIdentity("job1", "group1") //設定name/group
               .withDescription("this is a test job") //設定描述
               .usingJobData("age", 18) //加入屬性到ageJobDataMap
               .build();

           job.getJobDataMap().put("name", "quertz"); //加入屬性name到JobDataMap

           //定義一個每秒執行一次的SimpleTrigger
           Trigger trigger=newTrigger()
                   .startNow()
                   .withIdentity("trigger1")
                   .withSchedule(simpleSchedule()
                       .withIntervalInSeconds(1)
                       .repeatForever())
                   .build();

           Scheduler sche=StdSchedulerFactory.getDefaultScheduler();
           sche.scheduleJob(job, trigger);

           sche.start();

           System.in.read();

           sche.shutdown();
    }
}


public class DoNothingJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("do nothing");
    }
}

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

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

Quartz排程一次任務，會幹如下的事：

  1. JobClass jobClass=JobDetail.getJobClass()
  2. Job jobInstance=jobClass.newInstance()。所以Job實現類，必須有一個public的無參構建方法。
  3. jobInstance.execute(JobExecutionContext context)。JobExecutionContext是Job執行的上下文，可以獲得Trigger、Scheduler、JobDetail的資訊。

也就是說，每次排程都會建立一個新的Job例項，這樣的好處是有些任務併發執行的時候，不存在對臨界資源的訪問問題——當然，如果需要共享JobDataMap的時候，還是存在臨界資源的併發訪問的問題。

JobDataMap

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

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

我們可以在定義JobDetail，加入屬性值，方式有二：

newJob().usingJobData("age", 18) //加入屬性到ageJobDataMap

 or

 job.getJobDataMap().put("name", "quertz"); //加入屬性name到JobDataMap

然後在Job中可以獲取這個JobDataMap的值，方式同樣有二：

public class HelloQuartz implements Job {
    private String name;

    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail detail = context.getJobDetail();
        JobDataMap map = detail.getJobDataMap(); //方法一：獲得JobDataMap
        System.out.println("say hello to " + name + "[" + map.getInt("age") + "]" + " at "
                           + new Date());
    }

    //方法二：屬性的setter方法，會將JobDataMap的屬性自動注入
    public void setName(String name) { 
        this.name = name;
    }
}

對於同一個JobDetail例項，執行的多個Job例項，是共享同樣的JobDataMap，也就是說，如果你在任務裡修改了裡面的值，會對其他Job例項（併發的或者後續的）造成影響。

除了JobDetail，Trigger同樣有一個JobDataMap，共享範圍是所有使用這個Trigger的Job例項。

Job併發

Job是有可能併發執行的，比如一個任務要執行10秒中，而排程演算法是每秒中觸發1次，那麼就有可能多個任務被併發執行。

有時候我們並不想任務併發執行，比如這個任務要去”獲得資料庫中所有未傳送郵件的名單“，如果是併發執行，就需要一個數據庫鎖去避免一個數據被多次處理。這個時候一個@DisallowConcurrentExecution解決這個問題。

就是這樣

public class DoNothingJob implements Job {
    @DisallowConcurrentExecution
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("do nothing");
    }
}

注意，@DisallowConcurrentExecution是對JobDetail例項生效，也就是如果你定義兩個JobDetail，引用同一個Job類，是可以併發執行的。

JobExecutionException

Job.execute()方法是不允許丟擲除JobExecutionException之外的所有異常的（包括RuntimeException)，所以編碼的時候，最好是try-catch住所有的Throwable，小心處理。

其他屬性

  • Durability(耐久性？)

    如果一個任務不是durable，那麼當沒有Trigger關聯它的時候，它就會被自動刪除。

  • RequestsRecovery

    如果一個任務是”requests recovery”，那麼當任務執行過程非正常退出時（比如程序崩潰，機器斷電，但不包括丟擲異常這種情況），Quartz再次啟動時，會重新執行一次這個任務例項。

    可以通過JobExecutionContext.isRecovering()查詢任務是否是被恢復的。

Scheduler

Scheduler就是Quartz的大腦，所有任務都是由它來設施。

Schduelr包含一個兩個重要元件: JobStore和ThreadPool。

JobStore是會來儲存執行時資訊的，包括Trigger,Schduler,JobDetail，業務鎖等。它有多種實現RAMJob(記憶體實現)，JobStoreTX(JDBC，事務由Quartz管理），JobStoreCMT(JDBC，使用容器事務)，ClusteredJobStore(叢集實現)、TerracottaJobStore(什麼是Terractta)。

ThreadPool就是執行緒池，Quartz有自己的執行緒池實現。所有任務的都會由執行緒池執行。

SchedulerFactory

SchdulerFactory，顧名思義就是來用建立Schduler了，有兩個實現：DirectSchedulerFactory和 StdSchdulerFactory。前者可以用來在程式碼裡定製你自己的Schduler引數。後者是直接讀取classpath下的quartz.properties（不存在就都使用預設值）配置來例項化Schduler。通常來講，我們使用StdSchdulerFactory也就足夠了。

SchdulerFactory本身是支援建立RMI stub的，可以用來管理遠端的Scheduler，功能與本地一樣，可以遠端提交個Job什麼的。

DirectSchedulerFactory的建立介面

    /**
     * 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

這裡未講的稍微高階的主題

參考


原文連結： https://www.cnblogs.com/drift-ice/p/3817269.html

相關推薦

任務排程框架quartz使用總結(異常處理，解決恢復後多次排程處理)

任務排程框架quartz使用總結(異常處理，解決恢復後多次排程處理)      首先先說說什麼是排程框架，大白話所謂的排程框架你可以把它看成一個定時任務管理框架，並且quartz框架是多執行緒的， quartz最主要的三大基本特性: (1)排程器&nbs

java計劃任務排程框架quartz結合spring實現排程的配置例項程式碼分享

                一：quartz簡介       OpenSymphony 的Quartz提供了一個比較完美的任務排程解決方案。       Quartz 是個開源的作業排程框架，定時排程器，為在 Java 應用程式中進行作業排程提供了簡單卻強大的機制。       Quartz中有兩個基本概

排程框架Quartz

Quartz可以用來做什麼？ Quartz是一個任務排程框架。比如你遇到這樣的問題 想每月25號，信用卡自動還款 想每年4月1日自己給當年暗戀女神發一封匿名賀卡 想每隔1小時，備份一下自己的愛情動作片 學習筆記到雲盤 這些問題總結起來

.NET開源作業排程框架(Quartz.NET和FluentScheduler)實戰專案演練

一、課程介紹 明人不說暗話，跟著阿笨一起玩NET 。本次分享課程屬於《C#高階程式設計實戰技能開發寶典課程系列》中的一部分，阿笨後續會計劃將實際專案中的一些比較實用的關於C#高階程式設計的技巧分享出來給大家進行學習，不斷的收集、整理和完善此係列課程！本次分享課程給大家帶來的是《.NET開源作業排程框架

任務排程框架Quartz（一） Quartz——一個強大的定時任務排程框架

Quartz，水晶、石英，一個簡單樸素有美麗的名字，在Java程式界，Quartz大名鼎鼎，很多Java應用幾乎都整合或構建了一個定時任務排程系統，Quartz是一個定時任務排程框架。 何為定時任務排程框架？簡而言之，它可以領會我們的意圖在未來某個時刻做我們想

企業級定時任務排程框架Quartz中文文件chm

作業排程，在一個大的組織中每天的每小時跑上百個作業已屬普遍。並且作業的規模與複雜性仍在持續的上揚，因此批量作業和作業排程器也就隨需應生。Quartz的使用場景主要為： 1：定時郵件提醒和告警。 2：定時執行檔案傳輸操作 3：定時建立銷售報表 4：定時產生日誌資訊 ....等

作業排程框架 Quartz 學習筆記(四) -- 接收引數和維護狀態

<<Quartz中Job的引數傳遞和狀態儲存>> 如果你想在 某個job執行的時候傳入引數,引數在job執行過程中對引數有所修改,並且在job執行完畢後把引數返回那麼你需要學習一下現在的這個例子了,因為它正是你所想要的 ...... 我的建議是先把

任務排程框架Quartz原理簡介

第一章 Quartz 1.1 Quartz概念 Quartz是OpenSymphony開源組織的一個Java開源專案， 在2009被Terracotta收購。Quartz官網 1.2 Quartz任務排程主要元素 Quartz任務排程

作業排程框架 Quartz 學習筆記(三) -- Cron表示式

  前面兩篇說的是簡單的觸發器(SimpleTrigger) , SimpleTrigger 只能處理簡單的事件出發,如果想靈活的進行任務的觸發,就要請出CronTrigger 這個重要人物了.    CronTrigger也是Quartz最重要的特色之一，通過Quartz特

作業排程框架 Quartz 學習筆記(五) -- 錯過的任務怎麼辦?

不知道大家在用Quartz的時候 有沒有遇到這樣一種情況: 觸發器設定每3秒鐘觸發一次 ,但是工作需要10秒鐘的執行時間.因此，在一次任務結束執行前，觸發器已經錯失觸發 當這種情況下我們怎麼處理呢,讓我們一起學習一下...... 還是先貼程式碼: job類:Statefu

任務排程框架Quartz快速入門！

[toc] ## Quartz是什麼 Quartz是一個功能強大的開源任務排程庫，幾乎可以整合到任何Java應用程式中，無論是超小型的獨立應用還是超大型電子商務系統。 它常用於企業級應用中： - Driving Process Workflow：當新訂單下達，可以安排一個30分鐘內觸發的任務，檢查訂單狀

SpringBoot整合任務排程框架Quartz及持久化配置

[toc] > 本文側重SpringBoot與Quartz的整合，Quartz的基本入門概念不清楚的小夥伴可以看看這篇文章：[任務排程框架Quartz快速入門！](https://www.cnblogs.com/summerday152/p/14192845.html) ## 本篇要點 - 介紹Spri

Quartz任務排程框架初探

Quartz任務排程框架初探 什麼是Quartz? Quartz 是一個完全由 Java 編寫的開源作業排程框架，為在 Java 應用程式中進行作業排程提供了簡單卻強大的機制。 Quartz 可以與 J2EE 與 J2SE 應用程式相結合也可以單獨使用。

Quartz任務排程框架--任務執行流程（二）

       上一篇部落格Quartz任務排程框架--簡介與示例（一）中我們已經簡介和示例程式碼對quartz有了初步的認識，這篇部落格我們通過追蹤quartz的定時任務執行流程來加深對quartz的瞭解。 1、執行活動執行緒 （1）Quartz_Worker-*執行

Quartz任務排程框架（啟動定時任務框架）

Quartz任務排程框架（啟動定時任務框架） Quartz是OpenSymphony開源組織在Jobscheduling領域又一個開源專案，它可以與J2EE與J2SE應用程式相結合也可以單獨使用。Quartz可以用來建立簡單或為執行十個，百個，甚至是好幾萬個Jobs這樣複雜的

quartz任務排程框架實現任務定時執行，不傳參的配置（一）

quartz是一個任務排程框架，可以用它來實現一些需要定時執行的任務。 本次實現的是spring配置整合quartz 1.配置如下：目標bean和bean中的方法需要自己定義，這個方法就是要執行

quartz任務排程框架入門

1、 CronTrigger時間格式配置說明 CronTrigger配置格式: 格式: [秒] [分] [小時] [日] [月] [周] [年] 序號 說明 是否必填 允許填寫的值 允許的萬用字元 1 秒 是 0-59  , - * /

Quartz 企業級任務排程框架（一）之簡介

什麼是Quartz任務排程庫？Quartz是一個功能豐富的開源作業排程庫，可以整合到幾乎任何Java應用程式中 - 從最小的獨立應用程式到最大的電子商務系統。Quartz可以用來建立執行數十，數百乃至數萬個作業的簡單或複雜的計劃;作業的任務被定義為標準的Java元件，它可以執

quartz開源任務排程框架知識總結（一）

1.1.1             JDK Timer & TimerTask 如果是執行簡單的有一定執行週期的，那麼使用jdk自帶的timer是最簡單的。具體： ①、編寫一個簡單類繼承 TimerTask，在這個新編寫的類中重寫父類中run方法，在run中執行要執

Quartz.NET開源作業排程框架:CronTrigger

1 //排除的日期 2 HolidayCalendar cal = new HolidayCalendar(); 3 DateTime dt排除 = new DateTime(2015, 12, 1); 4 cal.Ad