首先quartz本身是支持分布式的，通过表来管理各节点之间的关系。

1、去quartz官网下载最新的包 http://www.quartz-scheduler.org/

2、下载之后解压，进入如下目录，创建数据库表

quartz-2.2.3-distribution\quartz-2.2.3\docs\dbTables并选择对应的数据库SQL（笔者使用的是MySQL数据库）
quartz分布式定时任务 - 图1

在pom文件中引入依赖

  2. <!--quartz依赖-->
  3. <dependency>
  4.     <groupId>org.quartz-scheduler</groupId>
  5.     <artifactId>quartz</artifactId>
  6. </dependency>
  7. <dependency>
  8.     <groupId>org.quartz-scheduler</groupId>
  9.     <artifactId>quartz-jobs</artifactId>
  10. </dependency>
  11. <dependency>
  12.     <groupId>org.springframework</groupId>
  13.     <artifactId>spring-context-support</artifactId>
  14. </dependency>

、创建 quartz.proiperties 配置文件


  1. org.quartz.scheduler.instanceId=AUTO
  2. org.quartz.scheduler.makeSchedulerThreadDaemon=true
  3. org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
  4. org.quartz.threadPool.makeThreadsDaemons=true
  5. #线程数量
  6. org.quartz.threadPool.threadCount:20
  7. #线程优先级
  8. org.quartz.threadPool.threadPriority:5
  9. org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
  10. org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
  11. org.quartz.jobStore.tablePrefix=QRTZ_
  12. #特别注意：此处是quartz的数据源，报错就debug跟踪一下查看dbName
  13. org.quartz.jobStore.dataSource = springTxDataSource.schedulerFactoryBean
  14. #加入集群
  15. org.quartz.jobStore.isClustered=true
  16. #容许的最大作业延
  17. org.quartz.jobStore.misfireThreshold=25000
  18. #调度实例失效的检查时间间隔
  19. org.quartz.jobStore.clusterCheckinInterval: 5000

quartz的初始化配置，读取配置文件

  1. package com.wh.timerdemo.config;
  3. import org.quartz.spi.JobFactory;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.beans.factory.config.PropertiesFactoryBean;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.core.io.ClassPathResource;
  10. import org.springframework.scheduling.quartz.SchedulerFactoryBean;
  12. import javax.sql.DataSource;
  13. import java.io.IOException;
  14. import java.util.Properties;
  16. @Configuration
  17. public class QuartzConfig {
  18.     // 配置文件路径
  19.     private static final String QUARTZ_CONFIG = "/quartz.properties";
  20.     // 按照自己注入的数据源自行修改
  21.     @Qualifier("writeDataSource")
  22.     @Autowired
  23.     private DataSource dataSource;
  25.     @Autowired
  26.     private AutoWiredSpringBeanToJobFactory autoWiredSpringBeanToJobFactory;
  28.     /**
  29.      * 从quartz.properties文件中读取Quartz配置属性
  30.      * @return
  31.      * @throws IOException
  32.      */
  33.     @Bean
  34.     public Properties quartzProperties() throws IOException {
  35.         PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
  36.         propertiesFactoryBean.setLocation(new ClassPathResource(QUARTZ_CONFIG));
  37.         propertiesFactoryBean.afterPropertiesSet();
  38.         return propertiesFactoryBean.getObject();
  39.     }
  40.     /**
  41.      * JobFactory与schedulerFactoryBean中的JobFactory相互依赖,注意bean的名称
  42.      * 在这里为JobFactory注入了Spring上下文
  43.      *
  44.      * @param applicationContext
  45.      * @return
  46.      */
  47.     @Bean
  48.     public JobFactory buttonJobFactory(ApplicationContext applicationContext) {
  49.         AutoWiredSpringBeanToJobFactory jobFactory = new AutoWiredSpringBeanToJobFactory();
  50.         jobFactory.setApplicationContext(applicationContext);
  51.         return jobFactory;
  52.     }
  54.     @Bean
  55.     public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
  56.         SchedulerFactoryBean factory = new SchedulerFactoryBean();
  57.         factory.setJobFactory(autoWiredSpringBeanToJobFactory);
  58.         factory.setOverwriteExistingJobs(true);
  59.         factory.setAutoStartup(true); // 设置自行启动
  60.         // 延时启动，应用启动1秒后
  61.         factory.setStartupDelay(1);
  62.         factory.setQuartzProperties(quartzProperties());
  63.         factory.setDataSource(dataSource);// 使用应用的dataSource替换quartz的dataSource
  64.         return factory;
  65.     }
  66. }

