Quartz-中断正在执行的任务
【摘要】
文章目录
概述示例示例源码
概述
由于业务需要，停止Quartz中正在执行的任务
任务类只需要实现InterruptableJob类，然后实现interrupt()方法。 在这个方法...
概述
由于业务需要，停止Quartz中正在执行的任务
-
任务类只需要实现InterruptableJob类，然后实现interrupt()方法。
-
在这个方法中进行标记的改变，在执行中进行这个标记判断，就可实现中断任务了
-
另外在调度器上调用方法：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;
}
}
- 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
文章来源: artisan.blog.csdn.net，作者：小小工匠，版权归原作者所有，如需转载，请联系作者。
原文链接：artisan.blog.csdn.net/article/details/78545158
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）