Quertz作業調度

第0章：簡介

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

第0節：參考網站

http://www.ibm.com/developerworks/cn/java/j-quartz/

http://www.ibm.com/developerworks/cn/java/j-lo-taskschedule/

官網：http://www.quartz-scheduler.org/

官網文檔：http://www.quartz-scheduler.org/documentation

開源中國：http://www.oschina.net/p/quartz

百度百科：http://baike.baidu.com/subview/1002067/5810766.htm#viewPageContent

第1節：maven座標

        <!--任務調度-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>1.8.5</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

第2節：札記

（1）Quartz 調度包的兩個基本單元是作業和觸發器。作業是能夠調度的可執行任務，觸發器 提供了對作業的調度。

（2）Quartz 允許在不丟失作業本身或作業的上下文的情況下，修改調度觸發器。而且，任何單個的作業都可以有多個觸發器與其關聯。

第1章：實例

（1）quertz任務調度器工具類(ScheduleService.java)

package com.mcc.core.quartz;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;

/**
 * 任務調度器服務，用到quartz包
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 13-12-20  上午10:54
 */
public abstract class ScheduleService {
    // members
    private static Logger logger = LoggerFactory.getLogger(ScheduleService.class);
    // 任務調度器
    protected Scheduler scheduler;

    // static block

    // constructors

    // properties

    // public methods

    /**
     * 添加任務調度器
     *
     * @param scheduler 調度器
     */
    public abstract void addScheduler(Scheduler scheduler);

    /**
     * 通用執行任務方法，並按照cronExpression執行任務
     *
     * @param jobClazz       執行的任務類
     * @param groupName      JOB組
     * @param cronExpression cron表達式
     * @throws org.quartz.SchedulerException
     * @throws java.text.ParseException
     */
    public void addJob(Class jobClazz, String groupName, String cronExpression) throws SchedulerException, ParseException {
        addJob(jobClazz, groupName, cronExpression, false);
    }

    /**
     * 通用執行任務方法，並按照cronExpression執行任務
     *
     * @param jobClazz       執行的任務類
     * @param groupName      JOB組
     * @param cronExpression cron表達式
     * @param pause          是否默認暫停
     * @throws org.quartz.SchedulerException
     * @throws java.text.ParseException
     */
    public void addJob(Class jobClazz, String groupName, String cronExpression, boolean pause) throws SchedulerException, ParseException {
        addJob(null, jobClazz, groupName, cronExpression, pause);
    }

    /**
     * 通用執行任務方法，並按照cronExpression執行任務
     *
     * @param jobDetail      執行的任務
     * @param jobClazz       執行的任務類
     * @param groupName      JOB組
     * @param cronExpression cron表達式
     * @throws org.quartz.SchedulerException
     * @throws java.text.ParseException
     */
    public void addJob(JobDetail jobDetail, Class jobClazz, String groupName, String cronExpression) throws SchedulerException, ParseException {
        addJob(jobDetail, jobClazz, groupName, cronExpression, false);
    }

    /**
     * 通用執行任務方法，並按照cronExpression執行任務
     *
     * @param jobDetail      執行的任務
     * @param jobClazz       執行的任務類
     * @param groupName      JOB組, jobName = groupName + "_DETAIL", triggerName = groupName + "_TRIGGER"
     * @param cronExpression cron表達式
     * @param pause          是否默認暫停
     * @throws org.quartz.SchedulerException
     * @throws java.text.ParseException
     */
    public void addJob(JobDetail jobDetail, Class jobClazz, String groupName, String cronExpression, boolean pause) throws SchedulerException, ParseException {
        // 添加任務
        String jobName = new StringBuilder(groupName).append("_").append("DETAIL").toString();
        if (jobDetail == null) {
            jobDetail = new JobDetail();
        }
        if (groupName == null || groupName.isEmpty()) {
            groupName = Scheduler.DEFAULT_GROUP;
        }
        jobDetail.setName(jobName);
        jobDetail.setGroup(groupName);
        jobDetail.setJobClass(jobClazz);
        scheduler.addJob(jobDetail, true);
        // 添加解發器
        String triggerName = new StringBuilder(groupName).append("_").append("TRIGGER").toString();
        CronTrigger cronTrigger = new CronTrigger();
        cronTrigger.setName(triggerName);
        cronTrigger.setGroup(groupName);
        cronTrigger.setJobName(jobDetail.getName());
        cronTrigger.setJobGroup(groupName);
        cronTrigger.setCronExpression(cronExpression);
        scheduler.scheduleJob(cronTrigger);
        if (pause) {
            scheduler.pauseJob(jobName, groupName);
        }
    }

    /**
     * 暫停所有任務
     *
     * @throws org.quartz.SchedulerException
     */
    public void pausehAll() {
        try {
            scheduler.pauseAll();
        } catch (SchedulerException e) {
            logger.error("暫停所有任務失敗！", e);
        }
    }

    /**
     * 暫停指定JOB
     *
     * @param jobName JOB名稱
     * @throws org.quartz.SchedulerException
     */
    public void pauseJob(String jobName) {
        pauseJob(jobName, Scheduler.DEFAULT_GROUP);
    }

    /**
     * 暫停指定JOB
     *
     * @param jobName JOB名稱
     * @throws org.quartz.SchedulerException
     */
    public void pauseJob(String jobName, String groupName) {
        try {
            scheduler.pauseJob(jobName, groupName);
        } catch (SchedulerException e) {
            logger.error("暫停任務 " + jobName + " 失敗！", e);
        }
    }

