Quartz结合线程池的动态管理

最新推荐文章于 2024-09-14 18:46:05 发布

lichongsky1

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量1.5k

点赞数 4

分类专栏： quartz 文章标签： quartz java

本文链接：https://blog.csdn.net/lichongsky1/article/details/107465506

版权

本文介绍了Quartz作为强大的任务调度框架，如何结合线程池实现动态任务管理。通过分析Quartz的Job、JobDetail、Trigger和Scheduler等核心接口，展示了从简单示例到动态控制任务的实现过程，包括任务的创建、更新、暂停、恢复和删除。同时，文章提到了数据库存储任务信息的必要性，并提供了SpringBoot中集成Quartz的步骤和关键代码实现。

摘要由CSDN通过智能技术生成

Quartz结合线程池的动态管理

项目下载地址：[quartz-demo](https://gitee.com/lichongsky1/quartzdemo.git)

Quartz是一个非常强大的任务调度框架，可以启动，暂停，恢复，删除，更新，在重启时错过执行时间，可设置misfire规则，也就是设置错过了执行时机怎么办，可以跳过这次执行，等待下一个周期再执行，也可以马上重新执行错过的任务等，具体下面再讲。使用方法比schedule稍微麻烦一点，因为动态控制肯定涉及到前端的，这里不讨论前端如何实现，会从简单的一个demo，到一个具体的动态控制demo，记录一下后端如何设计与实现。

项目下载地址：quartz-demo

Quartz几个重要的接口和类

Job ：接口，表示一个任务，要执行的具体内容。此接口中只有一个方法， void execute(JobExecutionContext var1);我们需要自己实现execute方法，Quartz也自带一个Job的实现类：QuartzJobBean，我们也可以去继承QuartzJobBean，然后重写executeInternal这个方法。
JobDetail：quartz框架自己的一个类，其实就是一个包装类，一个Wrapper，用来包装一个job的描述信息，唯一id（JobKey)，还有如果这个job定时去调用程序中另一个方法需要传递参数时，可以设置JobDataMap,把参数保存在这个map里。用JobBuilder链式创建JobDetail。

// 创建JobDetail实例，并与MyJob类绑定(Job执行内容)
JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();

Trigger：接口，翻译过来就是触发器的意思，也可以翻译为扳机，Quartz最常用的两种trigger，SimpleTrigger和CronTrigger这两个接口，都是继承自Trigger，他们都是用来设置你的job何时触发，间隔多久重复触发，重复多少次，何时停止，多个trigger同时触发的优先级，错过触发了怎么处理。SimpleTrigger字面意思就是比较简单的Trigger，适用于简单的设置，CronTrigger可以配置corn表达式，更灵活，需要再控台展示和编辑的时候这个就更适合。Trigger也和JobDetail一样有一个TriggerBuilder，也是链式构造的方式构造Trigger

//构建Trigger实例,每隔1s执行一次 重复两次，一共执行三次
Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(1)
                        .withRepeatCount(2)).build();

Scheduler：接口，英文翻译为计划，可以理解为总指挥，最终的调度都得靠它，我们一般在设置完JobDetail和Trigger的时候，就可以调用scheduler接口的实现类StdScheduler中的public Date scheduleJob(JobDetail jobDetail, Trigger trigger)这样就添加好了一条任务，当时间到了trigger中设定的时间时，任务开始执行，如果要立即执行就调用void triggerJob(JobKey jobKey, JobDataMap data);如果是暂停任务就调用void pauseJob(JobKey jobKey)，如果是恢复任务，就调用void resumeJob(JobKey jobKey),如果要删除任务就调用boolean deleteJob(JobKey jobKey)如果要更新任务，就调用public Date rescheduleJob(TriggerKey triggerKey, Trigger newTrigger)
jobStore: quartz框架存储内部执行逻辑的内容，有两种存储方式，1：RAMJobStore，将数据存储于内存中，重启就数据消失。2：JDBCJobSTore，也就是将数据存储于数据库中，如果web项目肯定是用这个了，一共有11张表需要新建，程序中也需要进行配置，这个直接用我下面的sql文件执行就行了，配置下面也会说。

SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//创建job
scheduler.scheduleJob(jobDetail, trigger);
//启动job
scheduler.start();

JobKey与TriggerKey：先看一下他们的源码

public final class JobKey extends Key<JobKey> {
   
    private static final long serialVersionUID = -6073883950062574010L;

    public JobKey(String name) {
   
        super(name, (String)null);
    }

    public JobKey(String name, String group) {
   
        super(name, group);
    }

    public static JobKey jobKey(String name) {
   
        return new JobKey(name, (String)null);
    }

    public static JobKey jobKey(String name, String group) {
   
        return new JobKey(name, group);
    }
}

