Quartz-中断正在执行的任务

简介: Quartz-中断正在执行的任务

概述


由于业务需要,停止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 + "\n");
          return; // 也可以选择抛出一个JobExecutionException,根据业务需要指定行为
        }
      }
    } finally {
      System.out.println("【完成任务】key:" + _jobKey + " 完成时间:"
          + sdf.format(new Date()));
    }
  }
  @Override
  public void interrupt() throws UnableToInterruptJobException {
    System.out.println("\n—————— 【中断】外界正在调用调度器停止这个任务key:" + _jobKey
        + " ————————");
    _interrupted = true;
  }
}

调度类

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();
  }
}


运行结果

------- 初始化 ----------------------
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.


示例源码


代码已托管到Github—> https://github.com/yangshangwei/SpringMaster


相关文章
|
Java 调度
Springboot 使用Quartz定时器执行多个定时任务 配置篇
Springboot 使用Quartz定时器执行多个定时任务 配置篇
788 0
Springboot 使用Quartz定时器执行多个定时任务 配置篇
三种方式中断运行的线程?(interrupt 方法)
三种方式中断运行的线程?(interrupt 方法)
98 0
RK3399平台开发系列讲解(中断篇)13.13、中断下半部WorkQueue实现原理
RK3399平台开发系列讲解(中断篇)13.13、中断下半部WorkQueue实现原理
72 0
RK3399平台开发系列讲解(中断篇)13.13、中断下半部WorkQueue实现原理
|
Scala 开发者
循环中断作业评讲|学习笔记
快速学习循环中断作业评讲。
循环中断作业评讲|学习笔记
|
Java 调度 Spring
调度介绍 - Quartz是怎么调起来的
Quartz调度核心类QuartzSchedulerThread,是一个线程。在线程启动后,通过while循环不断去触发作业的执行。ps:源码版本2.3.2,
调度介绍 - Quartz是怎么调起来的
Quartz的Scheduler的关闭和挂起,并发控制(四)下
Quartz的Scheduler的关闭和挂起,并发控制(四)下
478 0
Quartz的Scheduler的关闭和挂起,并发控制(四)下
|
调度 数据库
Quartz的Scheduler的关闭和挂起,并发控制(四)中
Quartz的Scheduler的关闭和挂起,并发控制(四)中
1715 0
Quartz的Scheduler的关闭和挂起,并发控制(四)中
|
调度
Quartz的Scheduler的关闭和挂起,并发控制(四)上
Quartz的Scheduler的关闭和挂起,并发控制(四)上
456 0
Quartz的Scheduler的关闭和挂起,并发控制(四)上
我们该如何正确的中断一个正在执行的线程??
当我们在调用Java对象的wait()方法或者线程的sleep()方法时,需要捕获并处理InterruptedException异常。如果我们对InterruptedException异常处理不当,则会发生我们意想不到的后果!今天,我们就以一个案例的形式,来为大家详细介绍下为何中断执行的线程不起作用。
159 0
【Quartz】定时器初步实验(一)
原文:【Quartz】定时器初步实验(一)     以前就了解了Quartz这个定时框架,但是一直没有认真的去关注他,最近忽然看到已经更新到3.0.4支持异步操作了所以就写个简单的小例子看看好用不。 第一步:创建项目 创建一个新项目,可以是ASP.NET MVC,WebForms,Winforms等多种.Net项目,这里使用的是VS2017,创建了一个MVC项目     创建完成后大致项目层级为:     第二部:引用 我们首先要在项目中引用Quartz.dll。
901 0