    /**
     * 暫停指定JOB Group
     *
     * @param groupName 組名
     * @throws org.quartz.SchedulerException
     */
    public void pauseGroup(String groupName) {
        try {
            scheduler.pauseJobGroup(groupName);
        } catch (SchedulerException e) {
            logger.error("暫停任務組 " + groupName + " 失敗！", e);
        }
    }

    /**
     * 恢復所有JOB
     *
     * @throws org.quartz.SchedulerException
     */
    public void resumeAll() {
        try {
            scheduler.resumeAll();
        } catch (SchedulerException e) {
            logger.error("恢復所有任務失敗！", e);
        }
    }

    /**
     * 恢復指定JOB
     *
     * @param jobName JOB名稱
     * @throws org.quartz.SchedulerException
     */
    public void resumeJob(String jobName) {
        resumeJob(jobName, Scheduler.DEFAULT_GROUP);
    }

    /**
     * 恢復指定JOB
     *
     * @param jobName JOB名稱
     * @throws org.quartz.SchedulerException
     */
    public void resumeJob(String jobName, String groupName) {
        try {
            scheduler.resumeJob(jobName, groupName);
        } catch (SchedulerException e) {
            logger.error("恢復任務 " + jobName + " 失敗！", e);
        }
    }

    /**
     * 恢復指定JOB Group
     *
     * @param groupName 組名
     */
    public void resumeGroup(String groupName) {
        try {
            scheduler.resumeJobGroup(groupName);
        } catch (SchedulerException e) {
            logger.error("恢復任務組失敗!", e);
        }
    }

    /**
     * 獲取JOB
     *
     * @param jobName JOB名稱
     * @return
     * @throws org.quartz.SchedulerException
     */
    public JobDetail getJobDetail(String jobName) throws SchedulerException {
        return scheduler.getJobDetail(jobName, Scheduler.DEFAULT_GROUP);
    }

    /**
     * 啓動調度器
     *
     * @throws org.quartz.SchedulerException
     */
    public void start() throws SchedulerException {
        scheduler.start();
    }

    /**
     * 停止調度器
     *
     * @throws org.quartz.SchedulerException
     */
    public void stop() throws SchedulerException {
        scheduler.shutdown();
    }
    // protected methods

    // friendly methods

    // private methods

    // inner class

    // test main

}

（2）quartz作業TestJob.java

package com.mcc.core.test;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.StatefulJob;

/**
 * quartz任務
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 13-12-20  下午1:02
 */
public class TestJob implements StatefulJob {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("quartz test !");
    }
}

（3）quartz任務調度測試類QuartzTest.java

package com.mcc.core.test;

import com.mcc.core.quartz.ScheduleService;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;

import java.text.ParseException;

/**
 * quartz任務調度測試
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 13-12-20  下午12:49
 */
public class QuartzTest extends ScheduleService {
    @Override
    public void addScheduler(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

    public void execute(){
        // 設置調度器
        try {
            addScheduler(StdSchedulerFactory.getDefaultScheduler());
            try {
                //可以一次執行多個addJob
                this.addJob(TestJob.class,"test","0/2 * * * * ?");
                this.start();
            } catch (ParseException e) {
                e.printStackTrace();
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public static void main(String args[]){
              new QuartzTest().execute();
    }
}

第2章：java自帶任務調度類

第0節：串行任務調度Timer

（1）簡介

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

2）Timer 的設計核心是一個 TaskList 和一個 TaskThread。Timer 將接收到的任務丟到自己的 TaskList 中，TaskList 按照 Task 的最初執行時間進行排序。TimerThread 在創建 Timer 時會啓動成爲一個守護線程。這個線程會輪詢所有任務，找到一個最近要執行的任務，然後休眠，當到達最近要執行任務的開始時間點，TimerThread 被喚醒並執行該任務。之後 TimerThread 更新最近一個要執行的任務，繼續休眠。

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

（2）實例

package com.mcc.core.test;

import java.util.Timer;
import java.util.TimerTask;

/**
 * 串行作業調度Timer測試類
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-2-12  下午4:52
 */
public class TimerTest extends TimerTask {
    private String jobName = "";

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

    @Override
    public void run() {
        System.out.println("運行作業： " + jobName + ",開始");
        try {
            TimeUnit.MILLISECONDS.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("運行作業： " + jobName + "，完成");
    }

    public static void main(String args[]){
        Timer timer = new Timer();
        // 從現在開始 5 秒鐘之後，每隔 1 秒鐘執行一次 job1
        timer.schedule(new TimerTest("job1"), 5000, 1000);
        // 從現在開始 1 秒鐘之後，每隔 2 秒鐘執行一次 job2
        timer.schedule(new TimerTest("job2"), 1000, 2000);
    }
}

第1節：併發作業調度ScheduledExecutor

（1）簡介

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

2）ScheduledExecutorService 中兩種最常用的調度方法 ScheduleAtFixedRate 和 ScheduleWithFixedDelay。

ScheduleAtFixedRate 每次執行時間爲上一次任務開始起向後推一個時間間隔，即每次執行時間爲 :initialDelay, initialDelay+period, initialDelay+2*period, …；

ScheduleWithFixedDelay 每次執行時間爲上一次任務結束起向後推一個時間間隔，即每次執行時間爲：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay。

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

（2）實例

package com.mcc.core.test;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 併發任務調度ScheduledExecutor測試類
 *
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-2-12  下午5:05
 */
public class ScheduledExecutorTest implements Runnable{

    private String jobName = "";

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

    @Override
    public void run() {
        System.out.println("運行作業： " + jobName + ",開始");
        try {
            TimeUnit.MILLISECONDS.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("運行作業： " + jobName + "，完成");
    }


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

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

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