将任务工厂注入到Spring

  1. package com.wh.timerdemo.config;
  3. import org.quartz.spi.TriggerFiredBundle;
  4. import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.ApplicationContextAware;
  7. import org.springframework.scheduling.quartz.SpringBeanJobFactory;
  8. import org.springframework.stereotype.Component;
  10. /**
  11.  * 为JobFactory注入SpringBean,否则Job无法使用Spring创建的bean
  12.  */
  13. @Component
  14. public class AutoWiredSpringBeanToJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
  15.     private transient AutowireCapableBeanFactory beanFactory;
  16.     @Override
  17.     public void setApplicationContext(final ApplicationContext context) {
  18.         beanFactory = context.getAutowireCapableBeanFactory();
  19.     }
  20.     @Override
  21.     protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
  22.         final Object job = super.createJobInstance(bundle);
  23.         beanFactory.autowireBean(job);
  24.         return job;
  25.     }
  26. }

7、创建任务调度管理，任务的增删改查，起动停止等。

  1. public class QuartzManager {
  2.     private static SchedulerFactory schedulerFactory =  new StdSchedulerFactory();
  3.     private Scheduler scheduler = null;
  4.     /**
  5.      * @Description: 添加一个定时任务
  6.      *
  7.      * @param jobName 任务名
  8.      * @param jobGroupName  任务组名
  9.      * @param triggerName 触发器名
  10.      * @param triggerGroupName 触发器组名
  11.      * @param jobClass  任务
  12.      * @param cron   时间设置，参考quartz说明文档
  13.      */
  14.     @SuppressWarnings({ "unchecked", "rawtypes" })
  15.     public  static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron) {
  16.         try {
  17.             // 任务名，任务组，任务执行类
  18.             Scheduler scheduler = schedulerFactory.getScheduler();
  19.             JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
  20.             // 触发器
  21.             TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
  22.             // 触发器名,触发器组
  23.             triggerBuilder.withIdentity(triggerName, triggerGroupName);
  24.             triggerBuilder.startNow();
  25.             // 触发器时间设定
  26.             triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
  27.             // 创建Trigger对象
  28.             CronTrigger trigger = (CronTrigger) triggerBuilder.build();
  30.             // 调度容器设置JobDetail和Trigger
  31.             scheduler.scheduleJob(jobDetail, trigger);
  33.             // 启动
  34.             if (!scheduler.isShutdown()) {
  35.                 scheduler.start();
  36.             }
  37.         } catch (Exception e) {
  38.             throw new RuntimeException(e);
  39.         }
  40.     }
  41.   /**
  42.      * @Description:启动所有定时任务
  43.      */
  44.     public  static  void startJobs() {
  45.         try {
  46.             Scheduler scheduler = schedulerFactory.getScheduler();
  47.             scheduler.start();
  48.         } catch (Exception e) {
  49.             throw new RuntimeException(e);
  50.         }
  51.     }
  53.     /**
  54.      * @Description:关闭所有定时任务
  55.      */
  56.     public static void shutdownJobs() {
  57.         try {
  58.             Scheduler scheduler = schedulerFactory.getScheduler();
  59.             if (!scheduler.isShutdown()) {
  60.                 scheduler.shutdown();
  61.             }
  62.         } catch (Exception e) {
  63.             throw new RuntimeException(e);
  64.         }
  65.     }
  67.     /**
  68.      * 获取当前正在执行的任务
  69.      * @return
  70.      */
  71.     public static boolean getCurrentJobs(String name){
  72.         try {
  73.             Scheduler scheduler = schedulerFactory.getScheduler();
  74.             List<JobExecutionContext> jobContexts = scheduler.getCurrentlyExecutingJobs();
  75.             for (JobExecutionContext context : jobContexts) {
  76.                 if (name.equals(context.getTrigger().getJobKey().getName())) {
  77.                     return true;
  78.                 }
  79.             }
  80.         } catch (Exception e) {
  81.             throw new RuntimeException(e);
  82.         }
  83.         return false;
  84.     }
  86.     public Scheduler getScheduler() {
  87.         return scheduler;
  88.     }
  90.     public void setScheduler(Scheduler scheduler) {
  91.         this.scheduler = scheduler;
  92.     }
  95. }

