1.简介
最近我司上线使用了分布式任务调度框架:XXL-JOB,方便对任务的管理控制。本来一开始就想讲述一下该框架,但是在学习了解过程中发现该框架式基于Quartz
思想开发实现的,Quartz
是一个很火的开源任务调度框架,完全由Java
写成,可以说是 Java 定时任务领域的老大哥或者说参考标准,所以在这里先讲讲Quartz
框架。
1.1.Quartz是什么
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,是完全由java开发的一个开源的任务日程管理系统,“任务进度管理器”就是一个在预先确定(被纳入日程)的时间到达时,负责执行(或者通知)其他软件组件的系统。其功能类似于java.util.Timer。但是相较于Timer, Quartz增加了很多功能,作为一个优秀的开源调度框架,Quartz具有以下特点:
- 强大的调度功能,例如支持丰富多样的调度方法,可以满足各种常规及特殊需求
- 灵活的应用方式,支持调度数据的多种存储方式
- 分布式和集群能力
1.2.存储方式
RAMJobStore和JDBCJobStore 两者对比如下:
类型 | 优点 | 缺点 |
---|---|---|
RAMJobStore | 不要外部数据库,配置容易,运行速度快 | 因为调度程序信息是存储在被分配给JVM的内存里面,所以,当应用程序停止运行时,所有调度信息将被丢失。另外因为存储到JVM内存里面,所以可以存储多少个Job和Trigger将会受到限制 |
JDBCJobStore | 支持集群,因为所有的任务信息都会保存到数据库中,可以控制事物,还有就是如果应用服务器关闭或者重启,任务信息都不会丢失,并且可以恢复因服务器关闭或者重启而导致执行失败的任务 | 运行速度的快慢取决与连接数据库的快慢 |
根据上面知道,要想支持分布式集群,必须属于JDBCJobStore
,其需要借助数据库MySQL,数据库初始化表SQL下载:tables,表描述说明如下:
表名 | 说明 |
---|---|
qrtz_blob_triggers | Trigger作为Blob类型存储(用于Quartz用户用JDBC创建他们自己定制的Trigger类型,JobStore 并不知道如何存储实例的时候) |
qrtz_calendars | 以Blob类型存储Quartz的Calendar日历信息, quartz可配置一个日历来指定一个时间范围 |
qrtz_cron_triggers | 存储Cron Trigger,包括Cron表达式和时区信息 |
qrtz_fired_triggers | 存储与已触发的Trigger相关的状态信息,以及相联Job的执行信息 |
qrtz_job_details | 存储每一个已配置的Job的详细信息 |
qrtz_locks | 存储程序的非观锁的信息(假如使用了悲观锁) |
qrtz_paused_trigger_graps | 存储已暂停的Trigger组的信息 |
qrtz_scheduler_state | 存储少量的有关 Scheduler的状态信息,和别的 Scheduler 实例(假如是用于一个集群中) |
qrtz_simple_triggers | 存储简单的 Trigger,包括重复次数,间隔,以及已触的次数 |
qrtz_triggers | 存储已配置的 Trigger的信息 |
项目推荐:基于SpringBoot2.x、SpringCloud和SpringCloudAlibaba企业级系统架构底层框架封装,解决业务开发时常见的非功能性需求,防止重复造轮子,方便业务快速开发和企业技术栈框架统一管理。引入组件化的思想实现高内聚低耦合并且高度可配置化,做到可插拔。严格控制包依赖和统一版本管理,做到最少化依赖。注重代码规范和注释,非常适合个人学习和企业使用
Github地址:https://github.com/plasticene/plasticene-boot-starter-parent
Gitee地址:https://gitee.com/plasticene3/plasticene-boot-starter-parent
微信公众号:Shepherd进阶笔记
交流探讨群:Shepherd_126
2.springboot整合示例
springboot整合quartz非常简单,这里我们演示集群模式,所以使用JDBCJobStore
,相关所需依赖如下:
<!-- 实现对 Quartz 的自动化配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
<!-- 实现对数据库连接池的自动化配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency> <!-- 本示例,我们使用 MySQL -->
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.48</version>
</dependency>
在创建任务之前,我们需要下载上面SQL语句执行一下,这里建表可以和业务数据库在同一个库,也可以单独放到一个数据库,如果单独建库建表,那么业务服务就是多数据源了,需要重新封装数据源连接。如下的多数据源配置:
@Configuration
public class DataSourceConfiguration {
/**
* 创建 user 数据源的配置对象
*/
@Primary
@Bean(name = "userDataSourceProperties")
@ConfigurationProperties(prefix = "spring.datasource.user") // 读取 spring.datasource.user 配置到 DataSourceProperties 对象
public DataSourceProperties userDataSourceProperties() {
return new DataSourceProperties();
}
/**
* 创建 user 数据源
*/
@Primary
@Bean(name = "userDataSource")
@ConfigurationProperties(prefix = "spring.datasource.user.hikari") // 读取 spring.datasource.user 配置到 HikariDataSource 对象
public DataSource userDataSource() {
// 获得 DataSourceProperties 对象
DataSourceProperties properties = this.userDataSourceProperties();
// 创建 HikariDataSource 对象
return createHikariDataSource(properties);
}
/**
* 创建 quartz 数据源的配置对象
*/
@Bean(name = "quartzDataSourceProperties")
@ConfigurationProperties(prefix = "spring.datasource.quartz") // 读取 spring.datasource.quartz 配置到 DataSourceProperties 对象
public DataSourceProperties quartzDataSourceProperties() {
return new DataSourceProperties();
}
/**
* 创建 quartz 数据源
*/
@Bean(name = "quartzDataSource")
@ConfigurationProperties(prefix = "spring.datasource.quartz.hikari")
@QuartzDataSource
public DataSource quartzDataSource() {
// 获得 DataSourceProperties 对象
DataSourceProperties properties = this.quartzDataSourceProperties();
// 创建 HikariDataSource 对象
return createHikariDataSource(properties);
}
private static HikariDataSource createHikariDataSource(DataSourceProperties properties) {
// 创建 HikariDataSource 对象
HikariDataSource dataSource = properties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
// 设置线程池名
if (StringUtils.hasText(properties.getName())) {
dataSource.setPoolName(properties.getName());
}
return dataSource;
}
}
为了快速简单测试,我们把Quartz的建表放到业务库一起,然后如下配置即可:
spring:
datasource:
url: jdbc:mysql://10.10.0.10:3306/ptc_job?useSSL=false&useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
# Quartz 的配置,对应 QuartzProperties 配置类
quartz:
scheduler-name: clusteredScheduler # Scheduler 名字。默认为 schedulerName
job-store-type: jdbc # Job 存储器类型。默认为 memory 表示内存,可选 jdbc 使用数据库。
auto-startup: true # Quartz 是否自动启动
startup-delay: 0 # 延迟 N 秒启动
wait-for-jobs-to-complete-on-shutdown: true # 应用关闭时,是否等待定时任务执行完成。默认为 false ,建议设置为 true
overwrite-existing-jobs: true # 是否覆盖已有 Job 的配置,注意为false时,修改已存在的任务调度cron,周期不生效
jdbc: # 使用 JDBC 的 JobStore 的时候,JDBC 的配置
initialize-schema: never # 是否自动使用 SQL 初始化 Quartz 表结构。这里设置成 never ,我们手动创建表结构。
properties: # 添加 Quartz Scheduler 附加属性,更多可以看 http://www.quartz-scheduler.org/documentation/2.4.0-SNAPSHOT/configuration.html 文档
org:
quartz:
# JobStore 相关配置
jobStore:
# 数据源名称
dataSource: quartzDataSource # 使用的数据源
class: org.quartz.impl.jdbcjobstore.JobStoreTX # JobStore 实现类
driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
tablePrefix: QRTZ_ # Quartz 表前缀
isClustered: true # 是集群模式
clusterCheckinInterval: 1000
useProperties: false
# 线程池相关配置
threadPool:
threadCount: 25 # 线程池大小。默认为 10 。
threadPriority: 5 # 线程优先级
class: org.quartz.simpl.SimpleThreadPool # 线程池类型
创建任务Job1
@DisallowConcurrentExecution
public class Job1 extends QuartzJobBean {
private Logger logger = LoggerFactory.getLogger(getClass());
private static SimpleDateFormat fullDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private final AtomicInteger count = new AtomicInteger();
@Autowired
private DemoService demoService;
private String k1;
public void setK1(String k1) {
this.k1 = k1;
}
@Override
protected void executeInternal(JobExecutionContext context) {
logger.info("[job1的执行了,时间: {}, k1={}, count={}, demoService={}]", fullDateFormat.format(new Date()), k1,
count.incrementAndGet(), demoService);
}
}
继承 QuartzJobBean 抽象类,实现 #executeInternal(JobExecutionContext context)
方法,执行自定义的定时任务的逻辑。
QuartzJobBean 实现了 org.quartz.Job
接口,提供了 Quartz 每次创建 Job 执行定时逻辑时,将该 JobDataMap数据进行依赖属性注入到Job Bean中。
// QuartzJobBean.java
public final void execute(JobExecutionContext context) throws JobExecutionException {
try {
// 将当前对象,包装成 BeanWrapper 对象
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
// 设置属性到 bw 中
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.addPropertyValues(context.getScheduler().getContext());
pvs.addPropertyValues(context.getMergedJobDataMap());
bw.setPropertyValues(pvs, true);
} catch (SchedulerException ex) {
throw new JobExecutionException(ex);
}
// 执行提供给子类实现的抽象方法
this.executeInternal(context);
}
protected abstract void executeInternal(JobExecutionContext context) throws JobExecutionException;
注入Job任务配置如下:
@Bean
public JobDetail job1() {
return JobBuilder.newJob(Job1.class)
.withIdentity("job1")
.storeDurably()
.usingJobData("k1", "v1")
.build();
}
@Bean
public Trigger simpleJobTrigger() {
// 简单的调度计划的构造器
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(30) // 频率 30s执行一次。
.repeatForever(); // 次数。
// Trigger 构造器
return TriggerBuilder.newTrigger()
.forJob(job1())
.withIdentity("job1Trigger")
.withSchedule(scheduleBuilder)
.build();
}
这时候启动项目查看日志如下:
2022-09-20 23:17:33.500 INFO 18982 --- [eduler_Worker-2] : [job1的执行了,时间: 2022-09-20 23:17:33, k1=v1, count=1, demoService=DemoService@3258ebff]
2022-09-20 23:18:03.463 INFO 18982 --- [eduler_Worker-3] : [job1的执行了,时间: 2022-09-20 23:18:03, k1=v1, count=1, demoService=DemoService@3258ebff]
2022-09-20 23:18:33.439 INFO 18982 --- [eduler_Worker-4] : [job1的执行了,时间: 2022-09-20 23:18:33, k1=v1, count=1, demoService=DemoService@3258ebff]
2022-09-20 23:19:03.448 INFO 18982 --- [eduler_Worker-5] : [job1的执行了,时间: 2022-09-20 23:19:03, k1=v1, count=1, demoService=DemoService@3258ebff]
从计数器count
可以看出,每次 Job0 都会被 Quartz 创建出一个新的 Job 对象,执行任务,但是DemoService
属性值相同,是Spring单例bean,同时JobData的数据自动映射注入到任务bean属性上。
上面是通过简单调度器simpleSchedule
指定频率执行任务,当然我也可以使用主流的基于cron表达式实现任务周期执行:
@Bean
public JobDetail job1() {
return JobBuilder.newJob(Job1.class)
.withIdentity("job1")
.storeDurably()
.usingJobData("k1", "v1")
.build();
}
@Bean
public Trigger cronJobTrigger() {
// 每隔1分钟执行一次
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0 0/1 * * * ? *");
// Trigger 构造器
return TriggerBuilder.newTrigger()
.forJob(job1())
.withIdentity("job1Trigger")
.withSchedule(scheduleBuilder)
.build();
}
任务调度执行结果这里就不再展示了,和上面一回事。
3.实现原理
Quartz 是通过 Scheduler 调度器来进行任务的操作,它可以把任务 JobDetail 和触发器 Trigger 加入任务池中,可以把任务删除,也可以把任务停止,scheduler 把这些任务和触发器放到一个 JobStore 中,这里 jobStore 有内存形式的也有持久化形式的,当然也可以自定义扩展成独立的服务。
Quartz内部会通过一个调度线程 QuartzSchedulerThread 不断到 JobStore 中找出下次需要执行的任务,并把这些任务封装放到一个线程池 ThreadPool 中运行,组件结构如下图:
核心类
QuartzSchedulerThread
:负责执行向QuartzScheduler注册的触发Trigger的工作的线程。 ThreadPool:Scheduler
使用一个线程池作为任务运行的基础设施,任务通过共享线程池中的线程提供运行效率。 QuartzSchedulerResources
:包含创建QuartzScheduler实例所需的所有资源(JobStore,ThreadPool等)。 SchedulerFactory
:提供用于获取调度程序实例的客户端可用句柄的机制。 JobStore
: 通过类实现的接口,这些类要为org.quartz.core.QuartzScheduler的使用提供一个org.quartz.Job和org.quartz.Trigger存储机制。作业和触发器的存储应该以其名称和组的组合为唯一性。 QuartzScheduler
:这是Quartz的核心,它是org.quartz.Scheduler接口的间接实现,包含调度org.quartz.Jobs,注册org.quartz.JobListener实例等的方法。 Scheduler
:这是Quartz Scheduler的主要接口,代表一个独立运行容器。调度程序维护JobDetails和触发器的注册表。 一旦注册,调度程序负责执行作业,当他们的相关联的触发器触发(当他们的预定时间到达时)。 Trigger
:具有所有触发器通用属性的基本接口,描述了job执行的时间出发规则。 - 使用TriggerBuilder实例化实际触发器。 JobDetail
:传递给定作业实例的详细信息属性。 JobDetails将使用JobBuilder创建/定义。 Job
:要由表示要执行的“作业”的类实现的接口。只有一个方法 void execute(jobExecutionContext context) (jobExecutionContext 提供调度上下文各种信息,运行时数据保存在jobDataMap中)
Job有个子接口StatefulJob ,代表有状态任务。有状态任务不可并发,前次任务没有执行完,后面任务处于阻塞等到。 下面展示原生的Quartz创建任务、绑定触发器、注册任务和定时器、启动调度器,
/**
* 原生创建任务流程示例,有助于分析quartz实现原理
* @throws SchedulerException
*/
public static void test() throws SchedulerException {
//1.创建Scheduler的工厂
SchedulerFactory sf = new StdSchedulerFactory();
//2.从工厂中获取调度器实例
Scheduler scheduler = sf.getScheduler();
//3.创建JobDetail
JobDetail jb = JobBuilder.newJob(Job1.class)
.withDescription("this is a job") //job的描述
.withIdentity("job1", "test-job") //job 的name和group
.build();
//任务运行的时间,SimpleSchedule类型触发器有效
long time= System.currentTimeMillis() + 3*1000L; //3秒后启动任务
Date statTime = new Date(time);
//4.创建Trigger
//使用SimpleScheduleBuilder或者CronScheduleBuilder
Trigger t = TriggerBuilder.newTrigger()
.withDescription("")
.withIdentity("job1Trigger", "job1TriggerGroup")
//.withSchedule(SimpleScheduleBuilder.simpleSchedule())
.startAt(statTime) //默认当前时间启动
.withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?")) //10秒执行一次
.build();
//5.注册任务和定时器
scheduler.scheduleJob(jb, t);//源码分析
//6.启动 调度器
scheduler.start();
}
public static void main(String[] args) throws SchedulerException {
test();
}
接下来对主要三个步骤:创建调度器、注册任务和触发器、启动调度器执行任务进行分析
调度器初始化
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler scheduler = sf.getScheduler();
SchedulerFacotory
是创建调度器的工厂接口,它有两个实现,StdSchedulerFacotory
根据配置文件来创建 Scheduler,DirectSchedulerFactory
主要通过编码对 Scheduler 控制,通常为了侵入性更小、实现更方便我们用 StdSchedulerFacotory
类型来创建 StdScheduler,quartz.properties 里面的配置都对应到这个 StdSchedulerFactory 中,所以对某个配置不明白已经该配置的默认值可以看 StdSchedulerFactory
中获取配置的代码。
从sf.getScheduler()
入手,进入StdSchedulerFacotory
可以看到该方法逻辑:
public Scheduler getScheduler() throws SchedulerException {
// 第一步:加载配置文件,System的properties覆盖前面的配置
if (cfg == null) {
initialize();
}
SchedulerRepository schedRep = SchedulerRepository.getInstance();
Scheduler sched = schedRep.lookup(getSchedulerName());
if (sched != null) {
if (sched.isShutdown()) {
schedRep.remove(getSchedulerName());
} else {
return sched;
}
}
// 第二步:初始化,生成scheduler
sched = instantiate();
return sched;
}
这里一共完成两个逻辑:加载配置和生成scheduler,接下来进入核心方法instantiate()
,这里面逻辑很多,其核心操作就是初始化各种调度所需要的对象,比如线程池、JobStore等等,最后把上面创建的对象放到 QuartzSchedulerResources 中并把线程池起来,这个相当于 QuartzScheduler 的资源存放处, 方法相关代码如下:
private Scheduler instantiate() throws SchedulerException{
......
// 要初始化的对象
JobStore js = null;
ThreadPool tp = null;
QuartzScheduler qs = null;
DBConnectionManager dbMgr = null;
String instanceIdGeneratorClass = null;
Properties tProps = null;
String userTXLocation = null;
boolean wrapJobInTx = false;
boolean autoId = false;
long idleWaitTime = -1;
long dbFailureRetry = 15000L; // 15 secs
String classLoadHelperClass;
String jobFactoryClass;
ThreadExecutor threadExecutor;
.....
QuartzSchedulerResources rsrcs = new QuartzSchedulerResources();
rsrcs.setName(schedName);
rsrcs.setThreadName(threadName);
rsrcs.setInstanceId(schedInstId);
rsrcs.setJobRunShellFactory(jrsf);
rsrcs.setMakeSchedulerThreadDaemon(makeSchedulerThreadDaemon);
rsrcs.setThreadsInheritInitializersClassLoadContext(threadsInheritInitalizersClassLoader);
rsrcs.setRunUpdateCheck(!skipUpdateCheck);
rsrcs.setBatchTimeWindow(batchTimeWindow);
rsrcs.setMaxBatchSize(maxBatchSize);
rsrcs.setInterruptJobsOnShutdown(interruptJobsOnShutdown);
rsrcs.setInterruptJobsOnShutdownWithWait(interruptJobsOnShutdownWithWait);
rsrcs.setJMXExport(jmxExport);
rsrcs.setJMXObjectName(jmxObjectName);
//这个线程执行者用于后面启动调度线程
rsrcs.setThreadExecutor(threadExecutor);
threadExecutor.initialize();
rsrcs.setThreadPool(tp);
if (tp instanceof SimpleThreadPool) {
if (threadsInheritInitalizersClassLoader)
((SimpleThreadPool) tp).setThreadsInheritContextClassLoaderOfInitializingThread(
threadsInheritInitalizersClassLoader);
}
//执行线程池启动
tp.initialize();
tpInited = true;
rsrcs.setJobStore(js);
// add plugins
for (int i = 0; i < plugins.length; i++) {
rsrcs.addSchedulerPlugin(plugins[i]);
}
//调度线程在构造方法里面启动的
qs = new QuartzScheduler(rsrcs, idleWaitTime, dbFailureRetry);
}
经过上面调度器scheduler就初始化好了,接下来就可以定义Job和Trigger,然后通过scheduler.scheduleJob(jb, t)
注册任务和触发器。
注册任务和触发器
scheduler.scheduleJob(jb, t)
进入StdScheduler#scheduleJob(JobDetail jobDetail, Trigger trigger)
public Date scheduleJob(JobDetail jobDetail, Trigger trigger)
throws SchedulerException {
return sched.scheduleJob(jobDetail, trigger);
}
这里的sched
对象就是QuartzScheduler
,进入sched.scheduleJob(jobDetail, trigger)
,这里就是注册任务和定时任务的核心逻辑。
public Date scheduleJob(JobDetail jobDetail, Trigger trigger) throws SchedulerException {
.....
//核心代码:存储给定的org.quartz.JobDetail和org.quartz.Trigger。
resources.getJobStore().storeJobAndTrigger(jobDetail, trig);
notifySchedulerListenersJobAdded(jobDetail);
notifySchedulerThread(trigger.getNextFireTime().getTime());
notifySchedulerListenersSchduled(trigger);
return ft;
}
这里的resources
就是上面创建调度器scheduler时初始化各种对象然后放到资源管理处QuartzSchedulerResources
,其里面包含对JobStore对象,然后再通过这个对象保存任务和触发器,至于保存逻辑的细节这里不在详述,请自行查看,反正核心逻辑这里上下文都对上了。
启动调度器执行任务
quartz 用一个线程不断轮询查找下次待执行的任务,并把任务交给线程池执行,这里涉及两种角色:调度线程和执行线程池。
scheduler.start();
scheduler.start()
调用 QuartzScheduler.start()
,Quartz 的启动要调用start()方法进行线程的启动,线程中启动线程是调用start()方法,但是真正执行线程任务的操作在run()中
QuartzScheduler.start()
代码如下:
public void start() throws SchedulerException {
if (shuttingDown|| closed) {
throw new SchedulerException(
"The Scheduler cannot be restarted after shutdown() has been called.");
}
notifySchedulerListenersStarting();
if (initialStart == null) {//初始化标识为null,进行初始化操作
initialStart = new Date();
this.resources.getJobStore().schedulerStarted();//1 主要分析的地方
startPlugins();
} else {
resources.getJobStore().schedulerResumed();//2 如果已经初始化过,则恢复jobStore
}
schedThread.togglePause(false);//3 唤醒所有等待的线程
getLog().info(
"Scheduler " + resources.getUniqueIdentifier() + " started.");
notifySchedulerListenersStarted();
}
this.resources.getJobStore().schedulerStarted()
;主要分析的地方,实际上是调用 QuartzSchedulerResources
中的JobStore
进行启动。
最后QuartzSchedulerThread.run()主要是在有可用线程的时候获取需要执行Trigger并出触发进行任务的调度!
看线程 QuartzSchedulerThread 的 run () 方法以 while (true) 的方式循环执行,不断从jobStore中获取下次要触发的触发器集合,将任务放到线程池中执行,这也是Quartz实现定时周期执行任务的核心所在,具体分析请看:https://my.oschina.net/chengxiaoyuan/blog/674603