学会这10种定时任务，我有点飘了

最新推荐文章于 2024-09-04 19:44:36 发布

2401_85112052

最新推荐文章于 2024-09-04 19:44:36 发布

阅读量885

点赞数 30

文章标签： java spring boot 开发语言

本文链接：https://blog.csdn.net/2401_85112052/article/details/139847062

版权

优点：非常方便实现多个周期性的定时任务，并且支持延迟执行，还支持在指定时间之后支持，功能还算强大。
缺点：如果其中一个任务耗时非常长，会影响其他任务的执行。并且如果TimerTask 抛出 RuntimeException ， Timer 会停止所有任务的运行，所以阿里巴巴开发者规范中不建议使用它。

3.ScheduledExecutorService

==========================

ScheduledExecutorService 是JDK1.5+版本引进的定时任务，该类位于 java.util.concurrent并发包下。

ScheduledExecutorService 是基于多线程的，设计的初衷是为了解决 Timer 单线程执行，多个任务之间会互相影响的问题。

它主要包含4个方法：

schedule(Runnable command,long delay,TimeUnit unit) ，带延迟时间的调度，只执行一次，调度之后可通过Future.get()阻塞直至任务执行完毕。
schedule(Callable callable,long delay,TimeUnit unit) ，带延迟时间的调度，只执行一次，调度之后可通过Future.get()阻塞直至任务执行完毕，并且可以获取执行结果。
scheduleAtFixedRate ，表示以固定频率执行的任务，如果当前任务耗时较多，超过定时周期period，则当前任务结束后会立即执行。
scheduleWithFixedDelay ，表示以固定延时执行任务，延时是相对当前任务结束为起点计算开始时间。

实现这种定时任务的具体代码如下：

