1.maven依赖
maven依赖
2. Quartz 核心概念
1.Job 表示一个工作,要执行的具体内容。
2.JobDetail 表示一个具体的可执行的调度程序,Job 是这个可执行程调度程序所要执行的内容,另外 JobDetail 还包含了这个任务调度的方案和策略。
3.Trigger 代表一个调度参数的配置,什么时候去调。
4.Scheduler 代表一个调度容器,一个调度容器中可以注册多个 JobDetail 和 Trigger。当 Trigger 与 JobDetail 组合,就可以被 Scheduler 容器调度了。
jobDetail
Scheduler 通过jobDetail识别将要调用的job的类型,来调用job工作
我们传给scheduler一个JobDetail实例,因为我们在创建JobDetail时,将要执行的job的类名传给了JobDetail,所以scheduler就知道了要执行何种类型的job;每次当scheduler执行job时,在调用其execute(…)方法之前会创建该类的一个新的实例;执行完毕,对该实例的引用就被丢弃了,实例会被垃圾回收;这种执行策略带来的一个后果是,job必须有一个无参的构造函数(当使用默认的JobFactory时);另一个后果是,在job类中,不应该定义有状态的数据属性,因为在job的多次执行中,这些属性的值不会保留。
如果需要有状态的数据属性时,需要用JobDataMap,这个就相当于Map,可以将数据传入job中
JobDataMap
JobDataMap中可以包含不限量的(序列化的)数据对象,在job实例执行的时候,可以使用其中的数据;JobDataMap是Java Map接口的一个实现,额外增加了一些便于存取基本类型的数据的方法。
将job加入到scheduler之前,在构建JobDetail时,可以将数据放入JobDataMap
Trigger 触发器
Job中包含了任务执行的逻辑,Scheduler负责扫描需要执行的Job任务,trigger则定义job何时被执行。
下面对触发器的子类分别进行讲述,我们主要看Trigger的4个可用的派生类,分别是:
org.quartz.SimpleTrigger
org.quartz.CronTrigger (常用)
org.quartz.DateIntervalTrigger
org.quartz.NthIncludedDayTrigger
SimpleTrigger
SimpleTrigger是一种设置和使用简单的触发器,它是在指定日期/时间且可能需要重复执行n次的时机下使用的。这种触发器不适合每天定时执行任务这种场景
它适合的任务类似于:9:00 开始,每隔1小时,每隔几分钟,每隔几秒钟执行一次。
CronTrigger
类似于SimpleTrigger,指定从某一个时间开始,以一定的时间间隔执行的任务。 但是不同的是SimpleTrigger指定的时间间隔为毫秒,没办法指定每隔一个月执行一次(每月的时间间隔不是固定值),而CalendarIntervalTrigger支持的间隔单位有秒,分钟,小时,天,月,年,星期。
它适合的任务类似于:9:00 开始执行,并且以后每周 9:00 执行一次
Cron表达式的格式:秒 分 时 日 月 周 年(可选)
DailyTimeIntervalTrigger
指定每天的某个时间段内,以一定的时间间隔执行任务。并且它可以支持指定星期。
它适合的任务类似于:指定每天9:00 至 18:00 ,每隔70秒执行一次,并且只要周一至周五执行。
NthIncludedDayTrigger
NthIncludedDayTrigger适用于在每一个间隔类型(月或年等)的第N天触发。直接上代码:
它适合的任务类似于:每个月的第10天中午12点整触发
3.代码实现
job 继承QuartzJobBean实现executeInternal方法
4.misfired 策略
对于判定为misfired job,其实有很多条件,目前了解到的有:
1.到执行时间时,上一个任务还未完成;
2.过期时间已超过设置的misfireThreshold;
3.线程池中已没有空闲线程
4.线程池中虽有空闲线程,但有优先级更高的任务
5.服务器停止运行
产生misfire后,会根据设置的misfire策略进行任务的处理。
对CronTrigger来说,有三种misfire策略:
withMisfireHandlingInstructionDoNothing
不触发立即执行,等待下次Cron触发频率到达时刻开始按照Cron频率依次执行
withMisfireHandlingInstructionFireAndProceed
以错过的第一个频率时间立刻开始执行,重做错过的所有频率周期后,当下一次触发频率发生时间大于当前时间后,再按照正常的Cron频率依次执行
withMisfireHandlingInstructionIgnoreMisfires
以当前时间为触发频率立刻触发一次执行,并发执行一次做完,然后按照Cron频率依次执行
5.job、trigger、scheduler监听器
由于quartz没有实现对任务执行情况做记录,所以主要用监听器来实现记录任务的执行情况,记录任务是否被错过,任务具体什么时候被执行,执行过程中是否抛出异常等。
监听器的执行顺序:
SimpleSchedulerListener.java
public class SimpleSchedulerListener extends SchedulerListenerSupport {
private static Logger logger = LoggerFactory.getLogger(SimpleSchedulerListener.class);
@Override
public void jobScheduled(Trigger trigger) {
String jobName = trigger.getJobKey().getName();
logger.info(jobName + " has been scheduled");
}
@Override
public void jobUnscheduled(TriggerKey triggerKey) {
logger.info(triggerKey + " is being unscheduled");
}
@Override
public void triggerFinalized(Trigger trigger) {
logger.info("Trigger is finished for " + trigger.getJobKey().getName());
}
@Override
public void triggerPaused(TriggerKey triggerKey) {
logger.info(triggerKey + " is being paused");
}
@Override
public void triggersPaused(String triggerGroup) {
logger.info("trigger group "+triggerGroup + " is being paused");
}
@Override
public void triggerResumed(TriggerKey triggerKey) {
logger.info(triggerKey + " is being resumed");
}
@Override
public void triggersResumed(String triggerGroup) {
logger.info("trigger group "+triggerGroup + " is being resumed");
}
@Override
public void jobAdded(JobDetail jobDetail) {
logger.info(jobDetail.getKey()+" is added");
}
@Override
public void jobDeleted(JobKey jobKey) {
logger.info(jobKey+" is deleted");
}
@Override
public void jobPaused(JobKey jobKey) {
logger.info(jobKey+" is paused");
}
@Override
public void jobsPaused(String jobGroup) {
logger.info("job group "+jobGroup+" is paused");
}
@Override
public void jobResumed(JobKey jobKey) {
logger.info(jobKey+" is resumed");
}
@Override
public void jobsResumed(String jobGroup) {
logger.info("job group "+jobGroup+" is resumed");
}
@Override
public void schedulerError(String msg, SchedulerException cause) {
logger.error(msg, cause.getUnderlyingException());
}
@Override
public void schedulerInStandbyMode() {
logger.info("scheduler is in standby mode");
}
@Override
public void schedulerStarted() {
logger.info("scheduler has been started");
}
@Override
public void schedulerStarting() {
logger.info("scheduler is being started");
}
@Override
public void schedulerShutdown() {
logger.info("scheduler has been shutdown");
}
@Override
public void schedulerShuttingdown() {
logger.info("scheduler is being shutdown");
}
@Override
public void schedulingDataCleared() {
logger.info("scheduler has cleared all data");
}
}
MonitorTriggerListener.java
public class MonitorTriggerListener extends TriggerListenerSupport {
private static Logger log = LoggerFactory.getLogger(MonitorTriggerListener.class);
@Override
public String getName() {
// TODO Auto-generated method stub
return getClass().getSimpleName();
}
@Override
public void triggerFired(Trigger trigger, JobExecutionContext jobExecutionContext) {
//Trigger 被触发了,此时job上的execute()方法将要被执行
}
@Override
public boolean vetoJobExecution(Trigger trigger, JobExecutionContext jobExecutionContext) {
//trigger被触发后,job将要被执行时Scheduler调用该方法,如返回true则job此次将不被执行
return false;
}
@Override
public void triggerMisfired(Trigger trigger) {
log.info("当前任务为错过任务" );
trigger.getJobDataMap().put("isMisfire",true);
}
@Override
public void triggerComplete(Trigger trigger, JobExecutionContext jobExecutionContext, Trigger.CompletedExecutionInstruction completedExecutionInstruction) {
log.info("Trigger被触发并且完成了job的执行,此方法被调用"+trigger.getJobKey().getName());
}
}
MonitorJobListener.java
public class MonitorJobListener extends JobListenerSupport {
private final static Logger log = LoggerFactory.getLogger(MonitorJobListener.class);
@Override
public String getName() {
return getClass().getSimpleName();
}
/**
* (1)
* 任务执行之前执行
* Called by the Scheduler when a JobDetail is about to be executed (an associated Trigger has occurred).
*/
@Override
public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {
log.info(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"->开始任务:" + jobExecutionContext.getJobDetail().getJobClass().getName());
log.info(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(System.currentTimeMillis()));
Long now = System.currentTimeMillis();
Long jobfire = jobExecutionContext.getScheduledFireTime().getTime();
log.info(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(jobExecutionContext.getScheduledFireTime().getTime()));
if (now - 10000L> jobfire){
log.info("当前任务为错过任务" );
jobExecutionContext.getTrigger().getJobDataMap().put("isMisfire",true);
}else {
jobExecutionContext.getTrigger().getJobDataMap().put("isMisfire",false);
}
jobExecutionContext.getTrigger().getJobDataMap().put("now",now);
}
/**
* (2)
* 这个方法正常情况下不执行,但是如果当TriggerListener中的vetoJobExecution方法返回true时,那么执行这个方法.
* 需要注意的是 如果方法(2)执行 那么(1),(3)这个俩个方法不会执行,因为任务被终止了嘛.
* Called by the Scheduler when a JobDetail was about to be executed (an associated Trigger has occurred),
* but a TriggerListener vetoed it's execution.
*/
@Override
public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {
log.info("========这个方法正常情况下不执行,但是如果当TriggerListener中的vetoJobExecution方法返回true时,那么执行这个方法.==========" + jobExecutionContext.getJobDetail().getJobClass().getName());
}
/**
* (3)
* 任务执行完成后执行,jobException如果它不为空则说明任务在执行过程中出现了异常
* Called by the Scheduler after a JobDetail has been executed, and be for the associated Trigger's triggered(xx) method has been called.
*/
@Override
public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {
//log.info("========任务执行完成后执行,jobException如果它不为空则说明任务在执行过程中出现了异常==========" + getName());
log.info(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"->结束任务任务:" + getName());
Long now = (Long) jobExecutionContext.getTrigger().getJobDataMap().get("now");
System.currentTimeMillis();
JobBo jobService = SpringContextHelp.getBean(JobBo.class);
Long jobfire = jobExecutionContext.getScheduledFireTime().getTime();
String ip_address = Constants.getApplicationValue("applicationContext","servlet.ip.address");
Calendar cr = Calendar.getInstance();
cr.setTimeInMillis(now);
Date d1= cr.getTime();
cr.setTimeInMillis(jobfire);
Date d2 = cr.getTime();
Boolean isMisfire = (Boolean) jobExecutionContext.getTrigger().getJobDataMap().get("isMisfire") == null? false:(Boolean) jobExecutionContext.getTrigger().getJobDataMap().get("isMisfire");
try {
QrtzTaskDetailVo vo = new QrtzTaskDetailVo(jobExecutionContext.getScheduler().getSchedulerName(),
jobExecutionContext.getJobDetail().getKey().getName(),
jobExecutionContext.getJobDetail().getKey().getGroup(),
jobExecutionContext.getTrigger().getKey().getName(),
jobExecutionContext.getTrigger().getKey().getGroup(),
d2,
d1,isMisfire,ip_address);
if (e != null){
log.info(e.getMessage());
vo.setError_detail(e.getMessage());
vo.setFinish_status(2);
}else {
vo.setFinish_status(1);
}
jobService.saveQrtzTaskDetail(vo);
} catch (SchedulerException s) {
s.printStackTrace();
}
}
}
6.Quartz 集群
注意事项
时间同步问题
Quartz实际并不关心你是在相同还是不同的机器上运行节点。当集群放置在不同的机器上时,称之为水平集群。节点跑在同一台机器上时,称之为垂直集群。对于垂直集群,存在着单点故障的问题。这对高可用性的应用来说是无法接受的,因为一旦机器崩溃了,所有的节点也就被终止了。对于水平集群,存在着时间同步问题。
节点用时间戳来通知其他实例它自己的最后检入时间。假如节点的时钟被设置为将来的时间,那么运行中的Scheduler将再也意识不到那个结点已经宕掉了。另一方面,如果某个节点的时钟被设置为过去的时间,也许另一节点就会认定那个节点已宕掉并试图接过它的Job重运行。最简单的同步计算机时钟的方式是使用某一个Internet时间服务器(Internet Time Server ITS)。
节点争抢Job问题
因为Quartz使用了一个随机的负载均衡算法, Job以随机的方式由不同的实例执行。Quartz官网上提到当前,还不存在一个方法来指派(钉住) 一个 Job 到集群中特定的节点。
网友评论