分布式定时任务-XXL-JOB

最新推荐文章于 2024-03-05 23:46:47 发布

努力的程序员先生

最新推荐文章于 2024-03-05 23:46:47 发布

阅读量543

点赞数 1

分类专栏： Java编程文章标签：分布式

本文链接：https://blog.csdn.net/qq_39636602/article/details/103715646

版权

Java编程专栏收录该内容

25 篇文章 0 订阅

订阅专栏

一、什么是定时任务？

定时任务顾名思义就是：指定时间去执行任务。

二、实现定时任务的方案？

单台服务器的定时job：

通过Thread进行实现（以下框架底层基本都是采用此种方式），Thread.Sleep方法。

package chauncy.single;

/**   
 * 任何定时任务框架的底层都是多线程。
 * @classDesc: 功能描述(使用多线程实现定时任务调度)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class UseThread {
	static int count = 0;
	public static void main(String[] args) {
		Runnable runnable = new Runnable() {
			public void run() {
				while (true) {
					try {
						//实现定时任务
						Thread.sleep(1000);
						count++;
						System.out.println("定时任务需要跑批执行。。。count:"+count);
					} catch (Exception e) {
						// TODO: handle exception
					}
				}
			}
		};
		Thread thread = new Thread(runnable);
		thread.start();
	}
}

使用java.util包下的TimeTask。

package chauncy.single;

import java.util.Timer;
import java.util.TimerTask;

/**
 * TimerTask是Thread的演进。   
 * @classDesc: 功能描述(使用TimerTask实现定时任务调度)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class UseTimerTask {
	static int count = 0;

	public static void main(String[] args) {
		TimerTask timerTask = new TimerTask() {

			@Override
			public void run() {
				count++;
				System.out.println("使用TimerTask实现定时任务调度...count:"+count);
			}
		};
		Timer timer = new Timer();
		// 天数
		long delay = 0;
		// 秒数
		long period = 1000;
		timer.scheduleAtFixedRate(timerTask, delay, period);
	}

}

使用线程池executor中的ScheduledExecutorService。

package chauncy.single;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * ScheduledExecutorService较TimerTask好，更为理想。 
 * @classDesc: 功能描述(使用ScheduledExecutorService实现定时任务调度)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class UseExecutor {
	static int count = 0;
	public static void main(String[] args) {
		Runnable runnable = new Runnable() {
			public void run() {
				// task to run goes here
				count++;
				System.out.println("使用ScheduledExecutorService实现定时任务调度。。。count:"+count);
			}
		};
		ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
		// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
		service.scheduleAtFixedRate(runnable, 1, 1, TimeUnit.SECONDS);
	}

}

SpringBoot中的定时任务注解@Schedule。

使用Quartz第三方框架。

引入maven依赖：

<dependencies>
	<!-- quartz -->
	<dependency>
		<groupId>org.quartz-scheduler</groupId>
		<artifactId>quartz</artifactId>
		<version>2.2.1</version>
	</dependency>
	<dependency>
		<groupId>org.quartz-scheduler</groupId>
		<artifactId>quartz-jobs</artifactId>
		<version>2.2.1</version>
	</dependency>
</dependencies>

创建任务调度类：

package chauncy.single.quartz;

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

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

/**   
 * @classDesc: 功能描述(Quartz任务调度类,实现job接口,重写execute方法)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class MyJob implements Job {
	
	/**
	 * 具体执行任务调度的方法
	 */
	public void execute(JobExecutionContext context) throws JobExecutionException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println("quartz MyJob date:" + sdf.format(new Date()));
	}

}

创建启动类：

package chauncy.single.quartz;

import java.util.Date;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 其它分布式任务调度框架底层都是用Quartz封装一遍,Quartz最优秀的是其Corn表达式。
 * @classDesc: 功能描述(Quartz的启动类)  
 * @author: ChauncyWang
 * @version: 1.0  
 */  
public class APP {

	public static void main(String[] args) throws SchedulerException {
		// 1.创建Scheduler的工厂
		SchedulerFactory sf = new StdSchedulerFactory();
		// 2.从工厂中获取调度器实例
		Scheduler scheduler = sf.getScheduler();

		// 3.创建JobDetail
		JobDetail jb = JobBuilder.newJob(MyJob.class).withDescription("this is a ram job") // job的描述
				.withIdentity("ramJob", "ramGroup") // job 的name和group
				.build();

		// 任务运行的时间，SimpleSchedle类型触发器有效
		long time = System.currentTimeMillis() + 3 * 1000L; // 3秒后启动任务
		Date statTime = new Date(time);

		// 4.创建Trigger
		// 使用SimpleScheduleBuilder或者CronScheduleBuilder
		Trigger t = TriggerBuilder.newTrigger().withDescription("").withIdentity("ramTrigger", "ramTriggerGroup")
				// .withSchedule(SimpleScheduleBuilder.simpleSchedule())
				.startAt(statTime) // 默认当前时间启动
				.withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")) // 两秒执行一次
				.build();

		// 5.注册任务和定时器
		scheduler.scheduleJob(jb, t);

		// 6.启动 调度器
		scheduler.start();

	}
}