public class ScheduleExecutorTest {

public static void main(String[] args) {

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

scheduledExecutorService.scheduleAtFixedRate(() -> {

System.out.println(“doSomething”);

},1000,1000, TimeUnit.MILLISECONDS);

}

调用 ScheduledExecutorService 类的 scheduleAtFixedRate 方法实现周期性任务，每隔1秒钟执行一次，每次延迟1秒再执行。

这种定时任务是阿里巴巴开发者规范中用来替代 Timer 类的方案，对于多线程执行周期性任务，是个不错的选择。

ScheduledExecutorService的优缺点：

=============================

优点：基于多线程的定时任务，多个任务之间不会相关影响，支持周期性的执行任务，并且带延迟功能。
缺点：不支持一些较复杂的定时规则。

三. spring支持的定时任务

================

1.spring task

=============

spring task 是 spring3 以上版本自带的定时任务，实现定时任务的功能时，需要引入 spring-context 包，目前它支持： xml 和注解两种方式。

1. 项目实战

========

由于xml方式太古老了，我们以springboot项目中注解方式为例。

第一步，在pom.xml文件中引入 spring-context 相关依赖。

org.springframework

spring-context

第二步，在springboot启动类上加上 @EnableScheduling 注解。

@EnableScheduling

@SpringBootApplication

public class Application {

public static void main(String[] args) {

new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);

}

第三步，使用 @Scheduled 注解定义定时规则。

@Service

public class SpringTaskTest {

@Scheduled(cron = “${sue.spring.task.cron}”)

public void fun() {

System.out.println(“doSomething”);

}

第四步，在

applicationContext.properties 文件中配置参数：

sue.spring.task.cron=*/10 * * * * ?

这样就能每隔10秒执行一次fun方法了。

2. cron规则

==========

spring4以上的版本中，cron表达式包含6个参数：

[秒] [分] [时] [日期] [月] [星期]

还支持几个常用的特殊符号：

=============

* ：表示任何时间触发任务
, ：表示指定的时间触发任务
- ：表示一段时间内触发任务
/ ：表示从哪一个时刻开始，每隔多长时间触发一次任务。
? ：表示用于月中的天和周中的天两个子表达式，表示不指定值。

cron表达式参数具体含义：

==============

秒，取值范围：0-59，支持 * 、 , 、 - 、 / 。
分，取值范围：0-59，支持 * 、 , 、 - 、 / 。
时，取值范围：0-23，支持 * 、 , 、 - 、 / 。
* , - / ? 星期日期
月，取值范围：1-12，支持 * 、 , 、 - 、 / 。
* , - / ? ? 日期星期

常见cron表达式使用举例：

==============

0 0 0 1 * ? 每月1号零点执行
0 0 2 * * ? 每天凌晨2点执行
0 0 2 * * ? 每天凌晨2点执行
0 0/5 11 * * ? 每天11点-11点55分，每隔5分钟执行一次
0 0 18 ? * WED 每周三下午6点执行

spring task先通过

ScheduledAnnotationBeanPostProcessor类的processScheduled方法，解析和收集 Scheduled 注解中的参数，包含：cron表达式。

然后在ScheduledTaskRegistrar类的afterPropertiesSet方法中，默认初始化一个单线程的 ThreadPoolExecutor 执行任务。

对spring task感兴趣的小伙伴，可以加我微信找我私聊。

使用 spring task 的优缺点：

====================

优点：spring框架自带的定时功能，springboot做了非常好的封装，开启和定义定时任务非常容易，支持复杂的 cron 表达式，可以满足绝大多数单机版的业务场景。单个任务时，当前次的调度完成后，再执行下一次任务调度。
缺点：默认单线程，如果前面的任务执行时间太长，对后面任务的执行有影响。不支持集群方式部署，不能做数据存储型定时任务。

2.spring quartz

===============

quartz 是 OpenSymphony 开源组织在 Job scheduling 领域的开源项目，是由java开发的一个开源的任务日程管理系统。

quartz能做什么？

作业调度：调用各种框架的作业脚本，例如shell,hive等。
定时任务：在某一预定的时刻，执行你想要执行的任务。

架构图如下：

学会这10种定时任务，我有点飘了

quartz包含的主要接口如下：

Scheduler 代表调度容器，一个调度容器中可以注册多个JobDetail和Trigger。
Job 代表工作，即要执行的具体内容。
JobDetail 代表具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容。
JobBuilder 用于定义或构建JobDetail实例。
Trigger 代表调度触发器，决定什么时候去调。
TriggerBuilder 用于定义或构建触发器。
JobStore 用于存储作业和任务调度期间的状态。

1. 项目实战

========

我们还是以 springboot 集成 quartz 为例。

第一步，在pom.xml文件中引入 quartz 相关依赖。

org.springframework.boot

spring-boot-starter-quartz

第二步，创建真正的定时任务执行类，该类继承 QuartzJobBean 。

public class QuartzTestJob extends QuartzJobBean {

@Override

protected void executeInternal(JobExecutionContext context) throws JobExecutionException {

String userName = (String) context.getJobDetail().getJobDataMap().get(“userName”);

System.out.println(“userName:” + userName);

}

第三步，创建调度程序 JobDetail 和调度器 Trigger 。

@Configuration

public class QuartzConfig {

@Value(“${sue.spring.quartz.cron}”)

private String testCron;

/**

创建定时任务

@Bean

public JobDetail quartzTestDetail() {

JobDetail jobDetail = JobBuilder.newJob(QuartzTestJob.class)

.withIdentity(“quartzTestDetail”, “QUARTZ_TEST”)

.usingJobData(“userName”, “susan”)

.storeDurably()

.build();

return jobDetail;

}

/**

创建触发器

@Bean

public Trigger quartzTestJobTrigger() {

//每隔5秒执行一次

CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(testCron);

//创建触发器

Trigger trigger = TriggerBuilder.newTrigger()

.forJob(quartzTestDetail())

.withIdentity(“quartzTestJobTrigger”, “QUARTZ_TEST_JOB_TRIGGER”)

.withSchedule(cronScheduleBuilder)

.build();

return trigger;

}

第四步，在

applicationContext.properties 文件中配置参数：

sue.spring.quartz.cron=*/5 * * * * ?

这样就能每隔5秒执行一次QuartzTestJob类的executeInternal方法了。

CronTrigger配置格式:

[秒] [分] [小时] [日] [月] [周] [年]

spring quartz 跟 spring task 的 cron 表达式规则基本一致，只是 spring4 以上的版本去掉了后面的年，而 quartz 的 CronTrigger 的年是非必填的，这里我就不做过多介绍了。

使用 spring quartz 的优缺点：

======================

优点：默认是多线程异步执行，单个任务时，在上一个调度未完成时，下一个调度时间到时，会另起一个线程开始新的调度，多个任务之间互不影响。支持复杂的 cron 表达式，它能被集群实例化，支持分布式部署。
缺点：相对于spring task实现定时任务成本更高，需要手动配置QuartzJobBean 、 JobDetail和 Trigger 等。需要引入了第三方的 quartz包，有一定的学习成本。不支持并行调度，不支持失败处理策略和动态分片的策略等。

四. 分布式定时任务

==========

1.xxl-job

=========

xxl-job 是大众点评（许雪里）开发的一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。

xxl-job 框架对 quartz 进行了扩展，使用 mysql 数据库存储数据，并且内置jetty作为 RPC服务调用。

主要特点如下：

有界面维护定时任务和触发规则，非常容易管理。
能动态启动或停止任务
支持弹性扩容缩容
支持任务失败报警
支持动态分片
支持故障转移
Rolling实时日志
支持用户和权限管理

管理界面：

学会这10种定时任务，我有点飘了

整体架构图如下：

学会这10种定时任务，我有点飘了

使用quartz架构图如下：

学会这10种定时任务，我有点飘了

项目实战

====

xxl-admin 管理后台部署和mysql脚本执行等这些前期准备工作，我就不过多介绍了，有需求的朋友可以找我私聊，这些更偏向于运维的事情。

假设前期工作已经OK了，接下来我们需要：

第一步，在pom.xml文件中引入 xxl-job 相关依赖。

com.xuxueli

xxl-job-core

第二步，在

applicationContext.properties 文件中配置参数：

xxl.job.admin.address: http://localhost:8088/xxl-job-admin/

xxl.job.executor.appname: xxl-job-executor-sample

xxl.job.executor.port: 8888

xxl.job.executor.logpath: /data/applogs/xxl-job/

第三步，创建HelloJobHandler类继承 IJobHandler 类：

@JobHandler(value = “helloJobHandler”)

@Component

public class HelloJobHandler extends IJobHandler {

@Override

public ReturnT execute(String param) {

System.out.println(“XXL-JOB, Hello World.”);

return SUCCESS;

}

这样定时任务就配置好了。

建议把定时任务单独部署到另外一个服务中，跟api服务分开。根据我以往的经验，job大部分情况下，会对数据做批量操作，如果操作的数据量太大，可能会对服务的内存和cpu资源造成一定的影响。

使用 xxl-job 的优缺点：

================

优点：有界面管理定时任务，支持弹性扩容缩容、动态分片、故障转移、失败报警等功能。它的功能非常强大，很多大厂在用，可以满足绝大多数业务场景。
缺点：和 quartz 一样，通过数据库分布式锁，来控制任务不能重复执行。在任务非常多的情况下，有一些性能问题。

2.elastic-job

=============

elastic-job 是当当网开发的弹性分布式任务调度系统，功能丰富强大，采用zookeeper实现分布式协调，实现任务高可用以及分片。它是专门为高并发和复杂业务场景开发。

elastic-job 目前是 apache 的 shardingsphere 项目下的一个子项目，官网地址：

http://shardingsphere.apache.org/elasticjob/。

elastic-job 在2.x之后，出了两个产品线： Elastic-Job-Lite 和 Elastic-Job-Cloud ，而我们一般使用Elastic-Job-Lite就能够满足需求。Elastic-Job-Lite定位为轻量级无中心化解决方案，使用jar包的形式提供分布式任务的协调服务，外部仅依赖于Zookeeper。。

主要特点如下：

分布式调度协调
弹性扩容缩容
失效转移
错过执行作业重触发
作业分片一致性，保证同一分片在分布式环境中仅一个执行实例
自诊断并修复分布式不稳定造成的问题
支持并行调度

整体架构图：

学会这10种定时任务，我有点飘了

项目实战

====

第一步，在pom.xml文件中引入 elastic-job 相关依赖。

com.dangdang

elastic-job-lite-core

com.dangdang

elastic-job-lite-spring

第二步，增加ZKConfig类，配置 zookeeper ：

@Configuration

@ConditionalOnExpression(“‘${zk.serverList}’.length() > 0”)

public class ZKConfig {

@Bean

public ZookeeperRegistryCenter registry(@Value(“${zk.serverList}”) String serverList,

@Value(“${zk.namespace}”) String namespace) {

return new ZookeeperRegistryCenter(new ZookeeperConfiguration(serverList, namespace));

}

第三步，定义一个类实现 SimpleJob 接口：

public class TestJob implements SimpleJob {

@Override

public void execute(ShardingContext shardingContext){

System.out.println(“ShardingTotalCount:”+shardingContext.getShardingTotalCount());

System.out.println(“ShardingItem:”+shardingContext.getShardingItem());

}

第四步，增加JobConfig配置任务：

@Configuration

public class JobConfig {

@Value(“${sue.spring.elatisc.cron}”)

private String testCron;

@Value(“${sue.spring.elatisc.itemParameters}”)

private String shardingItemParameters;

@Value(“${sue.spring.elatisc.jobParameters}”)

private String jobParameters =;

@Value(“${sue.spring.elatisc.shardingTotalCount}”)

private int shardingTotalCount;

@Autowired

private ZookeeperRegistryCenter registryCenter;

@Bean

public SimpleJob testJob() {

return new TestJob();

}

@Bean

public JobScheduler simpleJobScheduler(final SimpleJob simpleJob) {

return new SpringJobScheduler(simpleJob, registryCenter, getConfiguration(simpleJob.getClass(),

cron, shardingTotalCount, shardingItemParameters, jobParameters));

}

private geConfiguration getConfiguration(Class<? extends SimpleJob> jobClass,String cron,int shardingTotalCount,String shardingItemParameters,String jobParameters) {

JobCoreConfiguration simpleCoreConfig = JobCoreConfiguration.newBuilder(jobClass.getName(), testCron, shardingTotalCount).

shardingItemParameters(shardingItemParameters).jobParameter(jobParameters).build();

SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(simpleCoreConfig, jobClass.getCanonicalName());

LiteJobConfiguration jobConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).overwrite(true).build();

return jobConfig;

}

其中：

cron：cron表达式，定义触发规则。
shardingTotalCount：定义作业分片总数
shardingItemParameters：定义分配项参数，一般用分片序列号和参数用等号分隔，多个键值对用逗号分隔，分片序列号从0开始，不可大于或等于作业分片总数。
jobParameters：作业自定义参数

第五步，在

applicationContext.properties 文件中配置参数：

spring.application.name=elasticjobDemo

zk.serverList=localhost:2181

zk.namespace=elasticjobDemo

sue.spring.elatisc.cron=0/5 * * * * ?

sue.spring.elatisc.itemParameters=0=A,1=B,2=C,3=D

sue.spring.elatisc.jobParameters=test

sue.spring.elatisc.shardingTotalCount=4

总结

我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。

Mybatis源码解析

pleJobConfiguration(simpleCoreConfig, jobClass.getCanonicalName());

LiteJobConfiguration jobConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).overwrite(true).build();

return jobConfig;

}

其中：

cron：cron表达式，定义触发规则。
shardingTotalCount：定义作业分片总数
shardingItemParameters：定义分配项参数，一般用分片序列号和参数用等号分隔，多个键值对用逗号分隔，分片序列号从0开始，不可大于或等于作业分片总数。
jobParameters：作业自定义参数

第五步，在

applicationContext.properties 文件中配置参数：

spring.application.name=elasticjobDemo

zk.serverList=localhost:2181

zk.namespace=elasticjobDemo

sue.spring.elatisc.cron=0/5 * * * * ?

sue.spring.elatisc.itemParameters=0=A,1=B,2=C,3=D

sue.spring.elatisc.jobParameters=test

sue.spring.elatisc.shardingTotalCount=4