Quartz-中断正在执行的任务

最新推荐文章于 2021-04-21 10:45:42 发布
最新推荐文章于 2021-04-21 10:45:42 发布
阅读量3.1w 收藏 20
点赞数 7
分类专栏： 【Quartz任务调度】 文章标签： quartz 中断任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：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 + "\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调度程序停止,java系统中使用调度器Quartz实现对正在执行任务的停止
weixin_39710966的博客
03-11 565
最近在进行数据迁移的任务(就是迁移历史数据)，数据量很大，需要运行几个月才能运行完。要求是每天的非工作时间定时进行迁移，正常上班的时间自动停止。自然就想到了使用Quartz来执行定时任务。每天定时的启动任务是没有问题的，Quartz本来就是干这个事情的。但是如何让正在执行的任务定时关闭呢？通过在网上搜查资料发现了停止执行任务的代码如下：public static void removeJob(St...
java quartz 停止_Quartz 定时任务使用 —— 中断正在执行的任务（九）
weixin_31083103的博客
02-24 6967
由于业务需要，停止Quartz中正在执行的任务1、任务类只需要实现InterruptableJob类，然后实现interrupt()方法。2、在这个方法中进行标记的改变，在执行中进行这个标记判断，就可实现中断任务了3、另外在调度器上调用方法：sched.interrupt(job.getKey())源码示例：job类package com.anson.examples.example7;impor...
Quartz调度、终止执行的任务
08-07
使用Quartz调度任务，根据需要人为的终止某个任务，适用于很多常见的场景
Quartz执行逻辑（七）任务的暂停和恢复
卷福。的博客
04-21 7239
Quartz执行逻辑（七）任务的暂停和恢复1.简介2.暂停与恢复任务2.1暂停任务2.2恢复任务 1.简介 前面在Quartz执行逻辑（一）中说到trigger的状态是WAITING的，会在目标时间被触发，所以暂停与恢复任务自然是修改了trigger的状态。 2.暂停与恢复任务 2.1暂停任务 暂停任务时通过调用Scheduler的pauseJob方法来实现这个操作。这个方法一直向下调用到了JobStoreSupport中的pauseJob方法。该方法中是对任务的trigger进行操作的，也证实了前面的猜想
java quartz 停止正在进行的任务解决方案
就要嗨翻天
05-31 1万+
新建的Job实现InterruptableJob，在Job中实现interrupt()方法。如下：   public abstract class TestJob implements InterruptableJob { private boolean _interrupted = false; @Override public void interrupt() throw
java系统中使用调度器Quartz实现对正在执行任务的停止
热门推荐
ykp的专栏
03-06 1万+
最近在进行数据迁移的任务（就是迁移历史数据），数据量很大，需要运行几个月才能运行完。要求是每天的非工作时间定时进行迁移，正常上班的时间自动停止。自然就想到了使用Quartz来执行定时任务。每天定时的启动任务是没有问题的，Quartz本来就是干这个事情的。但是如何让正在执行的任务定时关闭呢？通过在网上搜查资料发现了停止执行任务的代码如下： public static void removeJob
java quartz 停止_quartz终止正在运行的任务
weixin_33883104的博客
02-16 898
importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importjava.net.URL;importjava.nio.ByteBuffer;importjava.nio.channels.Channels;importjava.nio.channels.ClosedByInterruptExcep...
Spring 3整合Quartz 2实现定时任务三：动态暂停 恢复 修改和删除任务
black_fuck的专栏
05-14 1144
前面我们已经完成了spring 3和quartz 2的整合以及动态添加定时任务，我们接着来完善它，使之能支持更多的操作，例如暂停、恢复、修改等。 在动态添加定时任务中其实已经涉及到了其中的一些代码，这里我们再来细化的理一理。先来看一下我们初步要实现的目标效果图，这里我们只在内存中操作，并没有把quartz的任何信息保存到数据库，即使用的是RAMJobStore，当然如果你有需要，可以实现成J
Quartz.NET学习系列(六)--- 中断任务
Eye_cng的专栏
03-14 3572
Quartz.NET的任务除了继承IJob之外，还可以继承IInterruptableJob。IInterruptableJob为可中断任务，相对于IJob多了个Interrupt接口实现，用于捕获中断事件， 当某个任务中断时，可调用Interrupt进行实际的业务处理。         具体代码如下： public class DumbInterruptableJob :
Java实现终止线程池中正在运行的定时任务
08-27
本篇文章给大家分享了JAVA中实现终止线程池中正在运行的定时任务的具体步骤和方法，有需要的朋友跟着学习下。
C# Quartz.Net定时任务操作明细、完整过程
07-14
**间隔执行任务**：如果需要每隔一段时间执行一次任务，可以使用`CalendarIntervalScheduleBuilder`，例如每隔3秒执行一次： ```csharp var builder = CalendarIntervalScheduleBuilder.Create(); builder....
quartz终止正在运行的任务
weixin_33763244的博客
10-24 838
import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.net.URL; import java.nio.ByteBuffer; import java.nio.channels.Channels; import java.nio.channels.C...
Quartz之InterruptableJob
笨笨
04-06 2071
问题1 由于业务需要,停止Quartz中正在执行的任务 Quartz:你的任务类只需要实现InterruptableJob类就可以了 只要实现一个方法:interrupt(),在这个方法中进行标记的改变,在执行中进行这个标记判断 就可实现中断任务了,另外在调度器上调用方法：sched.interrupt(job.getKey()); 在查看Quartz文档中已经有说明了,如下：  J...
quartz InterruptableJob
//Case
02-04 1365
有停止功能的job; 有时候我们需要在任务执行的时候, 中途停止, 这时候就可以用InterruptableJob来实现
Quartz停止正在运行的Job
传说中的未来之路......
02-07 2725
Job的重复次数如果只有1次，那么就没有办法对其过程进行操作，如：不能暂停 停止等，或者说是没有意义。 job每重复一次是quartz的最小单元。 如果重复次数大于1，到点击停止时为止，后面的次数就不执行了。这样做对于那些只需要执行一次的Job就不太公平了。 只能采用这样方式来停止仅重复一次的Job了： 让你的job实现InterruptableJob类，在实现类里构造interrupt()方法，...
quartz2.3.0（七）调度器中断任务执行，手动处理任务中断事件
weixin_30859423的博客
07-14 433
job任务类 package org.quartz.examples.example7; import java.util.Date; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.quartz.InterruptableJob; import org.quartz.JobExecut...
quartz停止正在执行的任务
最新发布
06-03
要停止 Quartz 中正在执行的任务，可以使用以下步骤： 1. 获取 Scheduler 对象。 2. 使用 getCurrentlyExecutingJobs() 方法获取当前正在执行的 JobDetail 对象列表。 3. 遍历 JobDetail 对象列表，找到你想要停止的任务。 4. 获取任务的 JobKey 对象。 5. 调用 Scheduler 对象的 interrupt() 方法并传入该 JobKey 对象，以停止该任务的执行。 以下是示例代码： ``` Scheduler scheduler = ...; // 获取 Scheduler 对象 List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs(); // 获取当前正在执行的 JobDetail 对象列表 for (JobExecutionContext executingJob : executingJobs) { JobDetail jobDetail = executingJob.getJobDetail(); JobKey jobKey = jobDetail.getKey(); if ("myJobName".equals(jobKey.getName()) && "myJobGroup".equals(jobKey.getGroup())) { scheduler.interrupt(jobKey); // 停止该任务的执行 } } ``` 注意：调用 interrupt() 方法并不会立即停止任务的执行，而是会向任务发送中断信号。任务需要在执行过程中检测中断信号并自行停止执行。因此，你需要在任务的 execute() 方法中添加中断信号检测的逻辑。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值