分布式定时任务-XXL-JOB

一、什么是定时任务？

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

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

1. 单台服务器的定时job：

   1. 通过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();
      	}
      }
      

   2. 使用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);
      	}
      
      }
      

   3. 使用线程池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);
      	}
      
      }
      

   4. SpringBoot中的定时任务注解@Schedule。
   5. 使用Quartz第三方框架。
      1. 引入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>
         

      2. 创建任务调度类：

         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()));
         	}
         
         }
         

      3. 创建启动类：

         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();
         
         	}
         }
         

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

2. 在分布式集群的情况下，怎么解决任务调度幂等性问题（不重复）？

   1. 解决思路：
      在集群的情况下，让job只能被1台服务器执行。
      多个jvm进行通讯，只能让一个jvm去执行任务调度。
   2. 解决方案列举：
      1. Zookeeper分布式锁：使用临时节点作为锁，临时节点不唯一，当其它连接会话关闭时，临时节点就会释放锁资源，等待其它连接进行分配。
         缺点：如果针对大型互联网公司，每天使用定时任务的需求非常懂的情况，就存在不易扩展、效率低、编写代码复杂的缺点。
      2. 使用配置文件做开关，缺点：适合小项目，不适合大项目。
      3. 使用数据库表的唯一性约束，缺点：不靠谱，效率不高。
         以上3种方式都有一个共性，就是没有容错机制、效率低、资源没有得到合理利用、不能解决高并发大流量的需求。
      4. 使用分布式任务调度平台（最合理），如：xxljob、antares等。
         优点：1.可以解决分布式任务调度幂等性问题。2.解决高可用问题（容错）。3.支持集群、负载均衡。4.拥有完善的管理机制、报警方案等。5.能够实现自动管理功能。6.简单易学。
         类似于nginx（任何请求需要先交给nginx转发），分布式任务调度平台（任何job统一交给任务调度平台管理分发）

3. 分布式环境下的定时job：
   xxljob等，具体可通过GitHub搜索：https://github.com->搜索“分布式任务调度”，排名第一：xxljob。

4. 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;
         	}
         }
         

5. XXL-JOB原理：

   1. xxl-job底层是使用quartz框架进行包装的。
   2. 任务调度平台执行流程原理：
      1. 创建执行器（客户端消费地址）。
      2. 创建任务，使用cron表达式进行执行。
      3. 任何一个Job会先在任务调度平台上执行一遍，往执行器地址发一个请求。
   3. 执行器端执行流程原理：
      1. 注册到admin平台。
      2. 创建socket服务端（ip和端口号）
      3. JobHandler将当前class信息地址注册到admin平台中。