Quartz：定时任务调度框架_网站优化分享

Quartz主要内容

Quartz是一个开源的任务调度框架，负责任务进度管理（就是一个在预先被纳入日程，当时间到达时，负责执行（或者通知）其他软件组件的系统），由OpenSymphony（一个开源组织）开发，这个框架进行了优良地解耦设计，

Quartz主要功能，就是在设定的时间内干什么事情，比如说把redis中的缓存数据与数据库中的数据进行同步、定时发送信息、设置一个周三才开始的活动。Quartz是一个基于Java实现的任务调度框架，应该说叫定时任务调度框架。在Java领域，有很多定时任务框架，这里简单对比一下目前比较流行的三款：

Quartz：定时任务调度框架,第1张

Quartz主要分为三大部分：

Job：定时执行的具体工作内容，想要调度的任务都必须实现 org.quartz.job 接口，然后实现接口中定义的 execute( ) 方法即可。
Trigger：触发器，指定运行参数，包括运行次数、运行开始时间和技术时间、运行时长等，如果想要凌晨1点执行备份数据的任务，那么 Trigger 就会设置凌晨1点执行该任务。其中 Trigger 又分为 SimpleTrigger 和 CronTrigger 两种。

Scheduler：调度器，将Job和Trigger组装起来，使定时任务被真正执行，主要负责基于Trigger设置的时间来启动、暂停、恢复、停止和触发时间修改对应的任务。

下图是Quartz主要的关系图:

Quartz：定时任务调度框架,第2张

文字化的描述就是，Job通过实现类与Trigger进行绑定，一个Job可以绑定多个Trigger（实现了Quartz的异步通知），但是一个Trigger只能绑定一个Job，且Job的实现类与Trigger通过Group和name来标识唯一性，Quartz是使用多线程来处理任务的。

Quartz集群

Quartz集群中每个节点是一个独立的Quartz任务应用，它又管理者其他节点。该集群需要分别对每个节点分别启动或停止，独立的Quartz节点并不与另一个节点或是管理节点通信。Quartz应用是通过共有相同数据库表来感知到另一应用。也就是说只有使用持久化JobStore存储Job和Trigger才能完成Quartz集群部署方案。

Quartz的集群部署方案是分布式的，没有负责集中管理的节点，而是利用数据库行锁的方式来实现集群环境下的并发控制。Quartz主要有两个行锁：

锁名	解释
STATE_ACCESS	状态访问锁
Trigger_ACCESS	触发器访问锁

一个scheduler实例在集群模式下首先获取行锁才行。Quartz集群争用触发器行锁，锁被占用只能等待，获取触发器行锁之后，先获取需要等待触发的其他触发器信息。

定时任务的诸多要素，如任务名称、数量、状态、运行频率、运行时间等，是要存储起来的。JobStore，就是用来存储任务和触发器相关的信息的。Quartz 中有两种存储任务的方式，一种在在内存（RAMJobStore），一种是在数据库（JDBCJobStore）。

Quartz 默认的 JobStore 是 RAMJobstore，也就是把任务和触发器信息运行的信息存储在内存中，用到了 HashMap、TreeSet、HashSet 等等数据结构，如果程序崩溃或重启，所有存储在内存中的数据都会丢失。所以我们需要把这些数据持久化到磁盘。

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
org.quartz.jobStore.misfireThreshold: 60000
org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore  # 标识Quartz的持久化存储是RAM

Quartz中相关类

Quartz：定时任务调度框架,第3张

Job接口：自己写的“定时程序”实现此接口的void execute(JobExecutionContext arg0)方法,Job还有一类为有状态的StatefulJob接口，如果我们需要在上一个作业执行完后，根据其执行结果再进行下次作业的执行，则需要实现此接口。

public class XXXJobs implements Job {
    
    @Autowired
    private XXXService xxxService;
    // 自己写的实现void execute()方法
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        log.debug("xxxQueueJob start...");
        // 分布式锁，如果获取失败则返回
        XXXJob proxy = ApplicationContextUtil.getBean(getClass());
        proxy.jobHandler();
        log.debug("xxxQueueJob end...");
    }
    @JobToken
    @RedisLock(expiration = 20L)
    public void jobHandler() {
        // 定时任务核心逻辑
    }
}

Trigger抽象类：调度类(Scheduler)在时间到时调用此类，再由trigger类调用指定的定时程序。Quertz中提供了两类触发器为：SimpleTrigger,CronTrigger。前者用于实现比较简单的定时功能，例如几点开始，几点结束，隔多长时间执行，共执行多少次等，后者提供了使用表达式来描述定时功能，因此适用于比较复杂的定时描述，例如每个月的最后一个周五，每周的周四等。

SimpleTrigger：简单触发器，支持定义任务执行的间隔时间，执行次数的规则有两种，一是定义重复次数，二是定义开始时间和结束时间。如果同时设置了结束时间与重复次数，先结束的会覆盖后结束的，以先结束的为准。
CronTrigger：基于Cron表达式的触发器。
CalendarIntervalTrigger：基于日历的触发器，比简单触发器更多时间单位，且能智能区分大小月和平闰年。

