【Quartz实战】quartz-2.2.3源码分析

一、quartz简介

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合(Spring集成Quartz的介绍)也可以单独使用。Quartz可以用来创建简单或为运行十个,百个,甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.2.3。

 

二、quartz的单独使用

Quartz是一个完全由java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能, 但就其简易形式看,你会发现它易用得简直让人受不了!。简单地创建一个实现org.quartz.Job接口的java类。Job接口包含唯一的方法:
public void execute(JobExecutionContext context)
throws JobExecutionException;
在你的Job接口实现类里面,添加一些逻辑到execute()方法。一旦你配置好Job实现类并设定好调度时间表,Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候,Quartz框架将调用你Job实现类(作业类)上的execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用,Quartz框架将在恰当的时间再次调用它。
 
示例如下: HelloJob
/**
 * <p>
 * This is just a simple job that says "Hello" to the world.
 * </p>
 * 
 */
public class HelloJob implements Job {

    private static Logger _log = LoggerFactory.getLogger(HelloJob.class);

    /**
     * <p>
     * Empty constructor for job initilization
     * </p>
     * <p>
     * Quartz requires a public empty constructor so that the
     * scheduler can instantiate the class whenever it needs.
     * </p>
     */
    public HelloJob() {
    }

    /**
     * <p>
     * Called by the <code>{@link org.quartz.Scheduler}</code> when a
     * <code>{@link org.quartz.Trigger}</code> fires that is associated with
     * the <code>Job</code>.
     * </p>
     * 
     * @throws JobExecutionException
     *             if there is an exception while executing the job.
     */
    public void execute(JobExecutionContext context)
        throws JobExecutionException {

        // Say Hello to the World and display the date/time
        _log.info("Hello World! - " + new Date());
    }

}
 
设置触发器
/**
 * This Example will demonstrate how to start and shutdown the Quartz scheduler and how 
 *to schedule a job to run in
 * Quartz.
 * 
 */
public class SimpleExample {

  public void run() throws Exception {
    Logger log = LoggerFactory.getLogger(SimpleExample.class);
    //1.获取scheduler对象,用quartz默认的
    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler();
    // 计算下一分钟的时间
    Date runTime = evenMinuteDate(new Date());
    // 2.定义一个作业job,指明job的名称,所在组的名称,以及绑定job类
    JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();
    // 3.定义一个触发该job的触发器,设置触发规则
    Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();
    // 4.将job和trigger设置到调度器中
    sched.scheduleJob(job, trigger);
    // 5.启动调度
    sched.start();
    // wait long enough so that the scheduler as an opportunity to
    // run the job!
    try {
      // wait 65 seconds to show job
      Thread.sleep(65L * 1000L);
      // executing...
    } catch (Exception e) {
      //
    }
    // 6.停止调度
    sched.shutdown(true);
  }

  public static void main(String[] args) throws Exception {

    SimpleExample example = new SimpleExample();
    example.run();

  }

}
三、源码分析
下面就以上面代码标注的那样一步一步分析
1.Scheduler
 代表一个Quartz的独立运行容器, Trigger和JobDetail可以注册到Scheduler中, 两者在Scheduler中拥有各自的组及名称, 组及名称是Scheduler查找定位容器中某一对象的依据, Trigger的组及名称必须唯一, JobDetail的组和名称也必须唯一(但可以和Trigger的组和名称相同,因为它们是不同类型的)。Scheduler定义了多个接口方法, 允许外部通过组及名称访问和控制容器中Trigger和JobDetail。

Scheduler可以将Trigger绑定到某一JobDetail中, 这样当Trigger触发时, 对应的Job就被执行。一个Job可以对应多个Trigger, 但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext,它类似于ServletContext,保存着Scheduler上下文信息,Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map,以键值对的方式维护这些上下文数据,SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler# getContext()获取对应的SchedulerContext实例;

1.1getScheduler方法

 