Corn表达式生成器：http://cron.qqe2.com/

在分布式集群的情况下，怎么解决任务调度幂等性问题（不重复）？
1. 解决思路：
  在集群的情况下，让job只能被1台服务器执行。
  多个jvm进行通讯，只能让一个jvm去执行任务调度。
2. 解决方案列举：
  1. Zookeeper分布式锁：使用临时节点作为锁，临时节点不唯一，当其它连接会话关闭时，临时节点就会释放锁资源，等待其它连接进行分配。
    缺点：如果针对大型互联网公司，每天使用定时任务的需求非常懂的情况，就存在不易扩展、效率低、编写代码复杂的缺点。
  2. 使用配置文件做开关，缺点：适合小项目，不适合大项目。
  3. 使用数据库表的唯一性约束，缺点：不靠谱，效率不高。
    以上3种方式都有一个共性，就是没有容错机制、效率低、资源没有得到合理利用、不能解决高并发大流量的需求。
  4. 使用分布式任务调度平台（最合理），如：xxljob、antares等。
    优点：1.可以解决分布式任务调度幂等性问题。2.解决高可用问题（容错）。3.支持集群、负载均衡。4.拥有完善的管理机制、报警方案等。5.能够实现自动管理功能。6.简单易学。
    类似于nginx（任何请求需要先交给nginx转发），分布式任务调度平台（任何job统一交给任务调度平台管理分发）
分布式环境下的定时job：
xxljob等，具体可通过GitHub搜索：https://github.com->搜索“分布式任务调度”，排名第一：xxljob。
XXL-JOB介绍：
1. 项目地址：
  https://github.com/xuxueli/xxl-job
2. 特色优点：
  1. 简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手；
  2. 动态：支持动态修改任务状态、启动/停止任务，以及终止运行中任务，即时生效；
  3. 调度中心HA（中心式）：调度采用中心式设计，“调度中心”自研调度组件并支持集群部署，可保证调度中心HA；
  4. 执行器HA（分布式）：任务分布式执行，任务"执行器"支持集群部署，可保证任务执行HA；
  5. 注册中心: 执行器会周期性自动注册任务, 调度中心将会自动发现注册的任务并触发执行。同时，也支持手动录入执行器地址；
  6. 弹性扩容缩容：一旦有新执行器机器上线或者下线，下次调度时将会重新分配任务；
  7. 路由（负载均衡）策略：执行器集群部署时提供丰富的路由策略，包括：第一个、最后一个、轮询、随机、一致性HASH、最不经常使用、最近最久未使用、故障转移、忙碌转移等；
  8. 故障转移：任务路由策略选择"故障转移"情况下，如果执行器集群中某一台机器故障，将会自动Failover切换到一台正常的执行器发送调度请求。
  9. 阻塞处理策略：调度过于密集执行器来不及处理时的处理策略，策略包括：单机串行（默认）、丢弃后续调度、覆盖之前调度；
  10. 任务超时控制：支持自定义任务超时时间，任务运行超时将会主动中断任务；
  11. 任务失败重试：支持自定义任务失败重试次数，当任务失败时将会按照预设的失败重试次数主动进行重试；其中分片任务支持分片粒度的失败重试；
  12. 任务失败告警；默认提供邮件方式失败告警，同时预留扩展接口，可方便的扩展短信、钉钉等告警方式；
  13. 分片广播任务：执行器集群部署时，任务路由策略选择"分片广播"情况下，一次任务调度将会广播触发集群中所有执行器执行一次任务，可根据分片参数开发分片任务；
  14. 动态分片：分片广播任务以执行器为维度进行分片，支持动态扩容执行器集群从而动态增加分片数量，协同进行业务处理；在进行大数据量业务操作时可显著提升任务处理能力和速度。
  15. 事件触发：除了"Cron方式"和"任务依赖方式"触发任务执行之外，支持基于事件的触发任务方式。调度中心提供触发任务单次执行的API服务，可根据业务事件灵活触发。
  16. 任务进度监控：支持实时监控任务进度；
  17. Rolling实时日志：支持在线查看调度结果，并且支持以Rolling方式实时查看执行器输出的完整的执行日志；
  18. GLUE：提供Web IDE，支持在线开发任务逻辑代码，动态发布，实时编译生效，省略部署上线的过程。支持30个版本的历史版本回溯。
  19. 脚本任务：支持以GLUE模式开发和运行脚本任务，包括Shell、Python、NodeJS、PHP、PowerShell等类型脚本;
  20. 命令行任务：原生提供通用命令行任务Handler（Bean任务，“CommandJobHandler”）；业务方只需要提供命令行即可；
  21. 任务依赖：支持配置子任务依赖，当父任务执行结束且执行成功后将会主动触发一次子任务的执行, 多个子任务用逗号分隔；
  22. 一致性：“调度中心”通过DB锁保证集群分布式调度的一致性, 一次任务调度只会触发一次执行；
  23. 自定义任务参数：支持在线配置调度任务入参，即时生效；
  24. 调度线程池：调度系统多线程触发调度运行，确保调度精确执行，不被堵塞；
  25. 数据加密：调度中心和执行器之间的通讯进行数据加密，提升调度信息安全性；
  26. 邮件报警：任务失败时支持邮件报警，支持配置多邮件地址群发报警邮件；
  27. 推送maven中央仓库: 将会把最新稳定版推送到maven中央仓库, 方便用户接入和使用;
  28. 运行报表：支持实时查看运行数据，如任务数量、调度次数、执行器数量等；以及调度报表，如调度日期分布图，调度成功分布图等；
  29. 全异步：任务调度流程全异步化设计实现，如异步调度、异步运行、异步回调等，有效对密集调度进行流量削峰，理论上支持任意时长任务的运行；
  30. 跨语言：调度中心与执行器提供语言无关的 RESTful API 服务，第三方任意语言可据此对接调度中心或者实现执行器。除此之外，还提供了 “多任务模式”和“httpJobHandler”等其他跨语言方案；
  31. 国际化：调度中心支持国际化设置，提供中文、英文两种可选语言，默认为中文；
  32. 容器化：提供官方docker镜像，并实时更新推送dockerhub，进一步实现产品开箱即用；
  33. 线程池隔离：调度线程池进行隔离拆分，慢任务自动降级进入"Slow"线程池，避免耗尽调度线程，提高系统稳定性；
  34. 用户管理：支持在线管理系统用户，存在管理员、普通用户两种角色；
  35. 权限控制：执行器维度进行权限控制，管理员拥有全量权限，普通用户需要分配执行器权限后才允许相关操作；