DailyTimeIntervalTrigger：基于日期的触发器，如每天的某个时间段。

Trigger是有状态的：NONE, NORMAL, PAUSED, COMPLETE, ERROR, BLOCKED，状态之间转换关系如下图所示：

Quartz：定时任务调度框架,第4张

 Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "trigger-group")
                .startNow()//立即生效
                .forJob(jobDetail)
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2) //每隔3s执行一次
                        .repeatForever()) // 永久循环
                .build();

JobDetail类：具体某个定时程序的详细描述，包括Name,Group,JobDataMap等。

JobDataMap jobDataMap = jobDetail.getJobDataMap();
String name = jobDetail.getKey().getName();
String group = jobDetail.getKey().getGroup();
String jobName = jobDetail.getJobClass().getName();

JobExecutionContext类：定时程序执行的run-time的上下文环境，用于得到当前执行的Job的名字，配置的参数等。
JobDataMap类：用于描述一个作业的参数，参数可以为任何基本类型例如String,float等，也可为某个对象的引用.
JobListener,TriggerListener接口：用于监听触发器状态和作业扫行状态，在特写状态执行相应操作。

JobStore类：在哪里执行定进程序，可选的有在内存中，在数据库中。

public class HelloJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        Object tv1 = context.getTrigger().getJobDataMap().get("t1");
        Object tv2 = context.getTrigger().getJobDataMap().get("t2");
        Object jv1 = context.getJobDetail().getJobDataMap().get("j1");
        Object jv2 = context.getJobDetail().getJobDataMap().get("j2");
        Object sv = null;
        try {
            sv = context.getScheduler().getContext().get("skey");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        System.out.println(tv1+":"+tv2);
        System.out.println(jv1+":"+jv2);
        System.out.println(sv);
        System.out.println("hello:"+LocalDateTime.now());
    }
}
-----------------------------------------------------------------------------------------
public class Test {
    public static void main(String[] args) throws SchedulerException {
        
        //创建一个scheduler
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.getContext().put("skey", "svalue");
        
        //创建一个Trigger
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .usingJobData("t1", "tv1")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3)
                        .repeatForever()).build();
        trigger.getJobDataMap().put("t2", "tv2");
        
        //创建一个job
        JobDetail job = JobBuilder.newJob(HelloJob.class)
                    .usingJobData("j1", "jv1")
                    .withIdentity("myjob", "mygroup").build();
        job.getJobDataMap().put("j2", "jv2");
        
        //注册trigger并启动scheduler
        scheduler.scheduleJob(job,trigger);
        scheduler.start(); 
    }
}

Quartz监听器

在 Quartz 中三个核心模块分别是 Job、Trigger、Scheduler，既然 Quartz中存在监听器，相应的，这三者也分别有对应的监听器。监听器的作用便是用于当任务调度中你所关注事件发生时，能够及时获取这一事件的通知。监听器也有作用域，主要分为

全局监听器：能够接收到所有的Job/Trigger的事件通知；

局部监听器：只能接收在其上注册Job或者Trigger的事件；

三核心监听器：

JobListener

任务调度中，与任务 Job 相关的事件包括： Job 开始要执行的提示，执行完成的提示，接口如下：

package org.quartz;
public interface JobListener {
    String getName(); //用于获取改JobListener 的名称
    // Scheduler 在 JobDetail 将要被执行时调用这个方法
    void jobToBeExecuted(JobExecutionContext var1);
    // cheduler 在 JobDetail 即将被执行，但又被 TriggerListener 否决时会调用该方法
    void jobExecutionVetoed(JobExecutionContext var1);
    // Scheduler 在 JobDetail 被执行之后调用这个方法
    void jobWasExecuted(JobExecutionContext var1, JobExecutionException var2);
}

将JobListener绑定到Scheduler中

//监听所有的Job
scheduler.getListenerManager().addJobListener(new SimpleJobListener(), EverythingMatcher.allJobs());
//监听特定的Job
scheduler.getListenerManager().addJobListener(new SimpleJobListener(), KeyMatcher.keyEquals(JobKey.jobKey("HelloWorld1_Job", "HelloWorld1_Group")));
//监听同一任务组的Job
scheduler.getListenerManager().addJobListener(new SimpleJobListener(), GroupMatcher.jobGroupEquals("HelloWorld2_Group"));
//监听两个任务组的Job
scheduler.getListenerManager().addJobListener(new SimpleJobListener(), OrMatcher.or(GroupMatcher.jobGroupEquals("HelloWorld1_Group"), GroupMatcher.jobGroupEquals("HelloWorld2_Group")));

TriggerListener

任务调度中，与触发器 Trigger 相关的事件包括：触发器触发、触发器未正常触发、触发器完成等，接口如下：