public Scheduler getScheduler() throws SchedulerException {
        if (cfg == null) {
	    //初始化加载配置信息
            initialize();
        }
	//判断缓存中有没有创建过的Scheduler
        SchedulerRepository schedRep = SchedulerRepository.getInstance();

        Scheduler sched = schedRep.lookup(getSchedulerName());

        if (sched != null) {
            if (sched.isShutdown()) {
                schedRep.remove(getSchedulerName());
            } else {
                return sched;
            }
        }
	//创建Scheduler 。。。。。
        sched = instantiate();

        return sched;
    }

1.2接着看创建instantiate()方法

方法很长,主要是进行所用到信息的创建,比如JobStore,ThreadPool,QuartzScheduler,ThreadExecutor等,主要看下ThreadPool和QuartzScheduler的创建

 

private Scheduler instantiate() throws SchedulerException {
	......
       	// Get ThreadPool Properties 默认采用的是SimpleThreadPool
        String tpClass = cfg.getStringProperty(PROP_THREAD_POOL_CLASS, SimpleThreadPool.class.getName());

        if (tpClass == null) {
            initException = new SchedulerException(
                    "ThreadPool class not specified. ");
            throw initException;
        }

        try {
            tp = (ThreadPool) loadHelper.loadClass(tpClass).newInstance();
        } catch (Exception e) {
            initException = new SchedulerException("ThreadPool class '"
                    + tpClass + "' could not be instantiated.", e);
            throw initException;
        }
	 ......
    //这里就是创建Quartz内部调度器和Quartz主线程的地方。主线程会在QuartzScheduler的构造函数中创            
    //建并启动
    qs = new QuartzScheduler(rsrcs, idleWaitTime, dbFailureRetry);
    
     // Create Scheduler ref...
     Scheduler scheduler = instantiate(rsrcs, qs);
	 ......
}


1.3线程池创建

    存放池中所有的线程引用
private List<WorkerThread> workers;
//存放空闲线程
private LinkedList<WorkerThread> availWorkers = new LinkedList<WorkerThread>();
//存放工作线程
private LinkedList<WorkerThread> busyWorkers = new LinkedList<WorkerThread>();
public void initialize() throws SchedulerConfigException {

        if(workers != null && workers.size() > 0) // already initialized...
            return;
        
        if (count <= 0) {
            throw new SchedulerConfigException(
                    "Thread count must be > 0");
        }
        if (prio <= 0 || prio > 9) {
            throw new SchedulerConfigException(
                    "Thread priority must be > 0 and <= 9");
        }

        if(isThreadsInheritGroupOfInitializingThread()) {
            threadGroup = Thread.currentThread().getThreadGroup();
        } else {
            // follow the threadGroup tree to the root thread group.
            threadGroup = Thread.currentThread().getThreadGroup();
            ThreadGroup parent = threadGroup;
            while ( !parent.getName().equals("main") ) {
                threadGroup = parent;
                parent = threadGroup.getParent();
            }
            threadGroup = new ThreadGroup(parent, schedulerInstanceName + "-SimpleThreadPool");
            if (isMakeThreadsDaemons()) {
                threadGroup.setDaemon(true);
            }
        }


        if (isThreadsInheritContextClassLoaderOfInitializingThread()) {
            getLog().info(
                    "Job execution threads will use class loader of thread: "
                            + Thread.currentThread().getName());
        }

        // create the worker threads and start them
	    //createWorkerThreads方法中会根据配置的池大小创建线程实例。并启动池中每一个线程
	    //这里启动的线程就是上面说到的等待Runnable(JobRunShell)的线程。
        Iterator<WorkerThread> workerThreads = createWorkerThreads(count).iterator();
        while(workerThreads.hasNext()) {
            WorkerThread wt = workerThreads.next();
            wt.start();
            availWorkers.add(wt);
        }
    }


来看createWorkerThreads(),创建workerThread线程,并放到workers中

