定时组件quartz系列<一>模拟定时组件小程序

一、核心概念
 
Quartz的原理不是很复杂，只要搞明白几个概念，然后知道如何去启动和关闭一个调度程序即可。
 
1、Job
表示一个工作，要执行的具体内容。此接口中只有一个方法
void execute(JobExecutionContext context)
 
2、JobDetail
JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。
 
3、Trigger代表一个调度参数的配置，什么时候去调。
 
4、Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。

二模拟案例

【1】定时任务类

package com.yeepay.sxf.testQuartz;

import java.util.Map;
/**
 * job类，这个类非常简单，只有一个execute方法，该方法是定时job具体执行的内容
 * 也就是定时任务
 * @author sxf
 *
 */
public class Job {
    public void exectute(Map<String, String> jobData){
        System.out.println("******************");
        System.out.println(jobData.get("type")+":Test Job Run at:"+System.currentTimeMillis());
        System.out.println("******************");
    }
}

【2】定时任务类的详细信息

package com.yeepay.sxf.testQuartz;

import java.util.HashMap;
/**
 * 定时的详细信息
 * 定时的相信信息（1）这个定时信息对应的任务类
 *                           （2）这个定时信息对应的任务类的参数，方法
 * @author sxf
 *
 */
public class JobDetail {

    private Class<? extends Job> clazz;
    private String jobName;
    private HashMap<String, String> jobData;
    
    //无参构造
    public JobDetail(){
        jobData =new HashMap<String, String>();
    }
    //有参构造
    public JobDetail(String name,Class<? extends Job> clazz){
        this();
        this.jobName=name;
        this.clazz=clazz;
    }
    
    public int hashCode(){
        final int prime=31;
        int result=1;
        result=prime*result+((jobName==null)?0:jobName.hashCode());
        return result;
    }
    
    /**
     * 用来通过在list中使用key匹配获取jobdetail
     */
    @Override
    public boolean equals(Object obj) {
        if(this==obj){
            return true;
        }
        if(obj==null){
            return false;
        }
        JobDetail other=(JobDetail) obj;
        if(jobName==null){
            if(other.jobName!=null){
                return false;
            }
        }else if(!jobName.equals(other.jobName)){
            return false;
        }
        return true;
    }
    public Class<? extends Job> getClazz() {
        return clazz;
    }
    public void setClazz(Class<? extends Job> clazz) {
        this.clazz = clazz;
    }
    public String getJobName() {
        return jobName;
    }
    public void setJobName(String jobName) {
        this.jobName = jobName;
    }
    public HashMap<String, String> getJobData() {
        return jobData;
    }
    public void setJobData(HashMap<String, String> jobData) {
        this.jobData = jobData;
    }
    
    
}

【3】定时的触发器

package com.yeepay.sxf.testQuartz;
/**
 * Trigger类，记录下次运行作业的时间和运行job的key
 * 一个触发器(1)内部维护一个定时任务的执行策略
 *                     (2)内部同时维护一个定时的详细信息
 *                     (3)触发器和定时详细信息是一对一的关系
 * @author sxf
 *
 */
public class Trigger implements Comparable {

    /**
     * 定时的详细信息
     */
    private String jobKey;
    /**
     * 定时的执行策略（下次执行时间）
     */
    private long nextFireTime;
    
    /**
     * 在TreeMap中可以根据下次运行时间排序
     */
    @Override
    public int compareTo(Object o) {
        Trigger d=(Trigger) o;
        return (int)(this.nextFireTime-d.getNextFireTime());
    }

    /**
     * 测试是只想运行一次，使用-1来退出
     */
    public void resert(){
        setNextFireTime(-1);
    }
    
    public String getJobKey() {
        return jobKey;
    }

    public void setJobKey(String jobKey) {
        this.jobKey = jobKey;
    }

    public long getNextFireTime() {
        return nextFireTime;
    }

    public void setNextFireTime(long nextFireTime) {
        this.nextFireTime = nextFireTime;
    }


    
}

【4】定时的初始化类（最关键的类）

package com.yeepay.sxf.testQuartz;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TreeSet;



