java–Quartz 定时执行

 <!-- 定时任务 -->
    <dependency>
    
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.2.2</version>
    </dependency>

package com.fync.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * 创建要被定执行的任务类
 * @author long
 *
 */
public class MyJob implements Job{

    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(sdf.format(new Date()));
    }

}

package com.fync.quartz;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 创建任务调度，并执行
 * @author long    
 *
 */
public class MainScheduler {
    
    //创建调度器
    public static Scheduler getScheduler() throws SchedulerException{
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        return schedulerFactory.getScheduler();
    }
    
    
    public static void schedulerJob() throws SchedulerException{
        //创建任务
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
        //创建触发器 每3秒钟执行一次
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group3")
                            .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever())
                            .build();
        Scheduler scheduler = getScheduler();
        //将任务及其触发器放入调度器
        scheduler.scheduleJob(jobDetail, trigger);
        //调度器开始调度任务
        scheduler.start();
        
    }
    
    public static void main(String[] args) throws SchedulerException {
        MainScheduler mainScheduler = new MainScheduler();
        mainScheduler.schedulerJob();
    }

} 

Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group3")
                            .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever())
                            .build();

// 创建调度器
  SchedulerFactory schedulerFactory = new StdSchedulerFactory();
  Scheduler scheduler = schedulerFactory.getScheduler();
......
// 将任务及其触发器放入调度器
  scheduler.scheduleJob(jobDetail, trigger);
// 调度器开始调度任务
  scheduler.start();

public Scheduler getScheduler() throws SchedulerException {
        // 读取quartz配置文件，未指定则顺序遍历各个path下的quartz.properties文件
        // 解析出quartz配置内容和环境变量，存入PropertiesParser对象
        // PropertiesParser组合了Properties（继承Hashtable），定义了一系列对Properties的操作方法，比如getPropertyGroup()批量获取相同前缀的配置。配置内容和环境变量存放在Properties成员变量中
        if (cfg == null) {
            initialize();
        }
        // 获取调度器池，采用了单例模式
        // 其实，调度器池的核心变量就是一个hashmap，每个元素key是scheduler名，value是scheduler实例
        // getInstance()用synchronized防止并发创建
        SchedulerRepository schedRep = SchedulerRepository.getInstance();

        // 从调度器池中取出当前配置所用的调度器
        Scheduler sched = schedRep.lookup(getSchedulerName());

        ......

        // 如果调度器池中没有当前配置的调度器，则实例化一个调度器，主要动作包括：
        // 1）初始化threadPool(线程池)：开发者可以通过org.quartz.threadPool.class配置指定使用哪个线程池类，比如SimpleThreadPool。先class load线程池类，接着动态生成线程池实例bean，然后通过反射，
　　　　 //　　　使用setXXX()方法将以org.quartz.threadPool开头的配置内容赋值给bean成员变量；
        // 2）初始化jobStore(任务存储方式)：开发者可以通过org.quartz.jobStore.class配置指定使用哪个任务存储类，比如RAMJobStore。先class load任务存储类，接着动态生成实例bean，然后通过反射，
　　　　//　 　使用setXXX()方法将以org.quartz.jobStore开头的配置内容赋值给bean成员变量；
        // 3）初始化dataSource(数据源)：开发者可以通过org.quartz.dataSource配置指定数据源详情，比如哪个数据库、账号、密码等。jobStore要指定为JDBCJobStore，dataSource才会有效；
        // 4）初始化其他配置：包括SchedulerPlugins、JobListeners、TriggerListeners等；
        // 5）初始化threadExecutor(线程执行器)：默认为DefaultThreadExecutor；
        // 6）创建工作线程：根据配置创建N个工作thread，执行start()启动thread，并将N个thread顺序add进threadPool实例的空闲线程列表availWorkers中；
        // 7）创建调度器线程：创建QuartzSchedulerThread实例，并通过threadExecutor.execute(实例)启动调度器线程；
        // 8）创建调度器：创建StdScheduler实例，将上面所有配置和引用组合进实例中，并将实例存入调度器池中
        sched = instantiate();

        return sched;
}

 public Date scheduleJob(JobDetail jobDetail,
            Trigger trigger) throws SchedulerException {
        // 检查调度器是否开启，如果关闭则throw异常到上层
        validateState();
        ......
        // 获取trigger首次触发job的时间，以此时间为起点，每隔一段指定的时间触发job
        Date ft = trig.computeFirstFireTime(cal);

        if (ft == null) {
            throw new SchedulerException(
                    "Based on configured schedule, the given trigger '" + trigger.getKey() + "' will never fire.");
        }

        // 把job和trigger注册进调度器的jobStore
        resources.getJobStore().storeJobAndTrigger(jobDetail, trig);
        // 通知job监听者
        notifySchedulerListenersJobAdded(jobDetail);                
        // 通知调度器线程
        notifySchedulerThread(trigger.getNextFireTime().getTime());
        // 通知trigger监听者
        notifySchedulerListenersSchduled(trigger);

        return ft;
    }

public void start() throws SchedulerException {
        ......
        // 这句最关键，作用是使调度器线程跳出一个无限循环，开始轮询所有trigger触发job
        // 原理详见“如何采用多线程进行任务调度”
        schedThread.togglePause(false);
        ......
    }