package org.quartz;
import org.quartz.Trigger.CompletedExecutionInstruction;
public interface TriggerListener {
    String getName(); //用于获取触发器的名称
    // 当与监听器相关联的Trigger被触发，Job上的**execute()**方法将被执行时，Scheduler就调用该方法
    void triggerFired(Trigger var1, JobExecutionContext var2);
    //在 Trigger 触发后，Job 将要被执行时由 Scheduler 调用这个方法。
    // TriggerListener 给了一个选择去否决 Job 的执行。假如这个方法返回 true，这个 Job 将不会为此次 Trigger 触发而得到执行
    boolean vetoJobExecution(Trigger var1, JobExecutionContext var2);
    // Scheduler 调用这个方法是在 Trigger 错过触发时
    void triggerMisfired(Trigger var1);
    // Trigger 被触发并且完成了 Job 的执行时，Scheduler 调用这个方法
    void triggerComplete(Trigger var1, JobExecutionContext var2, CompletedExecutionInstruction var3);
}

将TriggerListener绑定到Scheduler中：

//监听所有的Trigger
scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), EverythingMatcher.allTriggers());
//监听特定的Trigger
scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), KeyMatcher.keyEquals(TriggerKey.triggerKey("HelloWord1_Job", "HelloWorld1_Group")));
//监听一组Trigger
scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener("SimpleTrigger"), GroupMatcher.groupEquals("HelloWorld1_Group"));
//移除监听器
scheduler.getListenerManager().removeTriggerListener("SimpleTrigger");

SchedulerListener

SchedulerListener会在Scheduler的生命周期中关键事件发生时被调用。与Scheduler有关的事件包括：增加一个job/trigger，删除一个job/trigger，scheduler发生严重错误，关闭scheduler等。接口如下：

package org.quartz;
public interface SchedulerListener {
    // 用于部署JobDetail时调用
    void jobScheduled(Trigger var1);
    // 用于卸载JobDetail时调用
    void jobUnscheduled(TriggerKey var1);
    // 当一个 Trigger 来到了再也不会触发的状态时调用这个方法
    void triggerFinalized(Trigger var1);
    // Scheduler 调用这个方法是发生在一个 Trigger 或 Trigger 组被暂停时
    void triggerPaused(TriggerKey var1);
    void triggersPaused(String var1);
    // Scheduler 调用这个方法是发生成一个 Trigger 或 Trigger 组从暂停中恢复时
    void triggerResumed(TriggerKey var1);
    void triggersResumed(String var1);
    void jobAdded(JobDetail var1);
    void jobDeleted(JobKey var1);
    void jobPaused(JobKey var1);
    void jobsPaused(String var1);
    void jobResumed(JobKey var1);
    void jobsResumed(String var1);
    void schedulerError(String var1, SchedulerException var2);
    void schedulerInStandbyMode();
    // 当Scheduler处于StandBy模式时，调用该方法
    void schedulerStarted();
    void schedulerStarting();
    void schedulerShutdown();
    void schedulerShuttingdown();
    void schedulingDataCleared();
}

将SchedulerListener绑定到Scheduler中

//创建监听
scheduler.getListenerManager().addSchedulerListener(new SimpleSchedulerListener());
//移除监听
scheduler.getListenerManager().removeSchedulerListener(new SimpleSchedulerListener());

Quartz使用流程

引入Maven依赖


    org.springframework.boot
    spring-boot-starter-quartz

新建Job，实现想要执行的任务

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class SimpleJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) {
        // 创建一个事件，下面仅创建一个输出语句作演示
        System.out.println(Thread.currentThread().getName() + "--"
                           + DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()));
    }
}

创建Trigger与Scheduler，执行定时任务

import com.quartz.demo.schedule.SimpleJob;
import org.junit.jupiter.api.Test;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.Date;
import java.util.concurrent.TimeUnit;
public class SimpleQuartzTest {
    /*
     * 基于时间间隔的定时任务
     */
    @Test
    public void simpleTest() throws SchedulerException, InterruptedException {
        // 1、创建Scheduler（调度器）
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 2、创建JobDetail实例，并与SimpleJob类绑定(Job执行内容)
        JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
                .withIdentity("job1", "group1")
                .build();
        // 3、构建Trigger（触发器），定义执行频率和时长
        Trigger trigger = TriggerBuilder.newTrigger()
                // 指定group和name，这是唯一身份标识
                .withIdentity("trigger-1", "trigger-group")
                .startNow()  //立即生效
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2) //每隔2s执行一次
                        .repeatForever())  // 永久执行
                .build();
        //4、将Job和Trigger交给Scheduler调度
        scheduler.scheduleJob(jobDetail, trigger);
        // 5、启动Scheduler
        scheduler.start();
        // 休眠，决定调度器运行时间，这里设置30s
        TimeUnit.SECONDS.sleep(30);
        // 关闭Scheduler
        scheduler.shutdown();
    }
}

附

参考：https://blog.csdn.net/mu_wind/article/details/124257719

cron在线生成：https://cron.qqe2.com/

湖南seo优化公司网站建设公司亿企网络建设银行官网网址公司网站案例在线名片设计乌海网页设计公司

上一篇：Kafka Connect详解及应用实践

下一篇：kafka日志文件详解及生产常见问题总结