protected List<WorkerThread> createWorkerThreads(int createCount) {
        workers = new LinkedList<WorkerThread>();
        for (int i = 1; i<= createCount; ++i) {
            String threadPrefix = getThreadNamePrefix();
            if (threadPrefix == null) {
                threadPrefix = schedulerInstanceName + "_Worker";
            }
            WorkerThread wt = new WorkerThread(this, threadGroup,
                threadPrefix + "-" + i,
                getThreadPriority(),
                isMakeThreadsDaemons());
            if (isThreadsInheritContextClassLoaderOfInitializingThread()) {
                wt.setContextClassLoader(Thread.currentThread()
                        .getContextClassLoader());
            }
            workers.add(wt);
        }

        return workers;
    }

 

wt.start();
availWorkers.add(wt);
接着启动线程并将其添加到空闲线程中。看其run方法

public void run() {
            boolean ran = false;
            //run为AtomicBoolean保证原子性操作,内部是采用 (volatile关键字)private volatile int value;
            while (run.get()) {
                try {
                    synchronized(lock) {
                        // Runnable为空(外界还没有给JobRunShell)的时候,这个线程无限等待
                        while (runnable == null && run.get()) {
                            lock.wait(500);
                        }

                        if (runnable != null) {
                            ran = true;
                            // 这里就是JobRunShell的run方法,也就是作业最终被调用的地方。
                            runnable.run();
                        }
                    }
                } catch (InterruptedException unblock) {
                    // do nothing (loop will terminate if shutdown() was called
                    try {
                        getLog().error("Worker thread was interrupt()'ed.", unblock);
                    } catch(Exception e) {
                        // ignore to help with a tomcat glitch
                    }
                } catch (Throwable exceptionInRunnable) {
                    try {
                        getLog().error("Error while executing the Runnable: ",
                            exceptionInRunnable);
                    } catch(Exception e) {
                        // ignore to help with a tomcat glitch
                    }
                } finally {
                    synchronized(lock) {
                        runnable = null;
                    }
                    // repair the thread in case the runnable mucked it up...
                    if(getPriority() != tp.getThreadPriority()) {
                        setPriority(tp.getThreadPriority());
                    }

                    if (runOnce) {
                           run.set(false);
                        // 如果只执行一次则执行完成后该对象不放入空闲线程队列中
                        clearFromBusyWorkersList(this);
                    } else if(ran) {
                        ran = false;
                        // 将该对象从工作线程队列中删除,并且放入空闲队列中。这个方法实际上就是线程的回收
                        makeAvailable(this);
                    }

                }
            }

            //if (log.isDebugEnabled())
            try {
                getLog().debug("WorkerThread is shut down.");
            } catch(Exception e) {
                // ignore to help with a tomcat glitch
            }
        }


1.4QuartzScheduler

线程池的代码大概就是这样,下面跟踪QuartzScheduler的构造函数。这个类会创建Quartz的主线程。

public QuartzScheduler(QuartzSchedulerResources resources, long idleWaitTime, @Deprecated long dbRetryInterval)
        throws SchedulerException {
        ......
        this.schedThread = new QuartzSchedulerThread(this, resources);
        ThreadExecutor schedThreadExecutor = resources.getThreadExecutor();
        schedThreadExecutor.execute(this.schedThread);    //默认用的是DefaultThreadExecutor
}

 

QuartzSchedulerThread构造函数,发现一开始paused被置为true,run方法已知在等在,直到scheduler.start()方法执行,而后run方法一直处于循环状态,取出待执行的任务执行

 

QuartzSchedulerThread(QuartzScheduler qs, QuartzSchedulerResources qsRsrcs, boolean setDaemon, int threadPrio) {
        super(qs.getSchedulerThreadGroup(), qsRsrcs.getThreadName());
        this.qs = qs;
        this.qsRsrcs = qsRsrcs;
        this.setDaemon(setDaemon);
        if(qsRsrcs.isThreadsInheritInitializersClassLoadContext()) {
            log.info("QuartzSchedulerThread Inheriting ContextClassLoader of thread: " + Thread.currentThread().getName());
            this.setContextClassLoader(Thread.currentThread().getContextClassLoader());
        }

        this.setPriority(threadPrio);

        // start the underlying thread, but put this object into the 'paused'
        // state
        // so processing doesn't start yet...    线程已知在等待
        paused = true;
        halted = new AtomicBoolean(false);
    }

 