创建一个执行的Job，这里包含定时任务执行的逻辑

  1. package com.wh.timerdemo.task;
  3. import org.quartz.DisallowConcurrentExecution;
  4. import org.quartz.Job;
  5. import org.quartz.JobExecutionContext;
  6. import org.quartz.JobExecutionException;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  10. /**
  11.  * @DisallowConcurrentExecution : 此标记用在实现Job的类上面,意思是不允许并发执行.
  12.  * 注org.quartz.threadPool.threadCount的数量有多个的情况,@DisallowConcurrentExecution才生效
  13.  */
  14. @DisallowConcurrentExecution
  15. public class ButtonTimerJob implements Job {
  17.     private static final Logger logger = LoggerFactory.getLogger(ButtonTimerJob.class);
  19.     /**
  20.      *  核心方法,Quartz Job真正的执行逻辑。
  21.      *  @throws JobExecutionException execute()方法只允许抛出JobExecutionException异常
  22.      */
  24.     @Override
  25.     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
  26.         logger.info("--------------定时任务执行逻辑---------------------");
  27.     }
  28. }

创建启动Job类：负责任务的创建启动和配置cron等

  1. package com.wh.timerdemo.task;
  3. import com.wh.timerdemo.config.QuartzManager;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.context.ApplicationListener;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.context.event.ContextRefreshedEvent;
  10. /**
  11.  * 定时任务的启动类
  12.  */
  13. @Configuration
  14. public class StartJob implements ApplicationListener<ContextRefreshedEvent> {
  16.     private Logger logger = LoggerFactory.getLogger(this.getClass());
  18.     public void run() {
  19.         logger.info(">> 启动定时任务...");
  20.         //    QuartzManager.startJobs();
  21.         QuartzManager.addJob(
  22.                 "SpecialPeriodJob",
  23.                 "SpecialPeriodJobGroup",
  24.                 "SpecialPeriodTrigger",
  25.                 "SpecialPeriodTriggerGroup",
  26.                 ButtonTimerJob.class,
  27.                 "0/30 * * * * ?");
  28.     }
  30.     @Override
  31.     public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
  32.         System.out.println("启动定时任务......");
  33.         run();
  34.     }
  35. }


重点：11张表

  1. qrtz_blob_triggers : 以Blob 类型存储的触发器。
  2. qrtz_calendars：存放日历信息， quartz可配置一个日历来指定一个时间范围。
  3. qrtz_cron_triggers：存放cron类型的触发器。
  4. qrtz_fired_triggers：存放已触发的触发器。
  5. qrtz_job_details：存放一个jobDetail信息。
  6. qrtz_locks： 存储程序的悲观锁的信息(假如使用了悲观锁)。
  7. qrtz_paused_trigger_graps：存放暂停掉的触发器。
  8. qrtz_scheduler_state：调度器状态。
  9. qrtz_simple_triggers：简单触发器的信息。
  10. qrtz_trigger_listeners：触发器监听器。
  11. qrtz_triggers：触发器的基本信息。
  12. cron方式需要用到的4张数据表：
  13. qrtz_triggers，qrtz_cron_triggers，qrtz_fired_triggers，qrtz_job_details

Quartz核心是调度器，还采用多线程管理。quartz框架是原生就支持分布式定时任务的。

1.持久化任务（把调度信息存储到数据）：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务。

2.集群和分布式处理：当在集群环境下，当有配置Quartz的多个客户端时（节点），
采用Quartz的集群和分布式处理时，我们要了解几点好处
1) 一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。
2） Quartz调度是通过触发器的类别来识别不同的任务，在不同的节点定义相同的触发器的类别，这样在集群下能稳定的运行，一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。
3）分布式 体现在 当相同的任务定时在一个时间点，在那个时间点，不会被两个节点同时执行。
4、Quartz 在集群如何工作：
quartz分布式定时任务 - 图2**
上图三个节点在数据库中都拥有同一份Job定义，如果某一个节点失效，那么Job会在其他节点上执行。由于三个节点上的Job执行代码是一样的，那么怎么保证只有在一台机器上触发呢？答案是使用了数据库锁。在quartz的集群解决方案里有张表scheduler_locks，quartz采用了悲观锁的方式对triggers表进行行加锁，以保证任务同步的正确性。一旦某一个节点上面的线程获取了该锁，那么这个Job就会在这台机器上被执行，同时这个锁就会被这台机器占用。同时另外一台机器也会想要触发这个任务，但是锁已经被占用了，就只能等待，直到这个锁被释放。之后会看trigger状态，如果已经被执行了，则不会执行了。
简单地说,quartz的分布式调度策略是以数据库为边界资源的一种异步策略。各个调度器都遵守一个基于数据库锁的操作规则从而保证了操作的唯一性。同时多个节点的异步运行保证了服务的可靠。但这种策略有自己的局限性：集群特性对于高CPU使用率的任务效果很好，但是对于大量的短任务，各个节点都会抢占数据库锁，这样就出现大量的线程等待资源。这种情况随着节点的增加会越来越严重。
另外，quartz的分布式只是解决了高可用的问题，并没有解决任务分片的问题，还是会有单机处理的极限。