3. 文档地址：
  https://www.xuxueli.com/xxl-job/
4. 使用步骤：
  1. 从github上下载对应的项目包。
  2. 部署: xxl-job-admin 作为注册中心。
  3. 创建执行器（具体调度地址）可以支持集群。
  4. 配置文件需要填写xxl-job注册中心地址。
  5. 每个具体执行job服务器需要创建一个netty连接端口号。
  6. 需要执行job的任务类，集成IJobHandler抽象类注册到job容器中。
  7. Execute方法中编写具体job任务。
5. 客户端对接：
  1. 配置文件：
```
########################################################
## xxljob 执行器配置
########################################################
### xxl-job admin address list, such as "http://address" or "http://address01,http://address02"
xxl.job.admin.addresses=http://127.0.0.1:8081/xxl-job-admin
### xxl-job executor address
xxl.job.executor.appname=sample-xxl
#xxl.job.executor.ip=
xxl.job.executor.port=9999
### xxl-job log path
xxl.job.executor.logpath=/applog/
### xxl-job log retention days
xxl.job.executor.logretentiondays=-1

### xxl-job, access token
xxl.job.accessToken=

xxl.job.executor.start=false
```
  2. Java代码：
```
/**
 * 任务Handler的一个Demo（Bean模式）
 * 开发步骤： 
 * 1、继承 “IJobHandler” ；
 *  2、装配到Spring，例如加 “@Service” 注解； 
 * 3、加 “@JobHander”注解，注解value值为新增任务生成的JobKey的值;多个JobKey用逗号分割; 
 * 4、执行日志：需要通过 "XxlJobLogger.log"打印执行日志；
 */
@JobHander(value = "demoJobHandler")
@Service
public class DemoJobHandler extends IJobHandler {
	
	@Value("${xxl.job.executor.port}")
	private String port;
	
	@Override
	public ReturnT<String> execute(String... params) throws Exception {
		XxlJobLogger.log("XXL-JOB, Hello World." + port);
		System.out.println("XXL-JOB, Hello World." + port);
		for (int i = 0; i < 5; i++) {
			XxlJobLogger.log("beat at:" + i);
			// TimeUnit.SECONDS.sleep(2);
		}
		return ReturnT.SUCCESS;
	}
}
```
XXL-JOB原理：
1. xxl-job底层是使用quartz框架进行包装的。
2. 任务调度平台执行流程原理：
  1. 创建执行器（客户端消费地址）。
  2. 创建任务，使用cron表达式进行执行。
  3. 任何一个Job会先在任务调度平台上执行一遍，往执行器地址发一个请求。
3. 执行器端执行流程原理：
  1. 注册到admin平台。
  2. 创建socket服务端（ip和端口号）
  3. JobHandler将当前class信息地址注册到admin平台中。

努力的程序员先生

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
分布式定时任务-XXL-JOB

一、什么是定时任务？定时任务顾名思义就是：指定时间去执行任务。二、实现定时任务的方案？单台服务器的定时job：使用Quartz第三方框架。SpringBoot中的定时任务注解@Schedule。使用线程池executor中的ScheduledExecutorService。使用java.util包下的TimeTask。通过Thread进行实现（以上框架底层基本都是采用此种方式）...
复制链接

扫一扫