java定时任务管理系统开源_定时任务管理系统(Quartz和Spring的整合)开源和源码简述（四）...

利用学习的时间这里写了个Spring和Quartz结合的一个web项目，纯后端的项目，restful接口

实现对定时任务的增、删、改、查、停止， 启动、定时规则修改、立即执行等。github地址:holly-quartz-web,这里刚开始是为了学习源码，后来有了一些改动，再后来就想做一些业务上的改造，所以clone了一个quartz-core的项目进行改造，后期打算对其集群方式进行改造等等。github地址:quartz-core,有一起感兴趣的朋友可以一起改造，目前的项目比较简单可以作为学习入门的项目，也可以作为搭建job管理系统的初期项目，慢慢迭代。

三的时候讲到了QuartzSchedulerThread这个类，QuartzSchedulerThread是主处理线程，在三的时候我们发现创建Scheduler的时候已经启动了该线程。它作为一个非守护线程运行在正常优先级下。

看一下该类的run方法

public void run() {

boolean lastAcquireFailed = false;

//

while (!halted.get()) {

try {

// check if we're supposed to pause...

synchronized (sigLock) {

while (paused && !halted.get()) {

try {

// wait until togglePause(false) is called...

sigLock.wait(1000L);

} catch (InterruptedException ignore) {

}

}

if (halted.get()) {

break;

}

}

/获取当前线程池中线程的数量

int availThreadCount = qsRsrcs.getThreadPool().blockForAvailableThreads();

if(availThreadCount > 0) { // will always be true, due to semantics of blockForAvailableThreads...

List triggers = null;

long now = System.currentTimeMillis();

clearSignaledSchedulingChange();

try {

//调度器在trigger队列中寻找30秒内一定数目的trigger准备执行调度,

//参数1:nolaterthan = now+3000ms,参数2 最大获取数量,大小取线程池线程剩余量与定义值得较小者

//参数3 时间窗口 默认为0,程序会在nolaterthan后加上窗口大小来选择trigger

triggers = qsRsrcs.getJobStore().acquireNextTriggers(

now + idleWaitTime, Math.min(availThreadCount, qsRsrcs.getMaxBatchSize()), qsRsrcs.getBatchTimeWindow());

//上一步获取成功将失败标志置为false;

lastAcquireFailed = false;

if (log.isDebugEnabled())

log.debug("batch acquisition of " + (triggers == null ? 0 : triggers.size()) + " triggers");

} catch (JobPersistenceException jpe) {

if(!lastAcquireFailed) {

qs.notifySchedulerListenersError(

"An error occurred while scanning for the next triggers to fire.",

jpe);

}

//捕捉到异常则值标志为true,再次尝试获取

lastAcquireFailed = true;

continue;

} catch (RuntimeException e) {

if(!lastAcquireFailed) {

getLog().error("quartzSchedulerThreadLoop: RuntimeException "

+e.getMessage(), e);

}

lastAcquireFailed = true;

continue;

}

if (triggers != null && !triggers.isEmpty()) {

now = System.currentTimeMillis();

long triggerTime = triggers.get(0).getNextFireTime().getTime();

long timeUntilTrigger = triggerTime - now;//计算距离trigger触发的时间

while(timeUntilTrigger > 2) {

synchronized (sigLock) {

if (halted.get()) {

break;

}

//如果这时调度器发生了改变,新的trigger添加进来,那么有可能新添加的trigger比当前待执行的trigger

//更急迫,那么需要放弃当前trigger重新获取,然而,这里存在一个值不值得的问题,如果重新获取新trigger

//的时间要长于当前时间到新trigger出发的时间,那么即使放弃当前的trigger,仍然会导致xntrigger获取失败,

//但我们又不知道获取新的trigger需要多长时间,于是,我们做了一个主观的评判,若jobstore为RAM,那么

//假定获取时间需要7ms,若jobstore是持久化的,假定其需要70ms,当前时间与新trigger的触发时间之差小于

// 这个值的我们认为不值得重新获取,返回false

//这里判断是否有上述情况发生,值不值得放弃本次trigger,若判定不放弃,则线程直接等待至trigger触发的时刻

if (!isCandidateNewTimeEarlierWithinReason(triggerTime, false)) {

try {

// we could have blocked a long while

// on 'synchronize', so we must recompute

now = System.currentTimeMillis();

timeUntilTrigger = triggerTime - now;

if(timeUntilTrigger >= 1)

sigLock.wait(timeUntilTrigger);

} catch (InterruptedException ignore) {

}

}

}

//该方法调用了上面的判定方法,作为再次判定的逻辑

//到达这里有两种情况1.决定放弃当前trigger,那么再判定一次,如果仍然有放弃,那么清空triggers列表并

// 退出循环 2.不放弃当前trigger,且线程已经wait到trigger触发的时刻,那么什么也不做

if(releaseIfScheduleChangedSignificantly(triggers, triggerTime)) {

break;

}

now = System.currentTimeMillis();

timeUntilTrigger = triggerTime - now;

//这时触发器已经即将触发,值会<2

}

// this happens if releaseIfScheduleChangedSignificantly decided to release triggers

if(triggers.isEmpty())

continue;

// set triggers to 'executing'

List bndles = new ArrayList();

boolean goAhead = true;

synchronized(sigLock) {

goAhead = !halted.get();

}

if(goAhead) {

try {

//触发triggers,结果付给bndles,注意,从这里返回后,trigger在数据库中已经经过了锁定,解除锁定,这一套过程

//所以说,quratz定不是等到job执行完才释放trigger资源的占有,而是读取完本次触发所需的信息后立即释放资源

//然后再执行jobs

List res = qsRsrcs.getJobStore().triggersFired(triggers);

if(res != null)

bndles = res;

} catch (SchedulerException se) {

qs.notifySchedulerListenersError(

"An error occurred while firing triggers '"

+ triggers + "'", se);

//QTZ-179 : a problem occurred interacting with the triggers from the db

//we release them and loop again

for (int i = 0; i < triggers.size(); i++) {

qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));

}

continue;

}

}

//迭代trigger的信息,分别跑job

for (int i = 0; i < bndles.size(); i++) {

TriggerFiredResult result = bndles.get(i);

TriggerFiredBundle bndle = result.getTriggerFiredBundle();

Exception exception = result.getException();

if (exception instanceof RuntimeException) {

getLog().error("RuntimeException while firing trigger " + triggers.get(i), exception);

qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));

continue;

}

// it's possible to get 'null' if the triggers was paused,

// blocked, or other similar occurrences that prevent it being

// fired at this time... or if the scheduler was shutdown (halted)

//在特殊情况下,bndle可能为null,看triggerFired方法可以看到,当从数据库获取trigger时,如果status不是

//STATE_ACQUIRED,那么会直接返回空.quratz这种情况下本调度器启动重试流程,重新获取4次,若仍有问题,

// 则抛出异常.

if (bndle == null) {

qsRsrcs.getJobStore().releaseAcquiredTrigger(triggers.get(i));

continue;

}

//执行job

JobRunShell shell = null;

try {

//创建一个job的Runshell

shell = qsRsrcs.getJobRunShellFactory().createJobRunShell(bndle);

shell.initialize(qs);

} catch (SchedulerException se) {

qsRsrcs.getJobStore().triggeredJobComplete(triggers.get(i), bndle.getJobDetail(), CompletedExecutionInstruction.SET_ALL_JOB_TRIGGERS_ERROR);

continue;

}

//把runShell放在线程池里跑

if (qsRsrcs.getThreadPool().runInThread(shell) == false) {

// this case should never happen, as it is indicative of the

// scheduler being shutdown or a bug in the thread pool or

// a thread pool being used concurrently - which the docs

// say not to do...

getLog().error("ThreadPool.runInThread() return false!");

qsRsrcs.getJobStore().triggeredJobComplete(triggers.get(i), bndle.getJobDetail(), CompletedExecutionInstruction.SET_ALL_JOB_TRIGGERS_ERROR);

}

}

continue; // while (!halted)

}

} else { // if(availThreadCount > 0)

// should never happen, if threadPool.blockForAvailableThreads() follows contract

continue; // while (!halted)

}

