maven引入

<dependency>
     <groupId>org.quartz-scheduler</groupId>
     <artifactId>quartz</artifactId>
     <version>2.2.2</version>
</dependency>

核心概念

Quartz的原理不是很复杂，只要搞明白几个概念，然后知道如何去启动和关闭一个调度程序即可。

1、Job
表示一个工作，要执行的具体内容。此接口中只有一个方法
void execute(JobExecutionContext context)
线程运行Job时会把JobDataMap封装到JobExecutionContext里作为execute方法的参数，jobdetail是对job的封装，里面有Job的class，对应的数据，名称，分组等

2、JobDetail
JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。

3、Trigger代表一个调度参数的配置，job下次什么时候执行存放在trigger中。

4、Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。

5、QuartzSchedulerResources相当于调度的资源存放器，包含了JobStore, ThreadPool等资源，调度都是通过QuartzSchedulerResources获取相关属性的。

6、jobStore是任务和触发器存储地方，它里面提供大量类似于增删改的操作任务方法。

5、QuartzSchedulerThread是一个调度线程，ThreadPool是一个执行线程池，下图是运行后的线程栈：

quartz线程池.png

Quartz是通过对用户暴露出Scheduler来进行任务的操作，它可以把任务JobDetail和触发器Trigger加入任务池中，可以把任务删除，也可以把任务停止，scheduler把这些任务和触发器放到一个JobStore中，这里jobStore有内存形式的也有持久化形式的，当然也可以自定义扩展成独立的服务。

它内部会通过一个调度线程QuartzSchedulerThread不断到JobStore中找出下次需要执行的任务，并把这些任务封装放到一个线程池ThreadPool中运行，它的组件结构如下图：

quartz结构.png

各类的调用关系如下图：

quartz调用关系.png

简单应用

下面看看quartz的简单实现：
首先是一个调度管理类：

//调度管理类
public class QuartzManager {

    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
    private static String HM_JOB = "HM_JOB";
    private static String HM_TRIGGER = "HM_TRIGGER";

    /**
     * 增加任务
     * @param jobClass 任务实现类
     * @param jobName 任务名称
     * @param interval 间隔时间
     * @param data 数据
     */
    public static void addJob(Class<? extends Job> jobClass, String jobName, int interval, Map<String, Object> data) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, HM_JOB).build();
            jobDetail.getJobDataMap().putAll(data);

            //触发器
            SimpleTrigger trigger = TriggerBuilder.newTrigger()
                                    .withIdentity(jobName,HM_TRIGGER)
                                    .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND))
                                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(interval).repeatForever())
                                    .build();
            sched.scheduleJob(jobDetail, trigger);

            //启动
            if (!sched.isShutdown()) sched.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除任务
     *
     * @param jobName 任务名称
     */
    public static void removeJob(String jobName) {
        try {
            Scheduler scheduler = gSchedulerFactory.getScheduler();
            scheduler.deleteJob(new JobKey(jobName, HM_JOB));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

接下来实现job接口：

public class TestJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String id = jobExecutionContext.getJobDetail().getJobDataMap().getString("id");
        System.out.println("threadId: " + Thread.currentThread().getId() + ", id: " + id);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试主函数如下：

public static void main(String[] args) throws InterruptedException {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("id", "1");
        QuartzManager.addJob(TestJob.class, "aaa", 1, map);

        map.clear();
        map.put("id", "2");
        QuartzManager.addJob(TestJob.class, "bbb", 1, map);

        Thread.sleep(3000);
        removeJob("aaa");
        System.out.println("main end----------");
        Thread.sleep(3000);
        System.exit(1);
    }

运行结果如下：

quartz测试结果.JPG