zoukankan      html  css  js  c++  java

  • Quartz-中断正在执行的任务

    转：

    Quartz-中断正在执行的任务

    2017年11月15日 21:19:17 阅读数：6715更多
    所属专栏： Quartz手札
     
    版权声明：【show me the code ,change the world】 https://blog.csdn.net/yangshangwei/article/details/78545158

    概述

    由于业务需要，停止Quartz中正在执行的任务

    1. 任务类只需要实现InterruptableJob类，然后实现interrupt()方法。

    2. 在这个方法中进行标记的改变，在执行中进行这个标记判断，就可实现中断任务了

    3. 另外在调度器上调用方法：sched.interrupt(job.getKey())

    示例

    job类

    package com.xgj.quartz.quartzItself.interruptableJob;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.InterruptableJob;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.UnableToInterruptJobException;

/**
 * 
 * 
 * @ClassName: DumbInterruptableJob
 * 
 * @Description: 个可执行的中断可执行程序，用于单元测试。
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年11月15日 上午9:26:36
 */

public class DumbInterruptableJob implements InterruptableJob {

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private boolean _interrupted = false; // job 是否中断
    private JobKey _jobKey = null; // job name

    private static int counts = 0; // 中断执行次数

    @Override
    public void execute(JobExecutionContext context)
            throws JobExecutionException {

        _jobKey = context.getJobDetail().getKey();

        System.out.println("【开始执行】任务Key：" + _jobKey + "，执行时间： "
                + sdf.format(new Date()));

        try {

            for (int i = 0; i < 4; i++) {
                try {
                    Thread.sleep(1000L);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                // 查看是否中断
                if (_interrupted) {
                    counts++;
                    System.out.println("被外界因素停止了这个任务key：" + _jobKey
                            + ",中断累计次数: " + counts + "
");
                    return; // 也可以选择抛出一个JobExecutionException，根据业务需要指定行为
                }
            }

        } finally {
            System.out.println("【完成任务】key：" + _jobKey + " 完成时间："
                    + sdf.format(new Date()));
        }

    }

    @Override
    public void interrupt() throws UnableToInterruptJobException {
        System.out.println("
—————— 【中断】外界正在调用调度器停止这个任务key：" + _jobKey
                + " ————————");
        _interrupted = true;

    }

}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76

    调度类

    package com.xgj.quartz.quartzItself.interruptableJob;

import static org.quartz.DateBuilder.nextGivenSecondDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SchedulerMetaData;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 
 * 
 * @ClassName: InterruptExample
 * 
 * @Description: 调度类
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年11月15日 上午9:28:21
 */

public class InterruptExample {

    public void run() throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        System.out.println("------- 初始化 ----------------------");

        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler sched = sf.getScheduler();

        // 下一个15秒
        Date startTime = nextGivenSecondDate(null, 15);

        // 当前时间15秒后,每间隔5秒执行一次任务
        JobDetail job = newJob(DumbInterruptableJob.class).withIdentity(
                "interruptableJob1", "group1").build();
        SimpleTrigger trigger = newTrigger()
                .withIdentity("trigger1", "group1")
                .startAt(startTime)
                .withSchedule(
                        simpleSchedule().withIntervalInSeconds(5)
                                .repeatForever()).build();

        Date ft = sched.scheduleJob(job, trigger);
        System.out.println(job.getKey() + " 将运行于：" + sdf.format(ft) + " 并重复："
                + trigger.getRepeatCount() + " 次，间隔 "
                + trigger.getRepeatInterval() / 1000 + " 秒");

        // 调度开始执行
        sched.start();
        System.out.println("------- 开始调度 (调用.start()方法) ----------------");

        System.out.println("------- 每7秒钟启动一次中断任务（10次中断） ----------");
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(7000L);

                // 手动中断调度器中的job
                sched.interrupt(job.getKey());

            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        System.out.println("------- 关闭调度 ---------------------");

        sched.shutdown(true);

        System.out.println("------- 关闭调度器完成 -----------------");
        SchedulerMetaData metaData = sched.getMetaData();

        System.out.println("~~~~~~~~~~  执行了 "
                + metaData.getNumberOfJobsExecuted() + " 个 jobs.");

    }

    public static void main(String[] args) throws Exception {
        InterruptExample example = new InterruptExample();
        example.run();
    }
}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92

    运行结果

    ------- 初始化 ----------------------
INFO  StdSchedulerFactory - Using default implementation for ThreadExecutor
INFO  SimpleThreadPool - Job execution threads will use class loader of thread: main
INFO  SchedulerSignalerImpl - Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl
INFO  QuartzScheduler - Quartz Scheduler v.2.2.3 created.
INFO  RAMJobStore - RAMJobStore initialized.
INFO  QuartzScheduler - Scheduler meta-data: Quartz Scheduler (v2.2.3) 'DefaultQuartzScheduler' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.

INFO  StdSchedulerFactory - Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties'
INFO  StdSchedulerFactory - Quartz scheduler version: 2.2.3
group1.interruptableJob1 将运行于：2017-11-15 09:29:45 并重复：-1 次，间隔 5 秒
INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
------- 开始调度 (调用.start()方法) ----------------
------- 每7秒钟启动一次中断任务（10次中断） ----------
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:29:45

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 1

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:29:49
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:29:50
【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:29:54
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:29:55

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 2

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:29:56
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:00

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 3

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:03
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:05
【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:09
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:10
【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:14
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:15

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 4

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:17
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:20

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 5

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:24
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:25
【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:29
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:30

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 6

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:31
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:35

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 7

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:38
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:40
【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:44
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:45
【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:49
【开始执行】任务Key：group1.interruptableJob1，执行时间： 2017-11-15 09:30:50

—————— 【中断】外界正在调用调度器停止这个任务key：group1.interruptableJob1 ————————
------- 关闭调度 ---------------------
INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutting down.
INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED paused.
被外界因素停止了这个任务key：group1.interruptableJob1,中断累计次数: 8

【完成任务】key：group1.interruptableJob1 完成时间：2017-11-15 09:30:52
INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutdown complete.
------- 关闭调度器完成 -----------------
~~~~~~~~~~  执行了 14 个 jobs.
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87

    示例源码

    代码已托管到Github—> https://github.com/yangshangwei/SpringMaster
  • 相关阅读:
    剑指offer——最小的K个数和数组中第K大的元素
    Leetcode刷题指南链接整理
    160. Intersection of Two Linked Lists
    100. Same Tree
    92. Reverse Linked List II
    94. Binary Tree Inorder Traversal
    79. Word Search
    78，90，Subsets，46，47，Permutations，39,40 DFS 大合集
    0x16 Tire之最大的异或对
    0x16 Tire
  • 原文地址：https://www.cnblogs.com/libin6505/p/10571523.html
Copyright © 2011-2022 走看看