quartz使用（二）任务的删除，停止，暂停，启动

在上一篇文章中，介绍了quartz简单的使用方法，没有看过的可以查看https://editor.csdn.net/md/?articleId=102677404
这一篇介绍关于任务的启动停止这些操作，废话不多说。

任务启动停止

启动任务

    void start() throws SchedulerException;  //	启动任务

停止任务

    void shutdown() throws SchedulerException;   //直接关闭Scheduler
    void shutdown(boolean waitForJobsToComplete)throws SchedulerException;
      //shutdown(true)表示等待所有正在执行的任务执行完毕后关闭Scheduler
      //shutdown(false),即shutdown()表示直接关闭Scheduler

任务的启动这里就不再测试了，参照上一篇的文章写即可
先写一个实现类

public class QuartzJob1 implements Job {
    public static int times = 0;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("QuartzJob1--" + new Date() + "---实现业务逻辑----" + times++ + "------");
    }
}

以下是测试停止的方法：

public class QuartzJobUtil {

    //使用默认的配置
    private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();

    public static void addJob(String jobName, String jobGroupName, int time, Class <? extends Job> jobClass) {

        //创建任务
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
        //创建触发器 每 5 秒钟执行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroupName)
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(time).repeatForever())
                .build();
        try {
            //获取实例化的 Scheduler。
            Scheduler scheduler = getScheduler();
            //将任务及其触发器放入调度器
            scheduler.scheduleJob(jobDetail, trigger);
            //调度器开始调度任务
            if (!scheduler.isShutdown()) {
                scheduler.start();
                System.out.println(String.format("启动任务，jobName：%s ,jobGroupName:%s",jobName ,jobGroupName));
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    //获取一个默认的Scheduler对象
    private static Scheduler getScheduler() {
        try {
            return schedulerFactory.getScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return null;
    }

    //停止任务--再启动需要从新初始化
    public static void stopScheduler(){
        Scheduler scheduler = getScheduler();
        try {
            /**
             *  shutdown(true)表示等待所有正在执行的任务执行完毕后关闭Scheduler
             *  shutdown(false),即shutdown()表示直接关闭Scheduler
             */
            scheduler.shutdown();
            System.out.println("------停止任务----");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
//暂停所有任务执行
    public static void standbyScheduler() {
        Scheduler scheduler = getScheduler();
        try {
            scheduler.standby();
            System.out.println("-----暂停任务----");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    public void deleteJob(String jobName, String jobGroupName){
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
            Scheduler scheduler = getScheduler();
            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
            System.out.println(String.format("删除任务，jobName：%s ,jobGroupName:%s",jobName ,jobGroupName));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

这里就不展示结果了，但是通过测试可以得到，一旦shutDown(),，就不能直接通过start()直接启动了，需要从新实例化Scheduler传出定时任务配置，再start()才能从新启动。如果使用的是standBy(),则可以直接通过start()直接启动任务。

暂停和从新启动Job

暂停任务：

/**
*@see #resumeJob(JobKey)
*/
void pauseJob(JobKey jobKey) throws SchedulerException;
/**
*@see #resumeJobs(org.quartz.impl.matchers.GroupMatcher)
*/
void pauseJobs(GroupMatcher<JobKey> matcher) throws SchedulerException;
    /**
     * Pause the <code>{@link Trigger}</code> with the given key.
     * 
     * @see #resumeTrigger(TriggerKey)
     */
void pauseTrigger(TriggerKey triggerKey) throws SchedulerException;
/**
*@see #resumeTriggers(org.quartz.impl.matchers.GroupMatcher)
*/
void pauseTriggers(GroupMatcher<TriggerKey> matcher) throws SchedulerException;

   /** @see #resumeAll()
     * @see #pauseTriggers(org.quartz.impl.matchers.GroupMatcher)
     * @see #standby()
     */
    void pauseAll() throws SchedulerException;

从新启动定时job

   /** 
     * @param matcher The matcher to evaluate against known paused groups
     * @see #pauseJobs(GroupMatcher)
     */
    void resumeJobs(GroupMatcher<JobKey> matcher) throws SchedulerException;

    /**
     * 
     * @see #pauseTrigger(TriggerKey)
     */
    void resumeTrigger(TriggerKey triggerKey)
        throws SchedulerException;

    /**
     * @param matcher The matcher to evaluate against know paused groups
     * @see #pauseTriggers(org.quartz.impl.matchers.GroupMatcher)
     */
    void resumeTriggers(GroupMatcher<TriggerKey> matcher) throws SchedulerException;
	/**
     * @see #pauseAll()
     */
    void resumeAll() throws SchedulerException;

实现：

//停止其中的任务
    public static void pauseJob(String jobName, String jobGroupName){
        Scheduler scheduler = getScheduler();
        try {
            scheduler.pauseJob(JobKey.jobKey(jobName, jobGroupName));
            System.out.println(String.format("暂停任务，jobName：%s ,jobGroupName:%s",jobName ,jobGroupName));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    //从新开始任务
    public static void restartJob(String jobName, String jobGroupName){
        Scheduler scheduler = getScheduler();
        JobKey jobKey = JobKey.jobKey(jobName,jobGroupName);
        try {
            scheduler.resumeJob(jobKey);
            System.out.println(String.format("从新启动job,，jobName：%s ,jobGroupName:%s",jobName ,jobGroupName));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }