精华内容
下载资源
问答
  • 任务的调度
    千次阅读
    2022-04-14 13:08:49

    1. 定时任务调度概述

    1.1 业务场景概述

    日常开发中定时任务使用场景很多,比如支付系统每天凌晨定时清算对账;未支付订单超时回收;商品定时上下架等等。定时任务框架选择有很多,面对不同的业务场景可以选择不同的定时任务框架,比如操作系统自带的定时任务Linux的crontab,Windows的任务计划等,在某些相对简单的场景下也是可以使用的,这里就不在详细探讨,本文主要讲述Java框架下的定时任务框架。

    1.2 任务调度场景

    时间驱动/事件驱动:内部系统一般可以通过时间来驱动,但涉及到外部系统,则只能使用时间驱动。如怕取外部网站价格,每小时爬一次。

    批量处理/逐条处理:批量处理堆积的数据更加高效,在不需要实时性的情况下比消息中间件更有优势。而且有的业务逻辑只能批量处理。如移动每个月结算我们的话费。

    实时性/非实时性:消息中间件能够做到实时处理数据,但是有些情况下并不需要实时,比如:vip升级。

    系统内部/系统解耦:定时任务调度一般是在系统内部,而消息中间件可用于两个系统间。

    1.3 调度任务分类

    1.单机定时任务
    timer:是一个定时器类,通过该类可以为指定的定时任务进行配置。TimerTask类是一个定时任务类,该类实现了Runnable接口,缺点异常未检查会中止线程。

    ScheduledExecutorService:相对延迟或者周期作为定时任务调度,缺点没有绝对的日期或者时间。

    springTask:配置简单功能较多,如果系统使用单机的话可以优先考虑spring定时器。

    2.分布式定时任务
    Quartz:Java事实上的定时任务标准。但Quartz关注点在于定时任务而非数据,并无一套根据数据处理而定制化的流程。虽然Quartz可以基于数据库实现作业的高可用,但缺少分布式并行调度的功能。
    Quartz官方网址:http://www.quartz-scheduler.org/
    Quartz官方文档:http://www.quartz-scheduler.org/documentation/
    Quartz原码地址:https://github.com/quartz-scheduler/quartz

    xxl-job:是大众点评员工徐雪里于2015年发布的分布式任务调度平台,是一个轻量级分布式任务调度框架,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。产品功能丰富,开箱即用。
    xxl-job 社区地址: https://www.xuxueli.com/xxl-job/
    xxl-job github地址:https://github.com/xuxueli/xxl-job/
    xxl-job gitee地址: https://gitee.com/xuxueli0323/xxl-job

    elastic-job:当当开源的弹性分布式任务调度系统,目前赠送给Apache开源基金会。
    ElasticJob 是一个分布式调度解决方案,由 2 个相互独立的子项目 ElasticJob-Lite 和 ElasticJob-Cloud 组成。
    ElasticJob-Lite 定位为轻量级无中心化解决方案,使用jar的形式提供分布式任务的协调服务;
    ElasticJob-Cloud 使用 Mesos 的解决方案,额外提供资源治理、应用分发以及进程隔离等服务。
    ElasticJob 的各个产品使用统一的作业 API,开发者仅需要一次开发,即可随意部署。
    elastic-job文档地址:https://shardingsphere.apache.org/elasticjob/index_zh.html

    SchedulerX:分布式任务调度SchedulerX是阿里巴巴自研的基于Akka架构的分布式任务调度平台,兼容开源XXL-JOB、ElasticJob,支持Cron定时、一次性任务、任务编排、分布式执行批量任务等功能,具备高可用、可视化、可运维、低延时等能力。
    SchedulerX文档地址:https://help.aliyun.com/document_detail/148185.html

    Saturn:Saturn (任务调度系统)是唯品会开源的一个分布式任务调度平台,取代传统的Linux Cron/Spring Batch Job的方式,做到全域统一配置,统一监控,任务高可用以及分片并发处理。Saturn是在当当开源的Elastic Job基础上,结合各方需求和我们的实践见解改良而成。
    Saturn gitee文档地址:https://gitee.com/vipshop/Saturn?utm_source=alading&utm_campaign=repo
    Saturn github文档地址:https://github.com/vipshop/Saturn

    2. 定时任务调度详解

    2.1 Timer

    Timer类是jdk专门提供的定时器工具,用来在后台线程计划执行指定任务,在java.util包下,要跟TimerTask一起配合使用。TimerTask单机单线程加锁阻塞执行的,Timer类其实是一个任务调度器,它里面包含了一个TimerThread线程,在这个线程中无限循环从TaskQueue中获取TimerTask(该类实现了Runnable接口),调用其run方法,就能异步执行定时任务。我们需要继承TimerTask类,实现它的run方法,在该方法中加上自己的业务逻辑。

    使用方式
    先实例化一个Timer类,然后调用它的schedule方法,在该方法中实例化TimerTask类,业务逻辑写在run方法中。schedule方法最后的两次参数分别表示:延迟时间 和 间隔时间,单位是毫秒。上面例子中,设置的定时任务是每隔1秒执行一次,延迟2秒执行。

    主要方法
    schedule(TimerTask task, Date time), 指定任务task在指定时间time执行
    schedule(TimerTask task, long delay), 指定任务task在指定延迟delay后执行
    schedule(TimerTask task, Date firstTime,long period),指定任务task在指定时间firstTime执行后,进行重复固定延迟频率peroid的执行
    schedule(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后,进行重复固定延迟频率peroid的执行
    scheduleAtFixedRate(TimerTask task,Date firstTime,long period), 指定任务task在指定时间firstTime执行后,进行重复固定延迟频率peroid的执行
    scheduleAtFixedRate(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后,进行重复固定延迟频率peroid的执行

    存在问题
    1.由于Timer是单线程执行任务,如果其中一个任务耗时非常长,会影响其他任务的执行。
    2.如果TimerTask抛出RuntimeException,Timer会停止所有任务的运行。

    优缺点
    优点:非常方便实现多个周期性的定时任务,并且支持延迟执行,还支持在指定时间之后支持,功能还算强大。

    缺点:如果其中一个任务耗时非常长,会影响其他任务的执行。并且如果TimerTask抛出RuntimeException,Timer会停止所有任务的运行,所以阿里巴巴开发者规范中不建议使用它。

    操作验证

        /**
         * TimerTask
         */
        private void timerTaskTest() {
            java.util.TimerTask timerTask = new java.util.TimerTask() {
                @Override
                public void run() {
                    System.out.println("【JavaTask】"+Thread.currentThread().getName() + ",TimerTask," + DateUtil.date());
                }
            };
            Timer timer = new Timer();
            timer.schedule(timerTask, 10, 3000);
        }
    

    2.2 ScheduledExecutorService

    ScheduledExecutorService是JDK1.5+版本引进的定时任务,该类位于java.util.concurrent并发包下。相当于多线程版本的Timer,ScheduledExecutorService是基于多线程的,设计的初衷是为了解决Timer单线程执行,多个任务之间会互相影响的问题。

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

    使用方式
    调用ScheduledExecutorService类的scheduleAtFixedRate方法实现周期性任务,每隔1秒钟执行一次,每次延迟1秒再执行。这种定时任务是阿里巴巴开发者规范中用来替代Timer类的方案,对于多线程执行周期性任务,是个不错的选择。

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

    操作验证

        /**
         * ScheduledExecutorService
         */
        private void ScheduledExecutorTest() {
            //为了方便测试这里使用线程池工具创建线程池,建议手动创建线程池,避免内存溢出
            ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
    
            //按照固定频率执行,每隔5秒跑一次
            ses.scheduleAtFixedRate(() -> System.out.println("【JavaTask】ScheduledExecutorService-1," + DateUtil.date()), 0, 5, TimeUnit.SECONDS);
    
            //按照固定延时执行,上次执行完后隔3秒再跑
            ses.scheduleWithFixedDelay(() -> System.out.println("【JavaTask】ScheduledExecutorService-2," + DateUtil.date()), 0, 3, TimeUnit.SECONDS);
        }
    

    2.3 SpringTask

    spring task是spring3以上版本自带的定时任务,实现定时任务的功能时,需要引入spring-context包,目前它支持:xml 和 注解 两种方式。由于xml方式太古老了,我们以springboot项目中注解方式为例。

    主要方法
    @EnableScheduling 开启调度
    @Scheduled(cron = “10 * * * * ?”) cron 表达式
    @Scheduled(fixedRate = 5000) 循环调用
    @Scheduled(fixedDelay = 3000) 循环延迟调用

    cron规则
    spring4以上的版本中,cron表达式包含6个参数:[秒] [分] [时] [日期] [月] [星期]

    支持几个常用的特殊符号:
        *:表示任何时间触发任务
        ,:表示指定的时间触发任务
        -:表示一段时间内触发任务
        /:表示从哪一个时刻开始,每隔多长时间触发一次任务。
        ?:表示用于月中的天和周中的天两个子表达式,表示不指定值。
    
    cron表达式参数具体含义:
        秒,取值范围:0-59,支持*、,、-、/。
        分,取值范围:0-59,支持*、,、-、/。
        时,取值范围:0-23,支持*、,、-、/。
        日期,取值范围:1-31,支持*、,、-、/。比秒多了?,表示如果指定的星期触发了,则配置的日期变成无效。
        月,取值范围:1-12,支持*、,、-、/。
        星期,取值范围:1~7,1代表星期天,6代表星期六,其他的以此类推。支持*、,、-、/、?。比秒多了?,表示如果指定的日期触发了,则配置的星期变成无效。
    
    常见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框架自带的定时功能,springboot做了非常好的封装,开启和定义定时任务非常容易,支持复杂的cron表达式,可以满足绝大多数单机版的业务场景。单个任务时,当前次的调度完成后,再执行下一次任务调度。
    缺点:默认单线程,如果前面的任务执行时间太长,对后面任务的执行有影响。不支持集群方式部署,不能做数据存储型定时任务。

    操作验证

    package com.zrj.flowable.job;
    
    import cn.hutool.core.date.DateUtil;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Component;
    
    /**
     * SpringTask
     * 项目启动,定时任务同时启动开始运行
     *
     * @author zrj
     * @since 2022/4/13
     **/
    @Component
    @EnableScheduling
    public class ScheduledSpringTask {
    
        /**
         * 每分钟的第10秒跑一次
         * <p>
         * 配置文件配置:@ Scheduled(cron = "${sue.spring.task.cron}")
         * 直接代码表达式:@ Scheduled(cron = "10 * * * * ?")
         */
        @Scheduled(cron = "10 * * * * ?")
        public void cronTask() throws InterruptedException {
            System.out.println("【SpringTask】" + Thread.currentThread().getName() + ",cronTask," + DateUtil.date());
        }
    
        /**
         * 每隔5秒跑一次
         */
        @Scheduled(fixedRate = 5000)
        public void fixedRateTask() throws InterruptedException {
            System.out.println("【SpringTask】" + Thread.currentThread().getName() + ",fixedRateTask," + DateUtil.date());
        }
    
        /**
         * 上次跑完隔3秒再跑
         */
        @Scheduled(fixedDelay = 3000)
        public void fixedDelayTask() throws InterruptedException {
            System.out.println("【SpringTask】" + Thread.currentThread().getName() + ",fixedDelayTask," + DateUtil.date());
        }
    }
    
    

    2.4 Quartz

    quartz是OpenSymphony开源组织在Job scheduling领域的开源项目,是由java开发的一个开源的任务日程管理系统。Quartz是一套轻量级的任务调度框架,只需要定义了 Job(任务),Trigger(触发器)和 Scheduler(调度器),即可实现一个定时调度能力。支持基于数据库的集群模式,可以做到任务幂等执行。
    Quartz 支持任务幂等执行,其实理论上还是抢 DB 锁。quartz 表QRTZ_LOCKS 就是 Quartz 集群实现同步机制的行锁表。其中有 5 条记录,代表 5 把锁,分别用于实现多个 Quartz Node 对 Job、Trigger、Calendar 访问的同步控制。

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

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

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

    操作验证
    引入依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
    </dependency>
    

    Quartz执行任务

    package com.zrj.flowable.job;
    
    import org.quartz.JobDataMap;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.springframework.scheduling.quartz.QuartzJobBean;
    
    /**
     * Quartz执行任务
     *
     * @author zrj
     * @since 2022/4/13
     **/
    public class ScheduledQuartzTask extends QuartzJobBean {
        @Override
        protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
            String taskName = (String) jobDataMap.get("taskName");
            String userName = (String) jobDataMap.get("userName");
            System.out.println("【ScheduledQuartzTask】taskName=" + taskName + ",userName=" + userName);
        }
    }
    
    

    Quartz配置

    package com.zrj.flowable.job;
    
    import org.quartz.*;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * Quartz配置
     *
     * @author zrj
     * @since 2022/4/13
     **/
    @Configuration
    public class ScheduledQuartzConfig {
        @Value("${sue.spring.quartz.cron:*/5 * * * * ?}")
        private String testCron;
    
        /**
         * 创建定时任务
         */
        @Bean
        public JobDetail quartzTestDetail() {
            JobDetail jobDetail = JobBuilder.newJob(ScheduledQuartzTask.class)
                    .withIdentity("scheduledQuartzTask", "QUARTZ_TASK_TEST")
                    .usingJobData("userName", "Jerry")
                    .usingJobData("taskName", "ScheduledQuartzTask")
                    .storeDurably()
                    .build();
            return jobDetail;
        }
    
        /**
         * 创建触发器
         */
        @Bean
        public Trigger quartzTestJobTrigger() {
            //每隔5秒执行一次
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(testCron);
    
            //创建触发器
            Trigger trigger = TriggerBuilder.newTrigger()
                    .forJob(quartzTestDetail())
                    .withIdentity("quartzTestJobTrigger", "QUARTZ_TASK_JOB_TRIGGER")
                    .withSchedule(cronScheduleBuilder)
                    .build();
            return trigger;
        }
    
    }
    
    

    2.5 xxl-job

    XXL-JOB是一个分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线,开箱即用。xxl-job框架对quartz进行了扩展,使用mysql数据库存储数据,并且内置jetty作为RPC服务调用。主要包括调度中心和执行器,调度中心用于配置调度任务,执行器一般集成于项目,通过rpc注册到注册中心,注册中心通过配置参数实现定时调用。

    另外在xxl-job对外提供的rest接口可以通过后台直接实现任务配置,业务开发中通常有一种场景,就是本身不知道何时触发执行调度任务,这时候大多采用定时周期性扫描判断是否需要执行,比如每三分钟扫一次表判断商品是否过期,然后触发下架操作,这种方式虽然与业务解耦,但是对服务器损耗比较大,浪费大量的服务资源,尤其是对实时性要求比较高的场景,还有一种解决方案是根据商品的过期时间通过xxl-job后台提供的接口创建一条执行任务,到时间自动执行相关操作,这种情况可避免不知何时触达调度而循环扫描浪费资源的情况,但是如果商品数据量巨大,创建任务量特别大的情景不如第一种更适合,两种思路,具体使用一定结合具体的业务场景使用。

    主要模块
    调度中心:需要搭建调度中心项目。
    执行器:需要集成执行器客户端。

    使用方式
    官方文档极为详细,这里就不再赘述。
    官方文档地址:https://www.xuxueli.com/xxl-job/
    源码仓库地址 github:https://github.com/xuxueli/xxl-job
    源码仓库地址 gitee:http://gitee.com/xuxueli0323/xxl-job

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

    操作验证
    执行之前,需要完成xxl-admin管理后台部署和mysql脚本执行等这些前期准备工作。

    相关依赖

    <dependency>
       <groupId>com.xuxueli</groupId>
       <artifactId>xxl-job-core</artifactId>
    </dependency>
    

    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

    @JobHandler(value = "helloJobHandler")
    @Component
    public class HelloJobHandler extends IJobHandler {
    
        @Override
        public ReturnT<String> execute(String param) {
            System.out.println("XXL-JOB, Hello World.");
            return SUCCESS;
        }
    }
    

    2.6 elastic-job

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

    ElasticJob 是面向互联网生态和海量任务的分布式调度解决方案,由两个相互独立的子项目 ElasticJob-Lite 和 ElasticJob-Cloud 组成。 它通过弹性调度、资源管控、以及作业治理的功能,打造一个适用于互联网场景的分布式调度解决方案,并通过开放的架构设计,提供多元化的作业生态。 它的各个产品使用统一的作业 API,开发者仅需一次开发,即可随意部署。
    ElasticJob 已于 2020 年 5 月 28 日成为 Apache ShardingSphere 的子项目。elastic-job在2.x之后,出了两个产品线:Elastic-Job-Lite和Elastic-Job-Cloud,而我们一般使用Elastic-Job-Lite就能够满足需求。Elastic-Job-Lite定位为轻量级无中心化解决方案,使用jar包的形式提供分布式任务的协调服务,外部仅依赖于Zookeeper。

    ElasticJob 官网地址:https://shardingsphere.apache.org/elasticjob/index_zh.html

    功能列表
    1.弹性调度
    支持任务在分布式场景下的分片和高可用
    能够水平扩展任务的吞吐量和执行效率
    任务处理能力随资源配备弹性伸缩

    2.资源分配
    在适合的时间将适合的资源分配给任务并使其生效
    相同任务聚合至相同的执行器统一处理
    动态调配追加资源至新分配的任务

    3.作业治理
    失效转移
    错过作业重新执行
    自诊断修复

    4.作业依赖(TODO)
    基于有向无环图(DAG)的作业间依赖
    基于有向无环图(DAG)的作业分片间依赖

    5.作业开放生态
    可扩展的作业类型统一接口
    丰富的作业类型库,如数据流、脚本、HTTP、文件、大数据等
    易于对接业务作业,能够与 Spring 依赖注入无缝整合

    6.可视化管控端
    作业管控端
    作业执行历史数据追踪
    注册中心管理

    使用方式
    ElasticJob-Lite定位为轻量级无中心化解决方案,使用 jar 的形式提供分布式任务的协调服务。
    在这里插入图片描述
    优缺点
    优点:支持分布式调度协调,支持分片,适合高并发,和一些业务相对来说较复杂的场景。
    缺点:依赖过重,需要依赖于zookeeper,实现定时任务相对于xxl-job要复杂一些,要对分片规则非常熟悉。

    操作验证
    相关依赖

    <dependency>
        <groupId>com.dangdang</groupId>
        <artifactId>elastic-job-lite-core</artifactId>
    </dependency>
    <dependency>
        <groupId>com.dangdang</groupId>
        <artifactId>elastic-job-lite-spring</artifactId>
    </dependency>
    

    配置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;
        }
    }
    

    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
    
    更多相关内容
  • cloudsim任务调度课件
  • 介绍了云计算,对任务调度在云计算中的地位做了分析,并由任务调度出发,对云计算任务调度算法的研究现状进行分类、梳理和总结.根据调度目标的不同,将算法分为单目标优化的任务调度算法和多目标的任务调度算法,对...
  • 主要介绍了python任务调度实现方法,实例分析了任务调度的原理与Python实现方法,需要的朋友可以参考下
  • 针对卫星任务调度“一星一系统”、测运控分离的现状,以卫星执行任务产生的星上独立事件和星地协同事件作为调度对象,以事件可执行时机作为调度资源,建立卫星任务调度统一化约束满足模型,将传统运控任务调度与测控任务...
  • 任务调度中心平台设计与使用经验 标签:分布式任务调度 当“调度中心”和“执行器”项目已经成功部署并启动,我们则进入调度中心平台进行任务管理与使用。
  • 任务者 基于golang的分布式任务调度框架 基于Leader-Listener模式 使用redis作为存储和分配任务 支持任务失败自动重试
  •  在静态任务调度中,任务调度的开销比较小,任务调度的总长度成为评价一个任务调度算法的性能标准,除此之外还有任务调度长度比率、算法的效率等,具体的评定标准和公式如下:  (1)调度长度makespan,为所有...
  • 文章论述云计算环境下任务调度的概念、特点和目标,归纳了云计算任务调度的研究现状,并对传统任务调度算法、Hadoop中的任务调度算法、智能化的任务调度算法的实现机制和性能指标等进行了分析与比较。分析结果表明智能...
  • 基于定时器的小型任务调度器,占用很少的RAM
  • 任务调度问题就是给定一个有穷单位时间任务的集合S,集合S中的每个任务都有一个截止期限di和超时惩罚wi,需要找出集合S的一个调度,使得因任务误期所导致的总惩罚最小,这个调度也称为S的一个最优调度。
  • 分布式任务调度

    千次阅读 2021-08-18 09:00:40
    任务调度是指系统为了自动完成特定任务,在约定的特定时刻去执行任务的过程。有了任务调度即可解放更多的人力,而是由系统自动去执行任务。 如何实现任务调度? - 多线程方式,结合sleep - JDK提供的API

    一、概述

    1、定义

    业务场景
    - 某电商系统需要在每天上午10点,下午3点,晚上8点发放一批优惠券。
    - 某银行系统需要在信用卡到期还款日的前三天进行短信提醒。
    - 某财务系统需要在每天凌晨0:10结算前一天的财务数据,统计汇总。
    - 12306会根据车次的不同,设置某几个时间点进行分批放票。
    

    任务调度是指系统为了自动完成特定任务,在约定的特定时刻去执行任务的过程。有了任务调度即可解放更多的人力,而是由系统自动去执行任务。

    • 如何实现任务调度?
    - 多线程方式,结合sleep
    - JDK提供的API,例如:TimerScheduledExecutor
    - 框架,例如Quartz ,它是一个功能强大的任务调度框架,可以满足更多更复杂的调度需求
    - spring task
    

    2、分布式任务调度

    当前软件的架构已经开始向分布式架构转变,将单体结构拆分为若干服务,服务之间通过网络交互来完成业务处理。在分布式架构下,一个服务往往会部署多个实例来运行我们的业务,如果在这种分布式系统环境下运行任务调度,我们称之为分布式任务调度
    在这里插入图片描述

    将任务调度程序分布式构建,这样就可以具有分布式系统的特点,并且提高任务的调度处理能力:

    • 1、并行任务调度
      并行任务调度实现靠多线程,如果有大量任务需要调度,此时光靠多线程就会有瓶颈了,因为一台计算机CPU的处理能力是有限的。
      如果将任务调度程序分布式部署,每个结点还可以部署为集群,这样就可以让多台计算机共同去完成任务调度,我们可以将任务分割为若干个分片,由不同的实例并行执行,来提高任务调度的处理效率。
    • 2、高可用
      若某一个实例宕机,不影响其他实例来执行任务。
    • 3、弹性扩容
      当集群中增加实例就可以提高并执行任务的处理效率。
    • 4、任务管理与监测
      对系统中存在的所有定时任务进行统一的管理及监测。让开发人员及运维人员能够时刻了解任务执行情况,从而做出快速的应急处理响应。
    • 分布式任务调度面临的问题:
      当任务调度以集群方式部署,同一个任务调度可能会执行多次,例如:电商系统定期发放优惠券,就可能重复发放优惠券,对公司造成损失,信用卡还款提醒就会重复执行多次,给用户造成烦恼,所以我们需要控制相同的任务在多个运行实例上只执行一次。常见解决方案:

    • 分布式锁,多个实例在任务执行前首先需要获取锁,如果获取失败那么就证明有其他服务已经在运行,如果获取成功那么证明没有服务在运行定时任务,那么就可以执行。

    • ZooKeeper选举,利用ZooKeeper对Leader实例执行定时任务,执行定时任务的时候判断自己是否是Leader,如果不是则不执行,如果是则执行业务逻辑,这样也能达到目的。

    二、使用

    1、springtask

    • cron表达式

    cron表达式是一个字符串, 用来设置定时规则, 由七部分组成, 每部分中间用空格隔开, 每部分的含义如下表所示:
    在这里插入图片描述
    cron表达式还可以包含一些特殊符号来设置更加灵活的定时规则, 如下表所示:
    在这里插入图片描述
    在这里插入图片描述

    • 依赖
     <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
    • 代码
    - 启动类
    @SpringBootApplication
    @EnableScheduling
    public class SpringTaskApp {
        public static void main(String[] args) {
            SpringApplication.run(SpringTaskApp.class,args);
        }
    }
    
    
    
    - 调度类
     @RestController
    public class TaskController {
    
    
        @GetMapping
        @Scheduled(cron = "0/5 * * * * ?")
        public ResponseEntity<Map<String,Object>> getAll(){
            System.out.println("定时任务执行了");
    
            Map<String, Object> map = new HashMap<>();
            map.put("status","定时任务执行了");
            ResponseEntity<Map<String,Object>> responseEntity = new ResponseEntity<>(map, HttpStatus.OK);
            return responseEntity;
        }
    }
    

    2、xxl-Job简介

    2.1 简介

    • 针对分布式任务调度的需求,市场上出现了很多的产品:
    1TBSchedule:淘宝推出的一款非常优秀的高性能分布式调度框架,目前被应用于阿里、京东、支付宝、国美等很多互联网企业的流程调度系统中。但是已经多年未更新,文档缺失严重,缺少维护。
    
    2) XXL-Job:大众点评的分布式任务调度平台,是一个轻量级分布式任务调度平台, 其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线,开箱即用。
    
    3Elastic-job:当当网借鉴TBSchedule并基于quartz 二次开发的弹性分布式任务调度系统,功能丰富强大,采用zookeeper实现分布式协调,具有任务高可用以及分片功能。
    
    4Saturn: 唯品会开源的一个分布式任务调度平台,基于Elastic-job,可以全域统一配置,统一监
    控,具有任务高可用以及分片功能。 
    
    XXL-JOB是一个分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线,开箱即用。
    
    • 特性
    - 简单灵活**
      提供Web页面对任务进行管理,管理系统支持用户管理、权限控制;
      支持容器部署;
      支持通过通用HTTP提供跨平台任务调度;
    - **丰富的任务管理功能**
      支持页面对任务CRUD操作;
      支持在页面编写脚本任务、命令行任务、Java代码任务并执行;
      支持任务级联编排,父任务执行结束后触发子任务执行;
      支持设置指定任务执行节点路由策略,包括轮询、随机、广播、故障转移、忙碌转移等;
      支持Cron方式、任务依赖、调度中心API接口方式触发任务执行
    - **高性能**
      任务调度流程全异步化设计实现,如异步调度、异步运行、异步回调等,有效对密集调度进行流量削峰;
    - **高可用**
      任务调度中心、任务执行节点均 集群部署,支持动态扩展、故障转移
      支持任务配置路由故障转移策略,执行器节点不可用是自动转移到其他节点执行
      支持任务超时控制、失败重试配置
      支持任务处理阻塞策略:调度当任务执行节点忙碌时来不及执行任务的处理策略,包括:串行、抛弃、覆盖策略
    - **易于监控运维**
      支持设置任务失败邮件告警,预留接口支持短信、钉钉告警;
      支持实时查看任务执行运行数据统计图表、任务进度监控数据、任务完整执行日志;
    

    2.2 快速入门

    在分布式架构下,通过XXL-Job实现定时任务
    在这里插入图片描述

    调度中心:负责管理调度信息,按照调度配置发出调度请求,自身不承担业务代码。
    任务执行器:负责接收调度请求并执行任务逻辑。
    任务:专注于任务的处理。
    调度中心会发出调度请求,任务执行器接收到请求之后会去执行任务,任务则专注于任务业务的处理。

    2.2.1 环境搭建

    • 源码仓库地址
    源码仓库地址Release Download
    https://github.com/xuxueli/xxl-jobDownload
    http://gitee.com/xuxueli0323/xxl-jobDownload

    2.1.3 初始化“调度数据库”

    请下载项目源码并解压,获取 “调度数据库初始化SQL脚本” 并执行即可。
    位置:/xxl-job/doc/db/tables_xxl_job.sql 共8张表
    调度中心支持集群部署,集群情况下各节点务必连接同一个mysql实例;
    如果mysql做主从,调度中心集群节点务必强制走主库;在这里插入图片描述

    - xxl_job_lock:任务调度锁表;
    - xxl_job_group:执行器信息表,维护任务执行器信息;
    - xxl_job_info:调度扩展信息表: 用于保存XXL-JOB调度任务的扩展信息,如任务分组、任务名、机器地址、执行器、执行入参和报警邮件等等;
    - xxl_job_log:调度日志表: 用于保存XXL-JOB任务调度的历史信息,如调度结果、执行结果、调度入参、调度机器和执行器等等;
    - xxl_job_logglue:任务GLUE日志:用于保存GLUE更新历史,用于支持GLUE的版本回溯功能;
    - xxl_job_registry:执行器注册表,维护在线的执行器和调度中心机器地址信息;
    - xxl_job_user:系统用户表;
    

    2.1.4 编译源码

    解压源码,按照maven格式将源码导入IDE, 使用maven进行编译即可,源码结构如下:
    在这里插入图片描述
    在这里插入图片描述

    2.1.5 配置部署“调度中心”

    调度中心项目:xxl-job-admin
    作用:统一管理任务调度平台上调度任务,负责触发调度执行,并且提供任务管理平台。

    • 步骤一:调度中心配置

    调度中心配置文件地址:/xxl-job/xxl-job-admin/src/main/resources/application.properties
    数据库的连接信息修改为自己的数据库

    ### web
    server.port=8888
    server.servlet.context-path=/xxl-job-admin
    
    ### actuator
    management.server.servlet.context-path=/actuator
    management.health.mail.enabled=false
    
    ### resources
    spring.mvc.servlet.load-on-startup=0
    spring.mvc.static-path-pattern=/static/**
    spring.resources.static-locations=classpath:/static/
    
    ### freemarker
    spring.freemarker.templateLoaderPath=classpath:/templates/
    spring.freemarker.suffix=.ftl
    spring.freemarker.charset=UTF-8
    spring.freemarker.request-context-attribute=request
    spring.freemarker.settings.number_format=0.##########
    
    ### mybatis
    mybatis.mapper-locations=classpath:/mybatis-mapper/*Mapper.xml
    #mybatis.type-aliases-package=com.xxl.job.admin.core.model
    
    ### xxl-job, datasource
    spring.datasource.url=jdbc:mysql://127.0.0.1:3306/xxl_job?Unicode=true&serverTimezone=Asia/Shanghai&characterEncoding=UTF-8
    spring.datasource.username=root
    spring.datasource.password=root
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    
    ### datasource-pool
    spring.datasource.type=com.zaxxer.hikari.HikariDataSource
    spring.datasource.hikari.minimum-idle=10
    spring.datasource.hikari.maximum-pool-size=30
    spring.datasource.hikari.auto-commit=true
    spring.datasource.hikari.idle-timeout=30000
    spring.datasource.hikari.pool-name=HikariCP
    spring.datasource.hikari.max-lifetime=900000
    spring.datasource.hikari.connection-timeout=10000
    spring.datasource.hikari.connection-test-query=SELECT 1
    
    ### xxl-job, email
    spring.mail.host=smtp.qq.com
    spring.mail.port=25
    spring.mail.username=xxx@qq.com
    spring.mail.password=xxx
    spring.mail.properties.mail.smtp.auth=true
    spring.mail.properties.mail.smtp.starttls.enable=true
    spring.mail.properties.mail.smtp.starttls.required=true
    spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory
    
    ### xxl-job, access token
    xxl.job.accessToken=
    
    ### xxl-job, i18n (default is zh_CN, and you can choose "zh_CN", "zh_TC" and "en")
    xxl.job.i18n=zh_CN
    
    ## xxl-job, triggerpool max size
    xxl.job.triggerpool.fast.max=200
    xxl.job.triggerpool.slow.max=100
    
    ### xxl-job, log retention days
    xxl.job.logretentiondays=30
    
    • 步骤二:部署项目
    • 执行maven打包命令:package
    • 打完包以后,从项目的target目录中找到jar包拷贝到不带空格和中文的目录下
    • 执行以下命令,启动项目
      java -jar xxl-job-admin-2.2.0-SNAPSHOT.jar

    调度中心访问地址:http://localhost:8888/xxl-job-admin (该地址执行器将会使用到,作为回调地址)
    在这里插入图片描述

    2.1.6 配置执行器

    在这里插入图片描述

    属性名称说明
    AppName是每个执行器集群的唯一标示AppName, 执行器会周期性以AppName为对象进行自动注册。可通过该配置自动发现注册成功的执行器, 供任务调度时使用;
    名称执行器的名称, 因为AppName限制字母数字等组成,可读性不强, 名称为了提高执行器的可读性;
    排序执行器的排序, 系统中需要执行器的地方,如任务新增, 将会按照该排序读取可用的执行器列表;
    注册方式调度中心获取执行器地址的方式;
    机器地址注册方式为"手动录入"时有效,支持人工维护执行器的地址信息;

    2.1.7 在调度中心新建任务

    在这里插入图片描述- 执行器:任务的绑定的执行器,任务触发调度时将会自动发现注册成功的执行器, 实现任务自动发现功能; 另一方面也可以方便的进行任务分组。每个任务必须绑定一个执行器, 可在 “执行器管理” 进行设置

    • 任务描述:任务的描述信息,便于任务管理

      路由策略:当执行器集群部署时,提供丰富的路由策略,包括

      • FIRST(第一个):固定选择第一个机器;

      • LAST(最后一个):固定选择最后一个机器;

      • ROUND(轮询):

      • RANDOM(随机):随机选择在线的机器;

      • CONSISTENT_HASH(一致性HASH):每个任务按照Hash算法固定选择某一台机器,且所有任务均匀散列在不同机器上。

      • LEAST_FREQUENTLY_USED(最不经常使用):使用频率最低的机器优先被选举;

      • LEAST_RECENTLY_USED(最近最久未使用):最久为使用的机器优先被选举;

      • FAILOVER(故障转移):按照顺序依次进行心跳检测,第一个心跳检测成功的机器选定为目标执行器并发起调度;

      • BUSYOVER(忙碌转移):按照顺序依次进行空闲检测,第一个空闲检测成功的机器选定为目标执行器并发起调度;

      • SHARDING_BROADCAST(分片广播):广播触发对应集群中所有机器执行一次任务,同时系统自动传递分片参数;可根据分片参数开发分片任务;

    • Cron:触发任务执行的Cron表达式;

    • 运行模式:

      • BEAN模式:任务以JobHandler方式维护在执行器端;需要结合 “JobHandler” 属性匹配执行器中任务;

      • GLUE模式(Java):任务以源码方式维护在调度中心;该模式的任务实际上是一段继承自IJobHandler的Java类代码并 “groovy” 源码方式维护,它在执行器项目中运行,可使用@Resource/@Autowire注入执行器里中的其他服务;

      • GLUE模式(Shell):任务以源码方式维护在调度中心;该模式的任务实际上是一段 “shell” 脚本;

      • GLUE模式(Python):任务以源码方式维护在调度中心;该模式的任务实际上是一段 “python” 脚本;

      • GLUE模式(PHP):任务以源码方式维护在调度中心;该模式的任务实际上是一段 “php” 脚本;

      • GLUE模式(NodeJS):任务以源码方式维护在调度中心;该模式的任务实际上是一段 “nodejs” 脚本;

      • GLUE模式(PowerShell):任务以源码方式维护在调度中心;该模式的任务实际上是一段 “PowerShell” 脚本;

    • JobHandler:运行模式为 “BEAN模式” 时生效,对应执行器中新开发的JobHandler类“@JobHandler”注解自定义的value值;

    • 阻塞处理策略:调度过于密集执行器来不及处理时的处理策略;

      • 单机串行(默认):调度请求进入单机执行器后,调度请求进入FIFO队列并以串行方式运行;

      • 丢弃后续调度:调度请求进入单机执行器后,发现执行器存在运行的调度任务,本次请求将会被丢弃并标记为失败;

      • 覆盖之前调度:调度请求进入单机执行器后,发现执行器存在运行的调度任务,将会终止运行中的调度任务并清空队列,然后运行本地调度任务;

    • 子任务:每个任务都拥有一个唯一的任务ID(任务ID可以从任务列表获取),当本任务执行结束并且执行成功时,将会触发子任务ID所对应的任务的一次主动调度。

    • 任务超时时间:支持自定义任务超时时间,任务运行超时将会主动中断任务;

    • 失败重试次数;支持自定义任务失败重试次数,当任务失败时将会按照预设的失败重试次数主动进行重试;

    • 报警邮件:任务调度失败时邮件通知的邮箱地址,支持配置多邮箱地址,配置多个邮箱地址时用逗号分隔;

    • 负责人:任务的负责人;

    • 执行参数:任务执行所需的参数;

    2.2.3 搭建springboot项目

    • pom文件
    <groupId>com.itheima</groupId>
    <artifactId>xxl-job-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 继承Spring boot工程 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
    </parent>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- xxl-job -->
        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>2.2.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    

    注意:如果项目中没有找到xxl-job-core这个依赖,需要把这个依赖安装到本地的maven仓库

    • 配置文件

    application.properties

    server.port=${port:8801}
    # no web
    #spring.main.web-environment=false
    
    # log config
    logging.config=classpath:logback.xml
    
    
    ### xxl-job admin address list, such as "http://address" or "http://address01,http://address02"
    xxl.job.admin.addresses=http://localhost:8888/xxl-job-admin
    
    ### xxl-job, access token
    xxl.job.accessToken=
    
    ### xxl-job executor appname
    xxl.job.executor.appname=xxl-job-executor-sample
    ### xxl-job executor registry-address: default use address to registry , otherwise use ip:port if address is null
    xxl.job.executor.address=
    ### xxl-job executor server-info
    xxl.job.executor.ip=
    xxl.job.executor.port=${executor.port:9999}
    ### xxl-job executor log-path
    xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
    ### xxl-job executor log-retention-days
    xxl.job.executor.logretentiondays=30
    

    logback.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration debug="false" scan="true" scanPeriod="1 seconds">
    
        <contextName>logback</contextName>
        <property name="log.path" value="/data/applogs/xxl-job/xxl-job-executor-sample-springboot.log"/>
    
        <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n</pattern>
            </encoder>
        </appender>
    
        <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${log.path}</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}.%d{yyyy-MM-dd}.zip</fileNamePattern>
            </rollingPolicy>
            <encoder>
                <pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
                </pattern>
            </encoder>
        </appender>
    
        <root level="info">
            <appender-ref ref="console"/>
            <appender-ref ref="file"/>
        </root>
    
    </configuration>
    
    • 引导类
    package com.itheima.xxljob;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class XxlJobApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(XxlJobApplication.class,args);
        }
    }
    
    • 添加xxl-job配置

    这个类主要是创建了任务执行器,参考官方案例编写,无须改动

    @Configuration
    public class XxlJobConfig {
        private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);
    
        @Value("${xxl.job.admin.addresses}")
        private String adminAddresses;
    
        @Value("${xxl.job.accessToken}")
        private String accessToken;
    
        @Value("${xxl.job.executor.appname}")
        private String appName;
    
        @Value("${xxl.job.executor.address}")
        private String address;
    
        @Value("${xxl.job.executor.ip}")
        private String ip;
    
        @Value("${xxl.job.executor.port}")
        private int port;
    
        @Value("${xxl.job.executor.logpath}")
        private String logPath;
    
        @Value("${xxl.job.executor.logretentiondays}")
        private int logRetentionDays;
    
    
        @Bean
        public XxlJobSpringExecutor xxlJobExecutor() {
            logger.info(">>>>>>>>>>> xxl-job config init.");
            XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
            xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
            xxlJobSpringExecutor.setAppName(appName);
            xxlJobSpringExecutor.setAddress(address);
            xxlJobSpringExecutor.setIp(ip);
            xxlJobSpringExecutor.setPort(port);
            xxlJobSpringExecutor.setAccessToken(accessToken);
            xxlJobSpringExecutor.setLogPath(logPath);
            xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
    
            return xxlJobSpringExecutor;
        }
    
        /**
         * 针对多网卡、容器内部署等情况,可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP;
         *
         *      1、引入依赖:
         *          <dependency>
         *             <groupId>org.springframework.cloud</groupId>
         *             <artifactId>spring-cloud-commons</artifactId>
         *             <version>${version}</version>
         *         </dependency>
         *
         *      2、配置文件,或者容器启动变量
         *          spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
         *
         *      3、获取IP
         *          String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
         */
    
    
    }
    
    • 创建任务
    @Component
    public class HelloJob {
    
        @Value("${server.port}")
        private String appPort;
    
        @XxlJob("helloJob")
        public ReturnT<String> hello(String param) throws Exception {
            System.out.println("helloJob:"+ LocalDateTime.now()+",端口号"+appPort);
            return ReturnT.SUCCESS;
        }
    }
    
    展开全文
  • 现有的很多调度算法存在时间复杂度过高或调度成功率低的问题。提出一种新的调度算法(HRTSA...最后通过任务复制调度以提高任务调度成功率。对比实验分析表明提出的HRTSA算法时间复杂度与RTSDA相比较低,调度成功率较高。
  • Quartz分布式任务调度原理

    千次阅读 2021-12-31 20:11:51
    什么是分布式定时任务调度 定时任务调度 在很多应用场景下我们需要定时执行一些任务,比如订单系统的超时状态判断、缓存数据的定时更新等等,最简单粗暴的方式是用while(true)+sleep的组合来空转,直到到达指定时间...

    什么是分布式定时任务调度

    定时任务调度

    在很多应用场景下我们需要定时执行一些任务,比如订单系统的超时状态判断、缓存数据的定时更新等等,最简单粗暴的方式是用while(true)+sleep的组合来空转,直到到达指定时间就执行任务,但这显然非常低效。更好的方法是使用系统提供的Timer定时器或者使用Quartz框架等等。

    持久化

    如果只是设置一两个固定的简单的定时任务,比如只需要定时把数据从磁盘更新到内存的缓存中,那不需要考虑太多,即使节点宕机了,重启后就会继续按原有频率继续执行定时任务,所以不需要考虑定时任务的持久化问题。

    但是如果业务场景比较复杂,需要设置非常多的定时任务,比如订单系统的超时状态判断,每个用户下单后都需要设置一个30分钟的定时任务,30分钟一到就执行任务判断用户是否已经支付,如果尚未支付就自动取消订单。如果机器在此期间宕机丢失内存数据,那么重启之后将会丢失所有定时任务,一大批的超时的未支付订单都不会被取消。因此,我们往往还需要考虑将定时任务写到磁盘中将其持久化,确保任务能够得到执行。

    分布式集群

    在单个机器节点上做定时任务调度比较简单直白,但弊端是

    • 一旦节点宕机,就无法提供定时任务调度的服务。
    • 单个节点的算力有限,无法支持大量定时调度任务。

    因此往往需要部署分布式集群来提供定时任务调度服务,分布式的定时任务调度系统需要考虑如何统一管理众多的定时任务

    • 如何保证每个任务只被一个节点执行(避免时间点到来时同一任务被重复执行)
    • 一个节点宕机时如何让其他节点接管其负责的定时任务
    • 等等。。。

    Quartz单点

    Quartz 是一个完全由 Java 编写的开源作业调度框架。

    Quartz基础

    参考Quartz-任务调度

    三个基础概念

    • 任务:需要执行的任务。
    • 触发器:触发器用于配置调度参数,设置触发条件。
    • 调度器:调度器将对应的触发器和任务绑定在一起,当触发器被触发时执行对应的任务。

    使用实例

    image-20211231173730078

    创建Job

    实现Job接口,并且重写execute方法,就是在这个方法里写我们要执行的任务

    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    /** 此类只是用来执行任务代码 */
    public class MyJob implements Job 
    { 
       @Override 
       public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
          System.out.println("这里是我们的任务代码"); 
       }
    }
    

    创建JobDetail

    我们写了MyJob这个类来实现了Job接口,接着我们就要通过创建JobDetail告诉Quartz,MyJob这个类是我们准备要执行的一个任务

     //2.2.3版本 注册任务 方式 
    JobDetail job = JobBuilder.newJob(MyJob.class)//设置要执行的任务是哪个类 
                              .withIdentity("helloJob", "group1")//设置任务信息 参数1任务名 参数2为组名
                              .build();//创建
    

    创建Trigger

    Quartz主要有两种触发器:

    1. SimpleTrigger触发器:设置一些简单的属性,如开始时间、结束时间、重复次数、重复间隔等。
    2. CronTrigger触发器:可以使用cron表达式来更灵活的控制时间,例如每年执行一次、每天几点执行、每月几号执行等。

    cron格式可以参考crontab格式 & golang时间格式

    //Trigger 是触发器接口,要通过TriggerBuilder来实例化一个
    TriggerTrigger trigger1 = TriggerBuilder.newTrigger()
                             //withIdentity(String name, String group) 指定触发器信息 参数1触发器名 参数2触发器组,如果不创建将自动生成
                             .withIdentity("trigger1", "test")
                              //withSchedule(ScheduleBuilder schedBuilder) 设置一个实现了ScheduleBuilder接口的触发器 
                             //这里我们演示的是SimpleTrigger触发器,所以要使用SimpleScheduleBuilder.simpleSchedule()方来创建 
                              .withSchedule(SimpleScheduleBuilder.simpleSchedule() 
                             //指定触发间隔,以秒为单位 
                             .withIntervalInSeconds(5)
                              //设置执行次数  
                             .withRepeatCount(5))
                             .build();//创建
    
    Trigger trigger2 = TriggerBuilder.newTrigger() 
                             .withIdentity("cron trigger", "test")
                             .withSchedule(
                             //这里我们演示的是CronTrigger触发器,所以要使用CronScheduleBuilder.cronSchedule()方来创建
                             //每5秒执行一次
     CronScheduleBuilder.cronSchedule("0/5 * * ? * *")).build();
    

    创建Scheduler

    通过SchedulerFactory获取Scheduler调度器,并且将一个任务和一个触发器绑定起来

    SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    try { 
     /** 
       * Scheduler是一个调度器 
       * 一个Scheduler注册JobDetail和Trigger。一旦注册后,Scheduler 负责执行Job, 前提是Trigger的预定时间到达。
       */
       Scheduler scheduler = schedulerFactory.getScheduler();//调用getScheduler()方法来获取一个Scheduler实例
       //使用scheduleJob(JobDetail jobDetail, Trigger trigger) 方法使 任务 & 触发器 发生关联
        scheduler.scheduleJob(job, trigger2); 
       //使用start()方法开启调度 scheduler.start();
       //关闭调度//scheduler.shutdown();
    } catch (SchedulerException e) 
    {
       e.printStackTrace();
    }
    

    至此,一个定时任务就配置完成了。

    Quartz调度原理

    参考Quartz原理解密

    调度线程

    Quartz中Scheduler调度线程主要有两类线程:

    • Regular Scheduler Thread(执行常规调度):Regular Thread轮询所有Trigger,如果发现有将要触发的Trigger,就从任务线程池中获取一个空闲线程,然后执行与改Trigger关联的Job。
    • Misfire Scheduler Thread(执行错失的任务):Misfire Thraed轮询所有Trigger,查找有错失的任务,例如系统重启/线程占用等问题导致的任务错失,根据一定的策略进行处理。
    image-20211231171606262

    存储

    Quartz有两种方式将定时任务存储下来:

    • RAMJobStore:将trigger和job存储到内存里
    • JobStoreSupport:将trigger和job存储到数据库里

    为了防止任务数据丢失,Quartz会将trigger和job存储到数据库里,

    Quartz集群

    参考分布式任务调度方案调研

    定时任务的分布式调度

    集群环境下防止并发的一种实现( Spring Quartz 集群思路)

    分布式调度策略

    除了单机版本外,Quartz也提供了集群方案,它的集群方案是基于数据库实现的。

    img

    上图三个节点,每个节点里有许多Scheduler实例(调度器线程),每个Scheduler实例都会去争抢访问数据库中的Trigger,如何保证同一时刻每个Trigger只会被一个Scheduler实例获取并检查?答案是数据库锁(可以理解为用数据库实现了分布式锁)。Quartz集群采用了以数据库作为协调中心的方式,通过表的设计协调不同节点之间的行为:

    • QRTZ_SCHEDULER_STATE表:记录Scheduler实例的状态信息
    • QRTZ_LOCKS表:记录程序悲观锁的信息

    关注QRTZ_LOCKS表,表里只有一个字段

    CREATE TABLE QRTZ_LOCKS (
    	LOCK_NAME VARCHAR2(40) NOT NULL, 
    	PRIMARY KEY (LOCK_NAME)
    )
    

    这些数据是根据数据库的业务逻辑操作抽象出的系统所拥有的表的类型,QRTZ_LOCKS主要有两个行级锁

    lock_namedesc
    STATE_ACCESS状态访问锁
    TRIGGER_ACCESS触发器访问锁

    下面都以TRIGGER_ACCESS锁为例子讲解,Scheduler实例流程图:

    Quartz集群基于锁的同步方案

    比如一个Scheduler实例想要访问数据库来看是否有Trigger将要触发,那么它就开一个事务,并且首先获取并占用TRIGGER_ACCESS锁,然后再处理业务,比如说如果检查到有Trigger将要触发,就会去分配线程运行对应的任务。在此期间其他实例都无法访问所有与Trigger业务有关的数据表,处理完业务后commit work,结束事务,TRIGGER_ACCESS锁就被释放出来了,

    抽象出来的mysql语句(方便理解):

    mysql> begin work;
    mysql> select * from QRTZ_LOCKS where t.lock_name='TRIGGER_ACCESS' for update
    #在这里处理业务
    mysql> commit work;
    

    如果一个Scheduler实例获取了一个TRIGGER_ACCESS锁但是还没处理完就挂掉了,会导致与Trigger业务有关的表一直处于加锁状态无法被其他Scheduler实例访问,结果所有实例都没法工作了,因此Quartz又提出了一个接管锁的机制:

    • 每个Scheduler实例都在QRTZ_SCHEDULER_STATE表里有自己的唯一ID,例如以hostname+time标识;
    • 每个Scheduler实例的ClusterManager线程定期往QRTZ_SCHEDULER_STATE表更新LAST_CHECKIN_TIME作为心跳
    • 当某个Scheduler实例超过一定时间没有心跳更新时,其它Scheduler实例得到这个信息,会接管对应的行锁,并恢复过时的任务

    总结

    总的来说,Quartz的分布式调度策略是以数据库为边界资源的一种异步策略。各个调度器都遵守一个基于数据库锁的操作规则从而保证了操作的唯一性,同时多个节点的异步运行保证了服务的可靠。

    但这种Quartz的分布式调度策略有很多局限:

    • 集群特性对于高CPU使用率的任务效果很好,但是对于大量的短任务,各个节点都会抢占数据库锁,这样就出现大量的线程等待资源。这种情况随着节点的增加会越来越严重。
    • 没有实现比较好的负载均衡机制,仅依靠各个节点中的Scheduler实例随机抢占,可能会导致部分节点负载重,部分节点负载轻的情况。
    • 不能满足更复杂的功能,如任务分片、编排、暂停重启、失败重试等。
    展开全文
  • Quartz 是个开源的作业调度框架,为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听...
  • 用NSGA2解决车间任务调度,在MATLAB环境下实现,并且画出任务序列的甘特图
  • 分布式任务调度平台XXL-JOB

    千次阅读 2020-12-09 02:58:05
    以前带我的人说过,最好的学习就是看官方文档,个人也有4个T的学习视频,...一、简介1.1 概述XXL-JOB是一个分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公...

    以前带我的人说过,最好的学习就是看官方文档,个人也有4个T的学习视频,但是会发现讲的都是入门,有的也比较浅。

    官方文档比较官方,也比较权威,打开xxl-job的官网,写的贼详细,有些人喜欢收博客,不喜欢看官网,因此就直接复制过来了,

    过段时间会参考文档,自己来一遍。

    一、简介

    1.1 概述

    XXL-JOB是一个分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线,开箱即用。

    1.2 社区交流

    1.3 特性

    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、跨平台:原生提供通用HTTP任务Handler(Bean任务,”HttpJobHandler”);业务方只需要提供HTTP链接即可,不限制语言、平台;

    31、国际化:调度中心支持国际化设置,提供中文、英文两种可选语言,默认为中文;

    32、容器化:提供官方docker镜像,并实时更新推送dockerhub,进一步实现产品开箱即用;

    33、线程池隔离:调度线程池进行隔离拆分,慢任务自动降级进入”Slow”线程池,避免耗尽调度线程,提高系统稳定性;

    34、用户管理:支持在线管理系统用户,存在管理员、普通用户两种角色;

    35、权限控制:执行器维度进行权限控制,管理员拥有全量权限,普通用户需要分配执行器权限后才允许相关操作;

    1.4 下载

    文档地址

    源码仓库地址

    中央仓库地址

    com.xuxueli

    xxl-job-core

    ${最新稳定版本}

    1.6 环境

    Maven3+

    Jdk1.7+

    Mysql5.7+

    二、快速入门

    2.1 初始化“调度数据库”

    请下载项目源码并解压,获取 “调度数据库初始化SQL脚本” 并执行即可。

    “调度数据库初始化SQL脚本” 位置为:

    /xxl-job/doc/db/tables_xxl_job.sql

    调度中心支持集群部署,集群情况下各节点务必连接同一个mysql实例;

    如果mysql做主从,调度中心集群节点务必强制走主库;

    2.2 编译源码

    解压源码,按照maven格式将源码导入IDE, 使用maven进行编译即可,源码结构如下:

    xxl-job-admin:调度中心

    xxl-job-core:公共依赖

    xxl-job-executor-samples:执行器Sample示例(选择合适的版本执行器,可直接使用,也可以参考其并将现有项目改造成执行器)

    :xxl-job-executor-sample-springboot:Springboot版本,通过Springboot管理执行器,推荐这种方式;

    :xxl-job-executor-sample-spring:Spring版本,通过Spring容器管理执行器,比较通用;

    :xxl-job-executor-sample-frameless:无框架版本;

    :xxl-job-executor-sample-jfinal:JFinal版本,通过JFinal管理执行器;

    :xxl-job-executor-sample-nutz:Nutz版本,通过Nutz管理执行器;

    :xxl-job-executor-sample-jboot:jboot版本,通过jboot管理执行器;

    2.3 配置部署“调度中心”

    调度中心项目:xxl-job-admin

    作用:统一管理任务调度平台上调度任务,负责触发调度执行,并且提供任务管理平台。

    步骤一:调度中心配置:

    调度中心配置文件地址:

    /xxl-job/xxl-job-admin/src/main/resources/application.properties

    调度中心配置内容说明:

    ### 调度中心JDBC链接:链接地址请保持和 2.1章节 所创建的调度数据库的地址一致

    spring.datasource.url=jdbc:mysql://127.0.0.1:3306/xxl_job?Unicode=true&characterEncoding=UTF-8

    spring.datasource.username=root

    spring.datasource.password=root_pwd

    spring.datasource.driver-class-name=com.mysql.jdbc.Driver

    ### 报警邮箱

    spring.mail.host=smtp.qq.com

    spring.mail.port=25

    spring.mail.username=xxx@qq.com

    spring.mail.password=xxx

    spring.mail.properties.mail.smtp.auth=true

    spring.mail.properties.mail.smtp.starttls.enable=true

    spring.mail.properties.mail.smtp.starttls.required=true

    spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory

    ### 调度中心通讯TOKEN [选填]:非空时启用;

    xxl.job.accessToken=

    ### 调度中心国际化配置 [选填]: 默认为空,表示中文; "en" 表示英文;

    xxl.job.i18n=

    ## 调度线程池最大线程配置【必填】

    xxl.job.triggerpool.fast.max=200

    xxl.job.triggerpool.slow.max=100

    ### 调度中心日志表数据保存天数 [必填]:过期日志自动清理;限制大于等于7时生效,否则, 如-1,关闭自动清理功能;

    xxl.job.logretentiondays=30

    步骤二:部署项目:

    如果已经正确进行上述配置,可将项目编译打包部署。

    默认登录账号 “admin/123456”, 登录后运行界面如下图所示。

    至此“调度中心”项目已经部署成功。

    步骤三:调度中心集群(可选):

    调度中心支持集群部署,提升调度系统容灾和可用性。

    调度中心集群部署时,几点要求和建议:

    DB配置保持一致;

    集群机器时钟保持一致(单机集群忽视);

    建议:推荐通过nginx为调度中心集群做负载均衡,分配域名。调度中心访问、执行器回调配置、调用API服务等操作均通过该域名进行。

    其他:Docker 镜像方式搭建调度中心:

    下载镜像

    // Docker地址:https://hub.docker.com/r/xuxueli/xxl-job-admin/ (建议指定版本号)

    docker pull xuxueli/xxl-job-admin

    创建容器并运行

    docker run -p 8080:8080-v /tmp:/data/applogs --name xxl-job-admin -d xuxueli/xxl-job-admin

    /**

    * 如需自定义 mysql 等配置,可通过 "PARAMS" 指定,参数格式 RAMS="--key=value --key2=value2" ;

    * 配置项参考文件:/xxl-job/xxl-job-admin/src/main/resources/application.properties

    */

    docker run -e PARAMS="--spring.datasource.url=jdbc:mysql://127.0.0.1:3306/xxl_job?Unicode=true&characterEncoding=UTF-8"-p 8080:8080-v /tmp:/data/applogs --name xxl-job-admin -d xuxueli/xxl-job-admin

    2.4 配置部署“执行器项目”

    “执行器”项目:xxl-job-executor-sample-springboot (提供多种版本执行器供选择,现以springboot 版本为例,可直接使用,也可以参考其并将现有项目改造成执行器)

    作用:负责接收“调度中心”的调度并执行;可直接部署执行器,也可以将执行器集成到现有业务项目中。

    步骤一:maven依赖

    确认pom文件中引入了 “xxl-job-core” 的maven依赖;

    步骤二:执行器配置

    执行器配置,配置文件地址:

    /xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/resources/application.properties

    执行器配置,配置内容说明:

    ### 调度中心部署跟地址 [选填]:如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调";为空则关闭自动注册;

    xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin

    ### 执行器AppName [选填]:执行器心跳注册分组依据;为空则关闭自动注册

    xxl.job.executor.appname=xxl-job-executor-sample

    ### 执行器IP [选填]:默认为空表示自动获取IP,多网卡时可手动设置指定IP,该IP不会绑定Host仅作为通讯实用;地址信息用于 "执行器注册" 和 "调度中心请求并触发任务";

    xxl.job.executor.ip=

    ### 执行器端口号 [选填]:小于等于0则自动获取;默认端口为9999,单机部署多个执行器时,注意要配置不同执行器端口;

    xxl.job.executor.port=9999

    ### 执行器通讯TOKEN [选填]:非空时启用;

    xxl.job.accessToken=

    ### 执行器运行日志文件存储磁盘路径 [选填] :需要对该路径拥有读写权限;为空则使用默认路径;

    xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler

    ### 执行器日志文件保存天数 [选填] : 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能;

    xxl.job.executor.logretentiondays=30

    步骤三:执行器组件配置

    执行器组件,配置文件地址:

    /xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/java/com/xxl/job/executor/core/config/XxlJobConfig.java

    执行器组件,配置内容说明:

    @Bean

    publicXxlJobSpringExecutorxxlJobExecutor(){

    logger.info(">>>>>>>>>>> xxl-job config init.");

    XxlJobSpringExecutorxxlJobSpringExecutor =newXxlJobSpringExecutor();

    xxlJobSpringExecutor.setAdminAddresses(adminAddresses);

    xxlJobSpringExecutor.setAppName(appName);

    xxlJobSpringExecutor.setIp(ip);

    xxlJobSpringExecutor.setPort(port);

    xxlJobSpringExecutor.setAccessToken(accessToken);

    xxlJobSpringExecutor.setLogPath(logPath);

    xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

    returnxxlJobSpringExecutor;

    }

    步骤四:部署执行器项目:

    如果已经正确进行上述配置,可将执行器项目编译打部署,系统提供多种执行器Sample示例项目,选择其中一个即可,各自的部署方式如下。

    xxl-job-executor-sample-springboot:项目编译打包成springboot类型的可执行JAR包,命令启动即可;

    xxl-job-executor-sample-spring:项目编译打包成WAR包,并部署到tomcat中。

    xxl-job-executor-sample-jfinal:同上

    xxl-job-executor-sample-nutz:同上

    xxl-job-executor-sample-jboot:同上

    至此“执行器”项目已经部署结束。

    步骤五:执行器集群(可选):

    执行器支持集群部署,提升调度系统可用性,同时提升任务处理能力。

    执行器集群部署时,几点要求和建议:

    执行器回调地址(xxl.job.admin.addresses)需要保持一致;执行器根据该配置进行执行器自动注册等操作。

    同一个执行器集群内AppName(xxl.job.executor.appname)需要保持一致;调度中心根据该配置动态发现不同集群的在线执行器列表。

    2.5 开发第一个任务“Hello World”

    本示例以新建一个 “GLUE模式(Java)” 运行模式的任务为例。更多有关任务的详细配置,请查看“章节三:任务详解”。

    ( “GLUE模式(Java)”的执行代码托管到调度中心在线维护,相比“Bean模式任务”需要在执行器项目开发部署上线,更加简便轻量)

    前提:请确认“调度中心”和“执行器”项目已经成功部署并启动;

    步骤一:新建任务:

    登录调度中心,点击下图所示“新建任务”按钮,新建示例任务。然后,参考下面截图中任务的参数配置,点击保存。

    步骤二:“GLUE模式(Java)” 任务开发:

    请点击任务右侧 “GLUE” 按钮,进入 “GLUE编辑器开发界面” ,见下图。“GLUE模式(Java)” 运行模式的任务默认已经初始化了示例任务代码,即打印Hello World。

    ( “GLUE模式(Java)” 运行模式的任务实际上是一段继承自IJobHandler的Java类代码,它在执行器项目中运行,可使用@Resource/@Autowire注入执行器里中的其他服务,详细介绍请查看第三章节)

    步骤三:触发执行:

    请点击任务右侧 “执行” 按钮,可手动触发一次任务执行(通常情况下,通过配置Cron表达式进行任务调度出发)。

    步骤四:查看日志:

    请点击任务右侧 “日志” 按钮,可前往任务日志界面查看任务日志。

    在任务日志界面中,可查看该任务的历史调度记录以及每一次调度的任务调度信息、执行参数和执行信息。运行中的任务点击右侧的“执行日志”按钮,可进入日志控制台查看实时执行日志。

    在日志控制台,可以Rolling方式实时查看任务在执行器一侧运行输出的日志信息,实时监控任务进度;

    三、任务详解

    配置属性详细说明:

    -执行器:任务的绑定的执行器,任务触发调度时将会自动发现注册成功的执行器,实现任务自动发现功能;另一方面也可以方便的进行任务分组。每个任务必须绑定一个执行器,可在"执行器管理"进行设置;

    -任务描述:任务的描述信息,便于任务管理;

    -路由策略:当执行器集群部署时,提供丰富的路由策略,包括;

    FIRST(第一个):固定选择第一个机器;

    LAST(最后一个):固定选择最后一个机器;

    ROUND(轮询):;

    RANDOM(随机):随机选择在线的机器;

    CONSISTENT_HASH(一致性HASH):每个任务按照Hash算法固定选择某一台机器,且所有任务均匀散列在不同机器上。

    LEAST_FREQUENTLY_USED(最不经常使用):使用频率最低的机器优先被选举;

    LEAST_RECENTLY_USED(最近最久未使用):最久为使用的机器优先被选举;

    FAILOVER(故障转移):按照顺序依次进行心跳检测,第一个心跳检测成功的机器选定为目标执行器并发起调度;

    BUSYOVER(忙碌转移):按照顺序依次进行空闲检测,第一个空闲检测成功的机器选定为目标执行器并发起调度;

    SHARDING_BROADCAST(分片广播):广播触发对应集群中所有机器执行一次任务,同时系统自动传递分片参数;可根据分片参数开发分片任务;

    -Cron:触发任务执行的Cron表达式;

    -运行模式:

    BEAN模式:任务以JobHandler方式维护在执行器端;需要结合"JobHandler"属性匹配执行器中任务;

    GLUE模式(Java):任务以源码方式维护在调度中心;该模式的任务实际上是一段继承自IJobHandler的Java类代码并"groovy"源码方式维护,它在执行器项目中运行,可使用@Resource/@Autowire注入执行器里中的其他服务;

    GLUE模式(Shell):任务以源码方式维护在调度中心;该模式的任务实际上是一段"shell"脚本;

    GLUE模式(Python):任务以源码方式维护在调度中心;该模式的任务实际上是一段"python"脚本;

    GLUE模式(PHP):任务以源码方式维护在调度中心;该模式的任务实际上是一段"php"脚本;

    GLUE模式(NodeJS):任务以源码方式维护在调度中心;该模式的任务实际上是一段"nodejs"脚本;

    GLUE模式(PowerShell):任务以源码方式维护在调度中心;该模式的任务实际上是一段"PowerShell"脚本;

    -JobHandler:运行模式为"BEAN模式"时生效,对应执行器中新开发的JobHandler类“@JobHandler”注解自定义的value值;

    -阻塞处理策略:调度过于密集执行器来不及处理时的处理策略;

    单机串行(默认):调度请求进入单机执行器后,调度请求进入FIFO队列并以串行方式运行;

    丢弃后续调度:调度请求进入单机执行器后,发现执行器存在运行的调度任务,本次请求将会被丢弃并标记为失败;

    覆盖之前调度:调度请求进入单机执行器后,发现执行器存在运行的调度任务,将会终止运行中的调度任务并清空队列,然后运行本地调度任务;

    -子任务:每个任务都拥有一个唯一的任务ID(任务ID可以从任务列表获取),当本任务执行结束并且执行成功时,将会触发子任务ID所对应的任务的一次主动调度。

    -任务超时时间:支持自定义任务超时时间,任务运行超时将会主动中断任务;

    -失败重试次数;支持自定义任务失败重试次数,当任务失败时将会按照预设的失败重试次数主动进行重试;

    -报警邮件:任务调度失败时邮件通知的邮箱地址,支持配置多邮箱地址,配置多个邮箱地址时用逗号分隔;

    -负责人:任务的负责人;

    -执行参数:任务执行所需的参数;

    3.1 BEAN模式(类形式)

    Bean模式任务,支持基于类的开发方式,每个任务对应一个Java类。

    优点:不限制项目环境,兼容性好。即使是无框架项目,如main方法直接启动的项目也可以提供支持,可以参考示例项目 “xxl-job-executor-sample-frameless”;

    缺点:

    每个任务需要占用一个Java类,造成类的浪费;

    不支持自动扫描任务并注入到执行器容器,需要手动注入。

    步骤一:执行器项目中,开发Job类:

    1、开发一个继承自"com.xxl.job.core.handler.IJobHandler"的JobHandler类,实现其中任务方法。

    2、手动通过如下方式注入到执行器容器。

    ```

    XxlJobExecutor.registJobHandler("demoJobHandler", new DemoJobHandler());

    ```

    步骤二:调度中心,新建调度任务

    后续步骤和 “3.2 BEAN模式(方法形式)”一致,可以前往参考。

    3.2 BEAN模式(方法形式)

    Bean模式任务,支持基于方法的开发方式,每个任务对应一个方法。

    优点:缺点:要求Spring容器环境;

    每个任务只需要开发一个方法,并添加”@XxlJob”注解即可,更加方便、快速。

    支持自动扫描任务并注入到执行器容器。

    基于方法开发的任务,底层会生成JobHandler代理,和基于类的方式一样,任务也会以JobHandler的形式存在于执行器任务容器中。

    步骤一:执行器项目中,开发Job方法:

    1、在SpringBean实例中,开发Job方法,方式格式要求为"public ReturnT execute(String param)"

    2、为Job方法添加注解"@XxlJob(value="自定义jobhandler名称", init = "JobHandler初始化方法", destroy = "JobHandler销毁方法")",注解value值对应的是调度中心新建任务的JobHandler属性的值。

    3、执行日志:需要通过"XxlJobLogger.log"打印执行日志;// 可参考Sample示例执行器中的 "com.xxl.job.executor.service.jobhandler.SampleXxlJob" ,如下:

    @XxlJob("demoJobHandler")

    publicReturnTexecute(Stringparam){

    XxlJobLogger.log("hello world.");

    returnReturnT.SUCCESS;

    }

    步骤二:调度中心,新建调度任务

    参考上文“配置属性详细说明”对新建的任务进行参数配置,运行模式选中 “BEAN模式”,JobHandler属性填写任务注解“@XxlJob”中定义的值;

    原生内置Bean模式任务

    为方便用户参考与快速实用,示例执行器内原生提供多个Bean模式任务Handler,可以直接配置实用,如下:

    demoJobHandler:简单示例任务,任务内部模拟耗时任务逻辑,用户可在线体验Rolling Log等功能;

    shardingJobHandler:分片示例任务,任务内部模拟处理分片参数,可参考熟悉分片任务;

    httpJobHandler:通用HTTP任务Handler;业务方只需要提供HTTP链接即可,不限制语言、平台;

    commandJobHandler:通用命令行任务Handler;业务方只需要提供命令行即可;如 “pwd”命令;

    3.3 GLUE模式(Java)

    任务以源码方式维护在调度中心,支持通过Web IDE在线更新,实时编译和生效,因此不需要指定JobHandler。开发流程如下:

    步骤一:调度中心,新建调度任务:

    参考上文“配置属性详细说明”对新建的任务进行参数配置,运行模式选中 “GLUE模式(Java)”;

    步骤二:开发任务代码:

    选中指定任务,点击该任务右侧“GLUE”按钮,将会前往GLUE任务的Web IDE界面,在该界面支持对任务代码进行开发(也可以在IDE中开发完成后,复制粘贴到编辑中)。

    版本回溯功能(支持30个版本的版本回溯):在GLUE任务的Web IDE界面,选择右上角下拉框“版本回溯”,会列出该GLUE的更新历史,选择相应版本即可显示该版本代码,保存后GLUE代码即回退到对应的历史版本;

    3.4 GLUE模式(Shell)

    步骤一:调度中心,新建调度任务

    参考上文“配置属性详细说明”对新建的任务进行参数配置,运行模式选中 “GLUE模式(Shell)”;

    步骤二:开发任务代码:

    选中指定任务,点击该任务右侧“GLUE”按钮,将会前往GLUE任务的Web IDE界面,在该界面支持对任务代码进行开发(也可以在IDE中开发完成后,复制粘贴到编辑中)。

    该模式的任务实际上是一段 “shell” 脚本;

    3.4 GLUE模式(Python)

    步骤一:调度中心,新建调度任务

    参考上文“配置属性详细说明”对新建的任务进行参数配置,运行模式选中 “GLUE模式(Python)”;

    步骤二:开发任务代码:

    选中指定任务,点击该任务右侧“GLUE”按钮,将会前往GLUE任务的Web IDE界面,在该界面支持对任务代码进行开发(也可以在IDE中开发完成后,复制粘贴到编辑中)。

    该模式的任务实际上是一段 “python” 脚本;

    3.5 GLUE模式(NodeJS)

    步骤一:调度中心,新建调度任务

    参考上文“配置属性详细说明”对新建的任务进行参数配置,运行模式选中 “GLUE模式(NodeJS)”;

    步骤二:开发任务代码:

    选中指定任务,点击该任务右侧“GLUE”按钮,将会前往GLUE任务的Web IDE界面,在该界面支持对任务代码进行开发(也可以在IDE中开发完成后,复制粘贴到编辑中)。

    该模式的任务实际上是一段 “nodeJS” 脚本;

    3.6 GLUE模式(PHP)

    同上

    3.7 GLUE模式(PowerShell)

    同上

    四、操作指南

    4.1 配置执行器

    点击进入”执行器管理”界面, 如下图:

    1、"调度中心OnLine:"右侧显示在线的"调度中心"列表,任务执行结束后,将会以failover的模式进行回调调度中心通知执行结果,避免回调的单点风险;

    2、"执行器列表"中显示在线的执行器列表,可通过"OnLine 机器"查看对应执行器的集群机器。

    点击按钮 “+新增执行器” 弹框如下图, 可新增执行器配置:

    执行器属性说明

    AppName:是每个执行器集群的唯一标示AppName,执行器会周期性以AppName为对象进行自动注册。可通过该配置自动发现注册成功的执行器,供任务调度时使用;

    名称:执行器的名称,因为AppName限制字母数字等组成,可读性不强,名称为了提高执行器的可读性;

    排序:执行器的排序,系统中需要执行器的地方,如任务新增,将会按照该排序读取可用的执行器列表;

    注册方式:调度中心获取执行器地址的方式;

    自动注册:执行器自动进行执行器注册,调度中心通过底层注册表可以动态发现执行器机器地址;

    手动录入:人工手动录入执行器的地址信息,多地址逗号分隔,供调度中心使用;

    机器地址:"注册方式"为"手动录入"时有效,支持人工维护执行器的地址信息;

    4.2 新建任务

    进入任务管理界面,点击“新增任务”按钮,在弹出的“新增任务”界面配置任务属性后保存即可。详情页参考章节 “三、任务详解”。

    4.3 编辑任务

    进入任务管理界面,选中指定任务。点击该任务右侧“编辑”按钮,在弹出的“编辑任务”界面更新任务属性后保存即可,可以修改设置的任务属性信息:

    4.4 编辑GLUE代码

    该操作仅针对GLUE任务。

    选中指定任务,点击该任务右侧“GLUE”按钮,将会前往GLUE任务的Web IDE界面,在该界面支持对任务代码进行开发。可参考章节 “3.3 GLUE模式(Java)”。

    4.5 启动/停止任务

    可对任务进行“启动”和“停止”操作。

    需要注意的是,此处的启动/停止仅针对任务的后续调度触发行为,不会影响到已经触发的调度任务,如需终止已经触发的调度任务,可查看“4.9 终止运行中的任务”

    4.6 手动触发一次调度

    点击“执行”按钮,可手动触发一次任务调度,不影响原有调度规则。

    4.7 查看调度日志

    点击“日志”按钮,可以查看任务历史调度日志。在历史调入日志界面可查看每次任务调度的调度结果、执行结果等,点击“执行日志”按钮可查看执行器完整日志。

    调度时间:"调度中心"触发本次调度并向"执行器"发送任务执行信号的时间;

    调度结果:"调度中心"触发本次调度的结果,200表示成功,500或其他表示失败;

    调度备注:"调度中心"触发本次调度的日志信息;

    执行器地址:本次任务执行的机器地址

    运行模式:触发调度时任务的运行模式,运行模式可参考章节"三、任务详解";

    任务参数:本地任务执行的入参

    执行时间:"执行器"中本次任务执行结束后回调的时间;

    执行结果:"执行器"中本次任务执行的结果,200表示成功,500或其他表示失败;

    执行备注:"执行器"中本次任务执行的日志信息;

    操作:

    "执行日志"按钮:点击可查看本地任务执行的详细日志信息;详见“4.8查看执行日志”;

    "终止任务"按钮:点击可终止本地调度对应执行器上本任务的执行线程,包括未执行的阻塞任务一并被终止;

    4.8 查看执行日志

    点击执行日志右侧的 “执行日志” 按钮,可跳转至执行日志界面,可以查看业务代码中打印的完整日志,如下图;

    4.9 终止运行中的任务

    仅针对执行中的任务。

    在任务日志界面,点击右侧的“终止任务”按钮,将会向本次任务对应的执行器发送任务终止请求,将会终止掉本次任务,同时会清空掉整个任务执行队列。

    任务终止时通过 “interrupt” 执行线程的方式实现, 将会触发 “InterruptedException” 异常。因此如果JobHandler内部catch到了该异常并消化掉的话, 任务终止功能将不可用。

    因此, 如果遇到上述任务终止不可用的情况, 需要在JobHandler中应该针对 “InterruptedException” 异常进行特殊处理 (向上抛出) , 正确逻辑如下:

    try{

    // do something

    }catch(Exceptione){

    if(e instanceofInterruptedException){

    throwe;

    }

    logger.warn("{}",e);

    }

    而且,在JobHandler中开启子线程时,子线程也不可catch处理”InterruptedException”,应该主动向上抛出。

    任务终止时会执行对应JobHandler的”destroy()”方法,可以借助该方法处理一些资源回收的逻辑。

    4.10 删除执行日志

    在任务日志界面,选中执行器和任务之后,点击右侧的”删除”按钮将会出现”日志清理”弹框,弹框中支持选择不同类型的日志清理策略,选中后点击”确定”按钮即可进行日志清理操作;

    4.11 删除任务

    点击删除按钮,可以删除对应任务。

    4.12 用户管理

    进入 “用户管理” 界面,可查看和管理用户信息;

    目前用户分为两种角色:

    管理员:拥有全量权限,支持在线管理用户信息,为用户分配权限,权限分配粒度为执行器;

    普通用户:仅拥有被分配权限的执行器,及相关任务的操作权限;

    五、总体设计

    5.1 源码目录介绍

    -/doc :文档资料

    -/db :“调度数据库”建表脚本

    -/xxl-job-admin :调度中心,项目源码

    -/xxl-job-core :公共Jar依赖

    -/xxl-job-executor-samples :执行器,Sample示例项目(大家可以在该项目上进行开发,也可以将现有项目改造生成执行器项目)

    5.2 “调度数据库”配置

    XXL-JOB调度模块基于自研调度组件并支持集群部署,调度数据库表说明如下:

    -xxl_job_lock:任务调度锁表;

    -xxl_job_group:执行器信息表,维护任务执行器信息;

    -xxl_job_info:调度扩展信息表:用于保存XXL-JOB调度任务的扩展信息,如任务分组、任务名、机器地址、执行器、执行入参和报警邮件等等;

    -xxl_job_log:调度日志表:用于保存XXL-JOB任务调度的历史信息,如调度结果、执行结果、调度入参、调度机器和执行器等等;

    -xxl_job_log_report:调度日志报表:用户存储XXL-JOB任务调度日志的报表,调度中心报表功能页面会用到;

    -xxl_job_logglue:任务GLUE日志:用于保存GLUE更新历史,用于支持GLUE的版本回溯功能;

    -xxl_job_registry:执行器注册表,维护在线的执行器和调度中心机器地址信息;

    -xxl_job_user:系统用户表;

    5.3 架构设计

    5.3.1 设计思想

    将调度行为抽象形成“调度中心”公共平台,而平台自身并不承担业务逻辑,“调度中心”负责发起调度请求。

    将任务抽象成分散的JobHandler,交由“执行器”统一管理,“执行器”负责接收调度请求并执行对应的JobHandler中业务逻辑。

    因此,“调度”和“任务”两部分可以相互解耦,提高系统整体稳定性和扩展性;

    5.3.2 系统组成

    调度模块(调度中心):

    负责管理调度信息,按照调度配置发出调度请求,自身不承担业务代码。调度系统与任务解耦,提高了系统可用性和稳定性,同时调度系统性能不再受限于任务模块;

    支持可视化、简单且动态的管理调度信息,包括任务新建,更新,删除,GLUE开发和任务报警等,所有上述操作都会实时生效,同时支持监控调度结果以及执行日志,支持执行器Failover。

    执行模块(执行器):

    负责接收调度请求并执行任务逻辑。任务模块专注于任务的执行等操作,开发和维护更加简单和高效;

    接收“调度中心”的执行请求、终止请求和日志请求等。

    5.3.3 架构图

    5.4 调度模块剖析

    5.4.1 quartz的不足

    Quartz作为开源作业调度中的佼佼者,是作业调度的首选。但是集群环境中Quartz采用API的方式对任务进行管理,从而可以避免上述问题,但是同样存在以下问题:

    问题一:调用API的的方式操作任务,不人性化;

    问题二:需要持久化业务QuartzJobBean到底层数据表中,系统侵入性相当严重。

    问题三:调度逻辑和QuartzJobBean耦合在同一个项目中,这将导致一个问题,在调度任务数量逐渐增多,同时调度任务逻辑逐渐加重的情况下,此时调度系统的性能将大大受限于业务;

    问题四:quartz底层以“抢占式”获取DB锁并由抢占成功节点负责运行任务,会导致节点负载悬殊非常大;而XXL-JOB通过执行器实现“协同分配式”运行任务,充分发挥集群优势,负载各节点均衡。

    XXL-JOB弥补了quartz的上述不足之处。

    5.4.2 自研调度模块

    XXL-JOB最终选择自研调度组件(早期调度组件基于Quartz);一方面是为了精简系统降低冗余依赖,另一方面是为了提供系统的可控度与稳定性;

    XXL-JOB中“调度模块”和“任务模块”完全解耦,调度模块进行任务调度时,将会解析不同的任务参数发起远程调用,调用各自的远程执行器服务。这种调用模型类似RPC调用,调度中心提供调用代理的功能,而执行器提供远程服务的功能。

    5.4.3 调度中心HA(集群)

    基于数据库的集群方案,数据库选用Mysql;集群分布式并发环境中进行定时任务调度时,会在各个节点会上报任务,存到数据库中,执行时会从数据库中取出触发器来执行,如果触发器的名称和执行时间相同,则只有一个节点去执行此任务。

    5.4.4 调度线程池

    调度采用线程池方式实现,避免单线程因阻塞而引起任务调度延迟。

    5.4.5 并行调度

    XXL-JOB调度模块默认采用并行机制,在多线程调度的情况下,调度模块被阻塞的几率很低,大大提高了调度系统的承载量。

    XXL-JOB的每个调度任务虽然在调度模块是并行调度执行的,但是任务调度传递到任务模块的“执行器”确实串行执行的,同时支持任务终止。

    5.4.6 过期处理策略

    任务调度错过触发时间时的处理策略:

    可能原因:服务重启;调度线程被阻塞,线程被耗尽;上次调度持续阻塞,下次调度被错过;

    处理策略:

    过期超5s:本次忽略,当前时间开始计算下次触发时间

    过期5s内:立即触发一次,当前时间开始计算下次触发时间

    5.4.7 日志回调服务

    调度模块的“调度中心”作为Web服务部署时,一方面承担调度中心功能,另一方面也为执行器提供API服务。

    调度中心提供的”日志回调服务API服务”代码位置如下:

    xxl-job-admin#com.xxl.job.admin.controller.JobApiController.callback

    “执行器”在接收到任务执行请求后,执行任务,在执行结束之后会将执行结果回调通知“调度中心”:

    5.4.8 任务HA(Failover)

    执行器如若集群部署,调度中心将会感知到在线的所有执行器,如“127.0.0.1:9997, 127.0.0.1:9998, 127.0.0.1:9999”。

    当任务”路由策略”选择”故障转移(FAILOVER)”时,当调度中心每次发起调度请求时,会按照顺序对执行器发出心跳检测请求,第一个检测为存活状态的执行器将会被选定并发送调度请求。

    调度成功后,可在日志监控界面查看“调度备注”,如下;

    “调度备注”可以看出本地调度运行轨迹,执行器的”注册方式”、”地址列表”和任务的”路由策略”。”故障转移(FAILOVER)”路由策略下,调度中心首先对第一个地址进行心跳检测,心跳失败因此自动跳过,第二个依然心跳检测失败……

    直至心跳检测第三个地址“127.0.0.1:9999”成功,选定为“目标执行器”;然后对“目标执行器”发送调度请求,调度流程结束,等待执行器回调执行结果。

    5.4.9 调度日志

    调度中心每次进行任务调度,都会记录一条任务日志,任务日志主要包括以下三部分内容:

    任务信息:包括“执行器地址”、“JobHandler”和“执行参数”等属性,点击任务ID按钮可查看,根据这些参数,可以精确的定位任务执行的具体机器和任务代码;

    调度信息:包括“调度时间”、“调度结果”和“调度日志”等,根据这些参数,可以了解“调度中心”发起调度请求时具体情况。

    执行信息:包括“执行时间”、“执行结果”和“执行日志”等,根据这些参数,可以了解在“执行器”端任务执行的具体情况;

    调度日志,针对单次调度,属性说明如下:

    执行器地址:任务执行的机器地址;

    JobHandler:Bean模式表示任务执行的JobHandler名称;

    任务参数:任务执行的入参;

    调度时间:调度中心,发起调度的时间;

    调度结果:调度中心,发起调度的结果,SUCCESS或FAIL;

    调度备注:调度中心,发起调度的备注信息,如地址心跳检测日志等;

    执行时间:执行器,任务执行结束后回调的时间;

    执行结果:执行器,任务执行的结果,SUCCESS或FAIL;

    执行备注:执行器,任务执行的备注信息,如异常日志等;

    执行日志:任务执行过程中,业务代码中打印的完整执行日志,见“4.8 查看执行日志”;

    5.4.10 任务依赖

    原理:XXL-JOB中每个任务都对应有一个任务ID,同时,每个任务支持设置属性“子任务ID”,因此,通过“任务ID”可以匹配任务依赖关系。

    当父任务执行结束并且执行成功时,将会根据“子任务ID”匹配子任务依赖,如果匹配到子任务,将会主动触发一次子任务的执行。

    在任务日志界面,点击任务的“执行备注”的“查看”按钮,可以看到匹配子任务以及触发子任务执行的日志信息,如无信息则表示未触发子任务执行,可参考下图。

    5.4.11 全异步化 & 轻量级

    全异步化设计:XXL-JOB系统中业务逻辑在远程执行器执行,触发流程全异步化设计。相比直接在调度中心内部执行业务逻辑,极大的降低了调度线程占用时间;轻量级设计:XXL-JOB调度中心中每个JOB逻辑非常 “轻”,在全异步化的基础上,单个JOB一次运行平均耗时基本在 “10ms” 之内(基本为一次请求的网络开销);因此,可以保证使用有限的线程支撑大量的JOB并发运行;

    异步调度:调度中心每次任务触发时仅发送一次调度请求,该调度请求首先推送“异步调度队列”,然后异步推送给远程执行器

    异步执行:执行器会将请求存入“异步执行队列”并且立即响应调度中心,异步运行。

    得益于上述两点优化,理论上默认配置下的调度中心,单机能够支撑 5000 任务并发运行稳定运行;

    实际场景中,由于调度中心与执行器网络ping延迟不同、DB读写耗时不同、任务调度密集程度不同,会导致任务量上限会上下波动。

    如若需要支撑更多的任务量,可以通过 “调大调度线程数” 、”降低调度中心与执行器ping延迟” 和 “提升机器配置” 几种方式优化。

    5.4.12 均衡调度

    调度中心在集群部署时会自动进行任务平均分配,触发组件每次获取与线程池数量(调度中心支持自定义调度线程池大小)相关数量的任务,避免大量任务集中在单个调度中心集群节点;

    5.5 任务 “运行模式” 剖析

    5.5.1 “Bean模式” 任务

    开发步骤:可参考 “章节三” ;

    原理:每个Bean模式任务都是一个Spring的Bean类实例,它被维护在“执行器”项目的Spring容器中。任务类需要加“@JobHandler(value=”名称”)”注解,因为“执行器”会根据该注解识别Spring容器中的任务。任务类需要继承统一接口“IJobHandler”,任务逻辑在execute方法中开发,因为“执行器”在接收到调度中心的调度请求时,将会调用“IJobHandler”的execute方法,执行任务逻辑。

    5.5.2 “GLUE模式(Java)” 任务

    开发步骤:可参考 “章节三” ;

    原理:每个 “GLUE模式(Java)” 任务的代码,实际上是“一个继承自“IJobHandler”的实现类的类代码”,“执行器”接收到“调度中心”的调度请求时,会通过Groovy类加载器加载此代码,实例化成Java对象,同时注入此代码中声明的Spring服务(请确保Glue代码中的服务和类引用在“执行器”项目中存在),然后调用该对象的execute方法,执行任务逻辑。

    5.5.3 GLUE模式(Shell) + GLUE模式(Python) + GLUE模式(NodeJS)

    开发步骤:可参考 “章节三” ;

    原理:脚本任务的源码托管在调度中心,脚本逻辑在执行器运行。当触发脚本任务时,执行器会加载脚本源码在执行器机器上生成一份脚本文件,然后通过Java代码调用该脚本;并且实时将脚本输出日志写到任务日志文件中,从而在调度中心可以实时监控脚本运行情况;

    目前支持的脚本类型如下:

    -shell脚本:任务运行模式选择为"GLUE模式(Shell)"时支持"shell"脚本任务;

    -python脚本:任务运行模式选择为"GLUE模式(Python)"时支持"python"脚本任务;

    -nodejs脚本:务运行模式选择为"GLUE模式(NodeJS)"时支持"nodejs"脚本任务;

    脚本任务通过 Exit Code 判断任务执行结果,状态码可参考章节 “5.15 任务执行结果说明”;

    5.5.4 执行器

    执行器实际上是一个内嵌的Server,默认端口9999(配置项:xxl.job.executor.port)。

    在项目启动时,执行器会通过“@JobHandler”识别Spring容器中“Bean模式任务”,以注解的value属性为key管理起来。

    “执行器”接收到“调度中心”的调度请求时,如果任务类型为“Bean模式”,将会匹配Spring容器中的“Bean模式任务”,然后调用其execute方法,执行任务逻辑。如果任务类型为“GLUE模式”,将会加载GLue代码,实例化Java对象,注入依赖的Spring服务(注意:Glue代码中注入的Spring服务,必须存在与该“执行器”项目的Spring容器中),然后调用execute方法,执行任务逻辑。

    5.5.5 任务日志

    XXL-JOB会为每次调度请求生成一个单独的日志文件,需要通过 “XxlJobLogger.log” 打印执行日志,“调度中心”查看执行日志时将会加载对应的日志文件。

    (历史版本通过重写LOG4J的Appender实现,存在依赖限制,该方式在新版本已经被抛弃)

    日志文件存放的位置可在“执行器”配置文件进行自定义,默认目录格式为:/data/applogs/xxl-job/jobhandler/“格式化日期”/“数据库调度日志记录的主键ID.log”。

    在JobHandler中开启子线程时,子线程将会将会把日志打印在父线程即JobHandler的执行日志中,方便日志追踪。

    5.6 通讯模块剖析

    5.6.1 一次完整的任务调度通讯流程

    -1、“调度中心”向“执行器”发送http调度请求:“执行器”中接收请求的服务,实际上是一台内嵌Server,默认端口9999;

    -2、“执行器”执行任务逻辑;

    -3、“执行器”http回调“调度中心”调度结果:“调度中心”中接收回调的服务,是针对执行器开放一套API服务;

    5.6.2 通讯数据加密

    调度中心向执行器发送的调度请求时使用RequestModel和ResponseModel两个对象封装调度请求参数和响应数据, 在进行通讯之前底层会将上述两个对象对象序列化,并进行数据协议以及时间戳检验,从而达到数据加密的功能;

    5.7 任务注册, 任务自动发现

    自v1.5版本之后, 任务取消了”任务执行机器”属性, 改为通过任务注册和自动发现的方式, 动态获取远程执行器地址并执行。

    AppName:每个执行器机器集群的唯一标示,任务注册以"执行器"为最小粒度进行注册;每个任务通过其绑定的执行器可感知对应的执行器机器列表;

    注册表:见"xxl_job_registry"表,"执行器"在进行任务注册时将会周期性维护一条注册记录,即机器地址和AppName的绑定关系;"调度中心"从而可以动态感知每个AppName在线的机器列表;

    执行器注册:任务注册Beat周期默认30s;执行器以一倍Beat进行执行器注册,调度中心以一倍Beat进行动态任务发现;注册信息的失效时间为三倍Beat;

    执行器注册摘除:执行器销毁时,将会主动上报调度中心并摘除对应的执行器机器信息,提高心跳注册的实时性;

    为保证系统”轻量级”并且降低学习部署成本,没有采用Zookeeper作为注册中心,采用DB方式进行任务注册发现;

    5.8 任务执行结果

    自v1.6.2之后,任务执行结果通过 “IJobHandler” 的返回值 “ReturnT” 进行判断;

    当返回值符合 “ReturnT.code == ReturnT.SUCCESS_CODE” 时表示任务执行成功,否则表示任务执行失败,而且可以通过 “ReturnT.msg” 回调错误信息给调度中心;

    从而,在任务逻辑中可以方便的控制任务执行结果;

    5.9 分片广播 & 动态分片

    执行器集群部署时,任务路由策略选择”分片广播”情况下,一次任务调度将会广播触发对应集群中所有执行器执行一次任务,同时系统自动传递分片参数;可根据分片参数开发分片任务;

    “分片广播” 以执行器为维度进行分片,支持动态扩容执行器集群从而动态增加分片数量,协同进行业务处理;在进行大数据量业务操作时可显著提升任务处理能力和速度。

    “分片广播” 和普通任务开发流程一致,不同之处在于可以可以获取分片参数,获取分片参数进行分片业务处理。

    Java语言任务获取分片参数方式:BEAN、GLUE模式(Java)// 可参考Sample示例执行器中的示例任务"ShardingJobHandler"了解试用

    ShardingUtil.ShardingVOshardingVO =ShardingUtil.getShardingVo();

    脚本语言任务获取分片参数方式:GLUE模式(Shell)、GLUE模式(Python)、GLUE模式(Nodejs)// 脚本任务入参固定为三个,依次为:任务传参、分片序号、分片总数。以Shell模式任务为例,获取分片参数代码如下

    echo "分片序号 index = $2"

    echo "分片总数 total = $3"

    分片参数属性说明:

    index:当前分片序号(从0开始),执行器集群列表中当前执行器的序号;

    total:总分片数,执行器集群的总机器数量;

    该特性适用场景如:

    1、分片任务场景:10个执行器的集群来处理10w条数据,每台机器只需要处理1w条数据,耗时降低10倍;

    2、广播任务场景:广播执行器机器运行shell脚本、广播集群节点进行缓存更新等

    5.10 访问令牌(AccessToken)

    为提升系统安全性,调度中心和执行器进行安全性校验,双方AccessToken匹配才允许通讯;

    调度中心和执行器,可通过配置项 “xxl.job.accessToken” 进行AccessToken的设置。

    调度中心和执行器,如果需要正常通讯,只有两种设置;

    设置一:调度中心和执行器,均不设置AccessToken;关闭安全性校验;

    设置二:调度中心和执行器,设置了相同的AccessToken;

    5.11 调度中心API服务

    调度中心提供了API服务,主要分为两种类型:

    5.11.1 提供给执行器的API服务:

    1、任务结果回调服务;

    2、执行器注册服务;

    3、执行器注册摘除服务;

    4、触发任务单次执行服务,支持任务根据业务事件触发;

    API服务位置:com.xxl.job.core.biz.AdminBiz.java

    API服务请求参考代码:com.xxl.job.adminbiz.AdminBizTest.java

    5.11.2 提供给业务的API服务:

    1、任务列表查询;

    2、任务新增;

    3、任务更新;

    4、任务删除;

    5、任务启动;

    6、任务停止;

    7、任务触发;

    API服务位置:com.xxl.job.admin.controller.JobInfoController.java

    API服务请求参考代码:可参考任务界面操作的ajax请求。任何ajax接口均可配置成为API服务,只需在待启用的API服务上添加 “@PermissionLimit(limit = false)” 注解取消登陆态拦截即可;

    5.12 执行器API服务

    执行器提供了API服务,供调度中心选择使用,目前提供的API服务有:

    1、心跳检测:调度中心使用

    2、忙碌检测:调度中心使用

    3、触发任务执行:调度中心使用;本地进行任务开发时,可使用该API服务模拟触发任务;

    4、获取RollingLog:调度中心使用

    5、终止任务:调度中心使用

    API服务位置:com.xxl.job.core.biz.ExecutorBiz

    API服务请求参考代码:com.xxl.job.executor.ExecutorBizTest

    5.13 故障转移 & 失败重试

    一次完整任务流程包括”调度(调度中心) + 执行(执行器)”两个阶段。

    “故障转移”发生在调度阶段,在执行器集群部署时,如果某一台执行器发生故障,该策略支持自动进行Failover切换到一台正常的执行器机器并且完成调度请求流程。

    “失败重试”发生在”调度 + 执行”两个阶段,支持通过自定义任务失败重试次数,当任务失败时将会按照预设的失败重试次数主动进行重试;

    5.14 执行器灰度上线

    调度中心与业务解耦,只需部署一次后常年不需要维护。但是,执行器中托管运行着业务作业,作业上线和变更需要重启执行器,尤其是Bean模式任务。

    执行器重启可能会中断运行中的任务。但是,XXL-JOB得益于自建执行器与自建注册中心,可以通过灰度上线的方式,避免因重启导致的任务中断的问题。

    步骤如下:

    1、执行器改为手动注册,下线一半机器列表(A组),线上运行另一半机器列表(B组);

    2、等待A组机器任务运行结束并编译上线;执行器注册地址替换为A组;

    3、等待B组机器任务运行结束并编译上线;执行器注册地址替换为A组+B组;

    操作结束;

    5.15 任务执行结果说明

    系统根据以下标准判断任务执行结果,可参考之。

    —Bean/Glue(Java)Glue(Shell) 等脚本任务

    成功

    IJobHandler.SUCCESS

    0

    失败

    IJobHandler.FAIL

    -1(非0状态码)

    5.16 任务超时控制

    支持设置任务超时时间,任务运行超时的情况下,将会主动中断任务;

    需要注意的是,任务超时中断时与任务终止机制(可查看“4.9 终止运行中的任务”)类似,也是通过 “interrupt” 中断任务,因此业务代码需要将 “InterruptedException” 外抛,否则功能不可用。

    5.17 跨平台 & 跨语言

    跨平台、跨语言主要体现在以下两个方面:

    1、提供Java、Python、PHP……等十来种任务模式,可参考章节 “5.5 任务 “运行模式” ”;理论上可扩展任意语言任务模式;

    2、提供基于HTTP的任务Handler(Bean任务,JobHandler=”HttpJobHandler”);业务方只需要提供HTTP链接即可,不限制语言、平台;

    5.18 任务失败告警

    默认提供邮件失败告警,可扩展短信、钉钉等方式,扩展代码位置为 “JobFailMonitorHelper.failAlarm”;

    5.19 调度中心Docker镜像构建

    可以通过以下命令快速构建调度中心,并启动运行;

    mvn clean package

    docker build -t xuxueli/xxl-job-admin ./xxl-job-admin

    docker run --name xxl-job-admin -p 8080:8080-d xuxueli/xxl-job-admin

    5.20 避免任务重复执行

    调度密集或者耗时任务可能会导致任务阻塞,集群情况下调度组件小概率情况下会重复触发;

    针对上述情况,可以通过结合 “单机路由策略(如:第一台、一致性哈希)” + “阻塞策略(如:单机串行、丢弃后续调度)” 来规避,最终避免任务重复执行。

    5.21 命令行任务

    原生提供通用命令行任务Handler(Bean任务,”CommandJobHandler”);业务方只需要提供命令行即可;

    如任务参数 “pwd” 将会执行命令并输出数据;

    5.22 日志自动清理

    XXL-JOB日志主要包含如下两部分,均支持日志自动清理,说明如下:

    调度中心日志表数据:可借助配置项 “xxl.job.logretentiondays” 设置日志表数据保存天数,过期日志自动清理;详情可查看上文配置说明;

    执行器日志文件数据:可借助配置项 “xxl.job.executor.logretentiondays” 设置日志文件数据保存天数,过期日志自动清理;详情可查看上文配置说明;

    展开全文
  • JBPM采购申请系统——11_讲任务调度.7z JBPM采购申请系统——11_讲任务调度.7z JBPM采购申请系统——11_讲任务调度.7z JBPM采购申请系统——11_讲任务调度.7z JBPM采购申请系统——11_讲任务调度.7z JBPM采购申请...
  • 什么是任务调度

    千次阅读 2021-12-18 22:14:50
    我们可以先思考一下业务场景的解决方案: 某电商系统需要在每天上午10点,下午3点,晚上8点发放一批优惠券。 某银行系统需要在信用卡到期还款日的前三...任务调度是指系统为了自动完成特定任务,在约定的特定时
  • 【FreeRTOS】任务调度机制

    千次阅读 2022-04-24 23:06:43
    FreeRTOS之任务调度 不同于前后台轮询系统,FreeRTOS正是使用任务调度机制来选择某个任务运行。那么到底如何选择任务,就需要根据任务的优先级的状态来决定。 文章目录FreeRTOS之任务调度1 【优先级与任务状态】1.1 ...
  • "固定优先级"意味着调度程序不会一直更改任务的优先级,但是由于优先级继承,它可能会暂时提高任务的优先级。 "抢占式"意味着调度程序始终运行能够运行的最高优先级的 RTOS 任务,而不管任务何时能够运行。...
  • Azkaban任务调度工具简述

    千次阅读 2021-09-02 21:40:16
    复杂的任务调度:开发调度平台或使用现成的开源调度系统,比如ooize、azkaban、airflow等 在hadoop领域,常见的工作流调度器有Oozie,Azkaban,Cascading,Hamake等 各种调度工具特性对比 下面的表格对上述四种...
  • golang分布式任务调度

    千次阅读 2022-04-15 16:42:52
    虽然市面上已有许多完善的任务调度服务,但是对于我们初学者来说,为了锻炼代码能力,尝试自行解决问题,造一造轮子,实现一些demo,也并非坏事。 注:文章代码参照课程(Go语言打造分布式Crontab 轻松搞定高性能...
  • 分布式作业调度框架,是一个开发迅速、学习简单、轻量级、易扩展、高可用分布式任务调度框架。 二、分布式任务调度框架 2.1 任务调度框架的简介 任务调度是指基于给定的时间点,给定的时间间隔或者给定执行次数...
  • c语言实现任务调度

    千次阅读 2021-08-10 11:23:46
    一、介绍 调度器是常用的一种编程框架,也是操作系统的拆分多任务的核心,比如单片机的裸机程序框架,网络...三、任务调度代码实现 这里拿linux来测试 schduler.c //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // 头文件
  • DolphinScheduler任务调度

    千次阅读 2022-03-16 18:18:17
    DolphinScheduler任务调度1. DolphinScheduler简介2. DolphinScheduler特点3. DolphinScheduler安装3.1  依赖软件3.2  下载二进制tar.gz包3.3  数据库初始化3.4  修改运行参数3.5  启动Zookeeper集群3.6 ...
  • Java定时任务调度详解

    千次阅读 2021-10-31 13:43:15
    在实际项目开发中,除了Web应用、SOA服务外,还有一类不可缺少的,那就是定时任务调度。定时任务的场景可以说非常广泛,比如某些视频网站,购买会员后,每天会给会员送成长值,每月会给会员送一些电影券;比如在保证...
  • 浅谈大数据任务调度平台

    千次阅读 热门讨论 2020-12-28 13:54:35
    谈到大数据,避免不了hadoop, hive, spark 这些基础套件,但是在整个大数据开发的时候,我们面对的基本上都是数据开发平台和任务调度系统。数据开发平台一般直接面对业务同学,很大程度上影响业务同学的开发效率和...
  • DAG以及任务调度

    千次阅读 2019-12-07 21:49:16
    任务调度 任务调度组件的核心使命是让任务按照既定的执行计划去执行。对于复杂的任务,是由多个任务组成一个任务组,它们之间存在依赖关系,一个任务执行的条件,必须是它的前置任务已经执行成功(或者没有前置任务...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 494,288
精华内容 197,715
关键字:

任务的调度