quartz监控日志（一）

骑猪看日落 2022-06-17 04:55 561阅读 0赞

最近几个月，现网总是出现定时器不执行的情况，或者定时器卡死的情况，而又不方便排查，只能依靠quartz的debug日志以及错误日志来监控定时器的执行情况，并且随着我们系统中job越来越多，而使得job问题越来越难以跟踪，所以我们才需要一个能过对定时器进行监控的功能，并能实现线程阻塞告警，以及杀死阻塞线程的功能。

监控job有几种方案：

方案一：通过jmx远程或者直接在应用内部定时获取quartz执行信息，可以新增、修改job、job触发器以及执行情况，但是无法对以前执行的job进行跟踪。

方案二：在job的实现类中记录日志，这个方案太麻烦，因为系统目前有很多job实现类，不可能每个都去添加日志。

方案三：代理job执行类，在初始化时使用代理job执行器。

最后我选择了方案三。

先让我们来分析下源码，目前只针对quartz1.6.0：

首先查看JobRunShell类，这个是定时器的执行类实现了Runnable接口，它有两个空方法如下：

public class JobRunShell implements Runnable {
       public void run() {
          //省略若干代码
                 try {
                    begin();
                } catch (SchedulerException se) {
                    qs.notifySchedulerListenersError("Error executing Job ("
                            + jec.getJobDetail().getFullName()
                            + ": couldn't begin execution.", se);
                    break;
                }
          //省略若干代码
               try {
                    complete(true);
                } catch (SchedulerException se) {
                    qs.notifySchedulerListenersError("Error executing Job ("
                            + jec.getJobDetail().getFullName()
                            + ": couldn't finalize execution.", se);
                    continue;
                }
           }
      protected void begin() throws SchedulerException {
        }
    
        protected void complete(boolean successfulExecution)
            throws SchedulerException {
        }
    
    }

很明显，这里预留了两个方法来监控job的执行情况。

所以我们创建了一个其子类来代理它，在开始时记录日志，结束时更新日志，

public class MonitorJobRunShell extends JobRunShell {
         
        /**    
         * 创建一个新的实例 JobRunShellImpl.  
         * @param jobRunShellFactory
         * @param scheduler
         * @param schdCtxt    
         */
        public MonitorJobRunShell(JobRunShellFactory jobRunShellFactory, Scheduler scheduler, SchedulingContext schdCtxt) {
            super(jobRunShellFactory, scheduler, schdCtxt);
        }
    
        @Override
        protected void begin() throws SchedulerException {
            super.begin();
            try {
                JobDetail jobDetail = jec.getJobDetail();
                quartzLog=getService().insert(jobDetail.getName());
            } catch (Exception e) {
                logger.error("记录job开始时间异常",e);
            }catch (Throwable e) {
                logger.error("记录job开始时间出错",e);
            }
            
        }
    
        @Override
        protected void complete(boolean successfulExecution) throws SchedulerException {
            super.complete(successfulExecution);
            try {
                quartzLog.setExeTime(jec.getJobRunTime());
                getService().update(quartzLog);
            } catch (Exception e) {
                logger.error("记录job结束时间异常",e);
            }catch (Throwable e) {
                logger.error("记录job结束时间出错",e);
            }
        }
    }

创建了该类，必须要让quartz使用我们创建的代理类，这里quartz使用了简单工厂模式，如下

public interface JobRunShellFactory {
 /**
 * 
 * Called by the <code>{@link org.quartz.core.QuartzSchedulerThread}</code>
 * to obtain instances of <code>{@link JobRunShell}</code>.
 * 
 */
 JobRunShell borrowJobRunShell() throws SchedulerException;
 
 }

我们只需要实现该接口，代理原有的std工厂类：

public class StdJobRunShellFactoryProxy implements JobRunShellFactory{
 
 
 /**
 * 
 * Called by the <class>{@link org.quartz.core.QuartzSchedulerThread}
 * </code> to obtain instances of <code>
 * {@link org.quartz.core.JobRunShell}</code>.
 * 
 */
 public JobRunShell borrowJobRunShell() throws SchedulerException {
 return new MonitorJobRunShell(this, scheduler, schedCtxt);
 }
 
 /**
 * 
 * Called by the <class>{@link org.quartz.core.QuartzSchedulerThread}
 * </code> to return instances of <code>
 * {@link org.quartz.core.JobRunShell}</code>.
 * 
 */
 public void returnJobRunShell(JobRunShell jobRunShell) {
 jobRunShell.passivate();
 }
 }

进行到这里，需要使用到我们的工厂代理类，这时候则需要代理入口，即StdSchedulerFactory，

public class StdSchedulerFactoryProxy extends StdSchedulerFactory {
    
        
        /**
         * 初始化Scheduler
         * 同时，替换JobRunShellFactory，并启动清理job日志线程
         * @see org.quartz.impl.StdSchedulerFactory#instantiate(org.quartz.core.QuartzSchedulerResources, org.quartz.core.QuartzScheduler)
         */
        protected Scheduler instantiate(QuartzSchedulerResources rsrcs, QuartzScheduler qs) {
            SchedulingContext schedCtxt = new SchedulingContext();
            schedCtxt.setInstanceId(rsrcs.getInstanceId());
            Scheduler scheduler = new StdScheduler(qs, schedCtxt);
            try {
                JobRunShellFactory jobFactory=new StdJobRunShellFactoryProxy();
                jobFactory.initialize(scheduler, schedCtxt);
                rsrcs.setJobRunShellFactory(jobFactory);
            } catch (SchedulerConfigException e) {
                logger.error("初始化MonitorStdJobRunShellFactory出错",e);
            }
            return scheduler;
        }
    }

最后在初始化Scheduler时使用我们代理的Scheduler工厂类就行，实例如下：

StdSchedulerFactory factory = new StdSchedulerFactoryProxy();

这里我们就实现了自己的quartz监控程序，日志记录方式可以自己扩展。这样可以有效方便的监控job的执行情况，日志中可以记录job的执行时长、线程id等，可以配置阈值如果超时可以在界面上kill该线程。