public final class TriggerKey extends Key<TriggerKey> {
   
    private static final long serialVersionUID = 8070357886703449660L;

    public TriggerKey(String name) {
   
        super(name, (String)null);
    }

    public TriggerKey(String name, String group) {
   
        super(name, group);
    }

    public static TriggerKey triggerKey(String name) {
   
        return new TriggerKey(name, (String)null);
    }

    public static TriggerKey triggerKey(String name, String group) {
   
        return new TriggerKey(name, group);
    }
}

是表明Job或者Trigger身份的一个对象，里面封装了Job的name和group，TriggerKey同理。就像上面说JobDetail链式构造的时候，要指定.withIdentity(“trigger1”, “triggerGroup1”)，参数可以是两个String，也可以是一个JobKey，看一下JobBuilder和TriggerBuilder的源码片段就知道了

public JobBuilder withIdentity(String name) {
   
        this.key = new JobKey(name, (String)null);
        return this;
    }

    public JobBuilder withIdentity(String name, String group) {
   
        this.key = new JobKey(name, group);
        return this;
    }

    public JobBuilder withIdentity(JobKey jobKey) {
   
        this.key = jobKey;
        return this;
    }

public TriggerBuilder<T> withIdentity(String name) {
   
        this.key = new TriggerKey(name, (String)null);
        return this;
    }

    public TriggerBuilder<T> withIdentity(String name, String group) {
   
        this.key = new TriggerKey(name, group);
        return this;
    }

    public TriggerBuilder<T> withIdentity(TriggerKey triggerKey) {
   
        this.key = triggerKey;
        return this;
    }

demo1

main方法中使用

package com.lichong.quartz.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

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

public class PrintWordsJob implements Job {
   
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
   
        String printTime = new SimpleDateFormat("yy-MM-dd HH-mm-ss").format(new Date());
        System.out.println("PrintWordsJob start at:" + printTime + ", prints: Hello Job-" + new Random().nextInt(100));

    }
}

package com.lichong.quartz.job;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.concurrent.TimeUnit;

public class MyScheduler {
   

    public static void main(String[] args) throws SchedulerException, InterruptedException {
   
        // 1、创建调度器Scheduler 如果在spring环境中，可以直接注入Scheduler，@Autowired private Scheduler scheduler;    不需要SchedulerFactory创建
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 2、创建JobDetail实例，并与PrintWordsJob类绑定(Job执行内容)
        JobDetail jobDetail = JobBuilder.newJob(PrintWordsJob.class).withIdentity("job1", "group1").build();
        // 3、构建Trigger实例,每隔1s执行一次 重复两次，一共执行三次
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1")
                .startNow().withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(1)
                        .withRepeatCount(2)).build();

        //4、执行
        scheduler.scheduleJob(jobDetail, trigger);
        System.out.println("--------scheduler start ! ------------");
        scheduler.start();

        //睡眠
        TimeUnit.SECONDS.sleep(10);
        scheduler.shutdown();
        System.out.println("--------scheduler shutdown ! ------------");
    }
}

输出结果
--------scheduler start ! ------------
17:40:07.478 [main] INFO org.quartz.core.QuartzScheduler - Scheduler DefaultQuartzScheduler_ $KaTeX parse error: Expected group after '_' at position 1796: \dotsQuartzScheduler_̲$ NON_CLUSTERED shutting down.
17:40:17.480 [main] INFO org.quartz.core.QuartzScheduler - Scheduler DefaultQuartzScheduler $KaTeX parse error: Expected group after '_' at position 300: \dotsQuartzScheduler_̲$ _NON_CLUSTERED shutdown complete.
--------scheduler shutdown ! ------------
17:40:17.493 [DefaultQuartzScheduler_Worker-4] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.493 [DefaultQuartzScheduler_Worker-7] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.493 [DefaultQuartzScheduler_Worker-5] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.493 [DefaultQuartzScheduler_Worker-8] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.497 [DefaultQuartzScheduler_Worker-6] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.497 [DefaultQuartzScheduler_Worker-9] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.497 [DefaultQuartzScheduler_Worker-10] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.524 [DefaultQuartzScheduler_Worker-3] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.524 [DefaultQuartzScheduler_Worker-2] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.
17:40:17.530 [DefaultQuartzScheduler_Worker-1] DEBUG org.quartz.simpl.SimpleThreadPool - WorkerThread is shut down.

demo2

有了main方法后，如果我们要再spring中使用如何使用呢，在控台中想展示出来实现创建，暂停，恢复，删除，立即执行定时任务该如何做呢。

首先我们要创建一个springboot的工程，下面给出创建过程截图

这里可以提前选择添加依赖，也可以后面在pom文件里添加，下面会给出具体的依赖信息

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- 任务调度 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>

        <!-- MyBatis增强插件 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>