//保证负载平衡的方法,每次执行一轮触发后,本scheduler会等待一个随机的时间,这样就使得其他节点上的scheduler可以得到资源.

long now = System.currentTimeMillis();

long waitTime = now + getRandomizedIdleWaitTime();

long timeUntilContinue = waitTime - now;

synchronized(sigLock) {

try {

if(!halted.get()) {

// QTZ-336 A job might have been completed in the mean time and we might have

// missed the scheduled changed signal by not waiting for the notify() yet

// Check that before waiting for too long in case this very job needs to be

// scheduled very soon

if (!isScheduleChanged()) {

sigLock.wait(timeUntilContinue);

}

}

} catch (InterruptedException ignore) {

}

}

} catch(RuntimeException re) {

getLog().error("Runtime error occurred in main trigger firing loop.", re);

}

} // while (!halted)

// drop references to scheduler stuff to aid garbage collection...

qs = null;

qsRsrcs = null;

}

QuartzSchedulerThread 的主处理轮循步骤：

检查是否为scheuler是否为停止状态

检查是否为暂停状态，暂停的话会尝试去获得信号锁，并wait一会，这里算是乐观锁方式吧，直到获得锁并重新运行。

从线程池获取可用的线程(will always be true, due to semantics of blockForAvailableThreads...)

获取需要下次执行的triggers

根据一些条件过滤下triggers

根据triggers获取或者创建job并构建JobRunShell

利用线程池里面的线程去执行job(qsRsrcs.getThreadPool().runInThread(shell))

数据库release正在执行的job

去检查job是否在执行的时候变更了(如果变为现在需要立即执行那就不在做等待了 QTZ-336 A job might have been completed in the mean time and we might have missed the scheduled changed signal by not waiting for the notify() yet Check that before waiting for too long in case this very job needs to be scheduled very soon)

while (!halted)

基本的大致操作就是这样，在细节中涉及到分布式的实现。我们现在来看线quzrtz的分布式实现方式

总体来说是借助数据库

摘自网络，但愿原作者莫怪

借助的语句是 select for update 操作

表示QUARTZ_LOCKS表。每个sheduler会有两行数据

数据库表记录

多个Quartz服务器去获取trigger节点的时候 会锁住TRIGGER_ACCESS这行记录，别的节点获得不到后就会发现已经有别的服务器节点处理了这个Scheduler 所以不需要自己执行了。

另一行记录是 在执行Trigger对应的Job的时候 状态变更的一个锁。因为假如某一次执行的时间过长，下一次执行过来的时候上一次还没执行完，那么久需要等待在这里。 这两个条记录就实现了分布式。多么美好的事情。哈哈哈

在网上别人博客找到的组件图和时序图 我觉得相当细致和完整贴过来。

组件图原作者莫怪

时序图原作者莫怪