/**
 * Sucheduler类，最重要的类，用来启动和停止框架
 * （1）内部维护触发器的集合
 * （2）内部维护定时详细信息
 * （3）内部维护一个线程类。该线程类是调度定时执行的关键
 * @author sxf
 *
 */
public class Scheduler {

    private List<JobDetail> jobList=new ArrayList<JobDetail>();
    private TreeSet<Trigger> triggerList=new TreeSet<Trigger>();
    private Object lockObject=new Object();
     SchedulerThread thread;
    
    public void schedulerJob(JobDetail detail,Trigger trigger){
        synchronized (lockObject) {
            jobList.add(detail);
            trigger.setJobKey(detail.getJobName());
            triggerList.add(trigger);
            
        }
    }
    
    public void start(){
        this.thread=new SchedulerThread(lockObject, triggerList, jobList);
        System.out.println("########## run scheduler at:"+new Date()+"##########");
        thread.start();
    }
    
    public void halt(){
        thread.halt();
    }
}

【5】定时任务调度的线程类

package com.yeepay.sxf.testQuartz;

import java.util.List;
import java.util.TreeSet;

/**
 * 任务调度线程
 * （1）从触发器集合中获取触发器
 * （2）根据获取的触发器，确认执行策略，和定时的详细信息
 * （3）如果符合当前执行策略，则触发器和定时详细信息配合执行定时任务
 * @author sxf
 *
 */
public class SchedulerThread extends Thread{

    private Object lockObject;
    private boolean shutDown=false;
    private TreeSet<Trigger> triggerList;
    private List<JobDetail> jobList;
    
    public SchedulerThread(Object lockObject,TreeSet<Trigger> triggerList,List<JobDetail> joblist){
        this.lockObject=lockObject;
        this.triggerList=triggerList;
        this.jobList=joblist;
    }
    
    @Override
    public void run() {
    
        while(!shutDown){
            synchronized (lockObject) {
                try {
                    //获取最近的触发器
                    final Trigger trigger=triggerList.pollFirst();//获取最近执行的作业
                    if(trigger==null){
                        lockObject.wait(100);
                        continue;
                    }
                    long curr=System.currentTimeMillis();
                    //从触发器中获取该触发器对应的执行策略
                    long nextTime=trigger.getNextFireTime();
                    while(nextTime>curr&&!shutDown){
                        curr=System.currentTimeMillis();
                        if(nextTime>curr+1){
                            lockObject.wait(nextTime-curr);
                        }
                        if(!shutDown){
                            //获取最早的定时任务在集合中的索引
                            int index=jobList.indexOf(new JobDetail(trigger.getJobKey(), null));
                            //获取最早的定时
                            JobDetail jobDetail=jobList.get(index);
                            //利用反射机制，获取定时任务的类
                            Job job=jobDetail.getClazz().newInstance();
                            //执行定时任务
                            job.exectute(jobDetail.getJobData());
                            trigger.resert();
                            nextTime=trigger.getNextFireTime();
                            if(nextTime!=-1){
                                triggerList.add(trigger);
                            }else{
                                break;
                            }
                            
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }finally{
                    
                }
            }
        }
    }
    
    public void halt(){
        synchronized (lockObject) {
            shutDown=true;
            lockObject.notifyAll();
        }
    }
    
}

【6】客户端测试类

package com.yeepay.sxf.testQuartz;

/**
 * 客户端测试
 * 该定时模拟，和jdk自带的TimerTask很相似。
 * @author sxf
 *
 */
public class ClientTest {

    public static void main(String[] args) {
        final JobDetail detail1=new JobDetail("job1",Job.class);
        detail1.getJobData().put("type", "job1");
        final JobDetail detail2=new JobDetail("job2",Job.class);
        detail2.getJobData().put("type", "job2");
        final Trigger trigger1=new Trigger();
        trigger1.setNextFireTime(System.currentTimeMillis()+30001);
        final Trigger trigger2=new Trigger();
        trigger2.setNextFireTime(System.currentTimeMillis()+10001);
        
        Scheduler scheduler=new Scheduler();
        scheduler.schedulerJob(detail1, trigger1);
        scheduler.schedulerJob(detail2, trigger2);
        
        scheduler.start();
        try {
            Thread.sleep(100001);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        scheduler.halt();
    }
}