quartz2.3.0（十一）任務執行中故障情況，可設置重新執行任務

任務類

package org.quartz.examples.example11;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;

/**
 * job任務類
 */
public class SimpleJob implements Job {

    private static Logger LOG = LoggerFactory.getLogger(SimpleJob.class);

    // job parameter
    public static final String DELAY_TIME = "delay time";

    //必須要有public修飾的無參構造函數
    public SimpleJob() {
    }

    // 任務執行方法
    public void execute(JobExecutionContext context) throws JobExecutionException {

        JobKey jobKey = context.getJobDetail().getKey();
        LOG.info("執行任務開始：" + jobKey + " executing at " + new Date());

        // 等待一段時間delayTime毫秒
        long delayTime = context.getJobDetail().getJobDataMap().getLong(DELAY_TIME);
        try {
            Thread.sleep(delayTime);
        } catch (Exception e) {
            //
        }

        LOG.info("執行任務結束：" + jobKey + " at " + new Date());
    }

}

 

調度器類

package org.quartz.examples.example11;

import static org.quartz.DateBuilder.futureDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

import org.quartz.DateBuilder.IntervalUnit;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SchedulerMetaData;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 這個示例將生成大量要運行的作業
 */
public class LoadExample {

    // 初始化job任務個數
    private int _numberOfJobs = 500;

    public LoadExample(int inNumberOfJobs) {
        _numberOfJobs = inNumberOfJobs;
    }

    public void run() throws Exception {
        Logger LOG = LoggerFactory.getLogger(LoadExample.class);

        // 初始化一個調度工廠，並實例化一個調度類
        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler sched = sf.getScheduler();

        // 計划運行500個作業
        for (int count = 1; count <= _numberOfJobs; count++) {
            // requestRecovery：請調度程序重新執行此作業，如果該作業在調度程序宕機時正在進行中…
            //requestRecovery：指示調度程序，如果遇到“恢復”或“故障轉移”情況，是否應重新執行作業。如果沒有顯式設置，則默認值為false
            JobDetail job = newJob(SimpleJob.class).withIdentity("job" + count, "group_1").requestRecovery().build();

            // 讓工作人員推遲一點時間……模擬工作……
            long timeDelay = (long) (java.lang.Math.random() * 2500);
            job.getJobDataMap().put(SimpleJob.DELAY_TIME, timeDelay); //隨機數

            //每個觸發器的啟動時間都間隔100毫秒，相距時間非常短
            Trigger trigger = newTrigger().withIdentity("trigger_" + count, "group_1")
                    .startAt(futureDate((10000 + (count * 100)), IntervalUnit.MILLISECOND))
                    .build();

            sched.scheduleJob(job, trigger);
            if (count % 25 == 0) {
                LOG.info("...scheduled " + count + " jobs");
            }
        }
        
        sched.start();
        LOG.info("------- Waiting one minutes... -----------");

        // 等一分鍾，展示job任務的定時打印
        try {
            Thread.sleep(60L * 1000L);
        } catch (Exception e) {
            //
        }

        sched.shutdown(true);
        LOG.info("------- Shutdown Complete -----------------");

        SchedulerMetaData metaData = sched.getMetaData();
        LOG.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");
    }

    public static void main(String[] args) throws Exception {

        int numberOfJobs = 500;
        if (args.length == 1) {
            numberOfJobs = Integer.parseInt(args[0]);
        }
        if (args.length > 1) {
            System.out.println("Usage: java " + LoadExample.class.getName() + "[# of jobs]");
            return;
        }
        LoadExample example = new LoadExample(numberOfJobs);
        example.run();
    }

}