QuartzSchedulerThread创建完成后,线程执行方法执行,看其run方法。

 

 

 

public void run() {

while (!halted.get()) {

try {

synchronized (sigLock) {

// paused 就是等待外界的信号量,

// 需要信号量pausedc=false才能开始工作 QuartzScheduler.start()方法中会设置pausedc=false
 while (paused && !halted.get()) {
 try {
 // wait until togglePause(false) is called...
 sigLock.wait(1000L);
 } catch (InterruptedException ignore) {
 }
 }

 if (halted.get()) {
 break;
 }

// 当线程池中有空闲线程时才执行(这里也不是严格的,如果配置的没有空闲线程则创建一个新的)

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

if(availTreadCount > 0) {
......
// 这里会找到下一个要触发的线程。具体的方法在下面会分析。

trigger = qsRsrcs.getJobStore().acquireNextTrigger(ctxt, now + idleWaitTime);

//等待线程到trigger的真正触发时间。。。

// 创建JobRunShell,要执行的作业就在这里面

JobRunShell shell = null;

try {
 shell = qsRsrcs.getJobRunShellFactory().createJobRunShell(bndle);
 shell.initialize(qs, bndle);
 } catch (SchedulerException se) {。。。}

// 这里就是将JobRunShell交给线程池的地方

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

......
}

 

看其线程池中的runInThread方法,就可以明了线程池的使用了

public boolean runInThread(Runnable runnable) {
        if (runnable == null) {
            return false;
        }

        synchronized (nextRunnableLock) {

            handoffPending = true;

            // Wait until a worker thread is available
            while ((availWorkers.size() < 1) && !isShutdown) {
                try {
                    nextRunnableLock.wait(500);
                } catch (InterruptedException ignore) {
                }
            }

            if (!isShutdown) {
                WorkerThread wt = (WorkerThread)availWorkers.removeFirst();
                busyWorkers.add(wt);
                wt.run(runnable);
            } else {
                // If the thread pool is going down, execute the Runnable
                // within a new additional worker thread (no thread from the pool).
                WorkerThread wt = new WorkerThread(this, threadGroup,
                        "WorkerThread-LastJob", prio, isMakeThreadsDaemons(), runnable);
                busyWorkers.add(wt);
                workers.add(wt);
                wt.start();
            }
            nextRunnableLock.notifyAll();
            handoffPending = false;
        }

        return true;
    }

跟踪JobStore的acquireNextTrigger方法(这里是RAMJobStore)

// 实际上RAMJobStore持有一个TreeSet<Trigger> timeTriggers,排序方式是按触发时间排的。触发时间越早的排在前面。

// 所以这里只要取timeTriggers的first并验证就可以了。

public Trigger acquireNextTrigger(SchedulingContext ctxt, long noLaterThan) {
 TriggerWrapper tw = null;

synchronized (lock) {

while (tw == null) {
 try {
 tw = (TriggerWrapper) timeTriggers.first();
 } catch (java.util.NoSuchElementException nsee) {
 return null;
 }

if (tw == null) {
 return null;
 }

if (tw.trigger.getNextFireTime() == null) {
 timeTriggers.remove(tw);
 tw = null;
 continue;
 }

timeTriggers.remove(tw);

if (applyMisfire(tw)) {
 if (tw.trigger.getNextFireTime() != null) {
 timeTriggers.add(tw);
 }
 tw = null;
 continue;
 }

if(tw.trigger.getNextFireTime().getTime() > noLaterThan) {
 timeTriggers.add(tw);
 return null;
 }

tw.state = TriggerWrapper.STATE_ACQUIRED;

tw.trigger.setFireInstanceId(getFiredTriggerRecordId());
 Trigger trig = (Trigger) tw.trigger.clone();
 return trig;
 }
 }

return null;
 }

 

设置job和trigger不看,看5,启动调度

 

public void start() throws SchedulerException {

if (shuttingDown|| closed) {
 throw new SchedulerException(
 "The Scheduler cannot be restarted after shutdown() has been called.");
 }

if (initialStart == null) {
 initialStart = new Date();
 this.resources.getJobStore().schedulerStarted(); 
 startPlugins();
 }

// 这里就是将主线程的pause信号量置为false的地方

schedThread.togglePause(false);

getLog().info(
 "Scheduler " + resources.getUniqueIdentifier() + " started.");

 notifySchedulerListenersStarted();
 }

 

 

 

 

总结:起初创建并初始化Quartz线程池(TreadPool),并启动它。刚启动时线程池中每个线程都处于等待状态,等待外界给他分配Runnable(持有作业对象的线程)。然后会初始化并启动Quartz的主线程(QuartzSchedulerThread),该线程自启动后就会等待外界的信号量开始工作。外界给出工作信号量之后,该主线程的run方法才实质上开始工作。run方法会一直处于循环状态,run中会获取JobStore中下一次要触发的作业,拿到之后会一直等待到该作业的真正触发时间,然后将该作业包装成一个JobRunShell对象(该对象实现了Runnable接口,其实看是上面TreadPool中等待外界分配给他的Runnable),然后将刚创建的JobRunShell交给线程池,由线程池负责执行作业。线程池收到Runnable后,从线程池一个线程启动Runnable,然后将该线程回收至空闲线程中。JobRunShell对象的run方法就是最终通过反射调用作业的地方。

 

Quartz是运用最广的任务调度框架,它最核心的组成部分是Scheduler、Trigger、JobDetail,然后给Scheduler配置个线程QuartzSchedulerThread,此线程在Scheduler初始化时启动,等待Scheduler start,然后从JobStore里拿到最近要触发的Trigger,以线程等待的方式等到trigger触发时间点,之后就是执行trigger所关联的JobDetail,最后清扫战场。Scheduler初始化、start和trigger执行的时序图如下所示:


 


Quartz与Spring结合使用初始化的入口是SchedulerFactoryBean。该类实现了Spring的InitializingBean接口,所以IOC容器初始化完成后会调用afterPropertiesSet方法。Quartz的初始化也是在这里完成的。又因为该类实现了Spring的SmartLifecycle接口,所以真正启动主线程的start方法也是由Spring调用的。
public void afterPropertiesSet() throws Exception {

/**

* schedulerFactoryClass默认是StdSchedulerFactory,initSchedulerFactory方法没有仔细看,应该是读取配置信息

*/

SchedulerFactory schedulerFactory = (SchedulerFactory)BeanUtils.instantiateClass(this.schedulerFactoryClass);

initSchedulerFactory(schedulerFactory);

。。。

// 所有的工作都是在createScheduler方法中做的:创建线程池、创建并启动主线程。

// 但这里创建的主线程并没有实质上的开始工作,他要等待外界的信号量

try {
 this.scheduler = createScheduler(schedulerFactory, this.schedulerName);
 populateSchedulerContext();
 }

。。。

// registerListeners注册监听器,这个方法没有仔细看过

// registerJobsAndTriggers方法就是读取配置的作业和他们的触发器的地方

registerListeners();
 registerJobsAndTriggers();

}

跟踪createScheduler方法(这里返回的Scheduler对象就是最终要返回的Scheduler任务调度者):

protected Scheduler createScheduler(SchedulerFactory schedulerFactory, String schedulerName)
 throws SchedulerException {

。。。

// 这里创建的是StdScheduler,调用方法的自然也是StdSchedulerFactory

Scheduler newScheduler = schedulerFactory.getScheduler();

。。。

}

 


相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页