关于java:SpringBoot定时任务-开箱即用分布式任务框架xxljob

41次阅读

共计 14762 个字符，预计需要花费 37 分钟才能阅读完成。

除了前文介绍的 ElasticJob，xxl-job 在很多中小公司有着利用（尽管其代码和设计等品质并不太高，License 不够凋谢，有着个人主义色调，然而其具体开箱应用的便捷性和性能绝对欠缺性，这是中小团队采纳的次要起因）；XXL-JOB 是一个分布式任务调度平台，其外围设计指标是开发迅速、学习简略、轻量级、易扩大。本文介绍 XXL-JOB 以及 SpringBoot 的集成。@pdai

  • SpringBoot 定时工作 – 分布式 xxl-job 形式

    • 常识筹备

      • 分布式工作常识体系
      • 什么是 xxl-job

      • xxl-job 的架构设计

        • 设计思维
        • 零碎组成
        • 架构图

    • 实现案例

      • Bean 模式 (基于办法)

        • Job 的开发环境依赖
        • Job 的开发
        • Job 的调度配置和执行

      • Bean 模式 (基于类)

        • Job 的开发环境依赖
        • Job 的开发
        • Job 的调度配置和执行

      • GLUE 模式

        • 配置和启动流程
        • GLUE 模式还有哪些
      • 更多配置的阐明
    • 示例源码

常识筹备

须要对分布式工作的常识体系和 xxl-Job 有根本的了解。@pdai

什么是 xxl-job

XXL-JOB 是一个分布式任务调度平台，其外围设计指标是开发迅速、学习简略、轻量级、易扩大。现已凋谢源代码并接入多家公司线上产品线，开箱即用。如下内容来源于 xxl-job 官网

反对如下个性：

  • 1、简略：反对通过 Web 页面对工作进行 CRUD 操作，操作简略，一分钟上手；
  • 2、动静：反对动静批改工作状态、启动 / 进行工作，以及终止运行中工作，即时失效；
  • 3、调度核心 HA（核心式）：调度采纳核心式设计，“调度核心”自研调度组件并反对集群部署，可保障调度核心 HA；
  • 4、执行器 HA（分布式）：工作分布式执行，工作 ” 执行器 ” 反对集群部署，可保障工作执行 HA；
  • 5、注册核心: 执行器会周期性主动注册工作, 调度核心将会主动发现注册的工作并触发执行。同时，也反对手动录入执行器地址；
  • 6、弹性扩容缩容：一旦有新执行器机器上线或者下线，下次调度时将会重新分配工作；
  • 7、触发策略：提供丰盛的工作触发策略，包含：Cron 触发、固定距离触发、固定延时触发、API（事件）触发、人工触发、父子工作触发；
  • 8、调度过期策略：调度核心错过调度工夫的弥补解决策略，包含：疏忽、立刻弥补触发一次等；
  • 9、阻塞解决策略：调度过于密集执行器来不及解决时的解决策略，策略包含：单机串行（默认）、抛弃后续调度、笼罩之前调度；
  • 10、工作超时管制：反对自定义工作超时工夫，工作运行超时将会被动中断工作；
  • 11、工作失败重试：反对自定义工作失败重试次数，当工作失败时将会依照预设的失败重试次数被动进行重试；其中分片工作反对分片粒度的失败重试；
  • 12、工作失败告警；默认提供邮件形式失败告警，同时预留扩大接口，可不便的扩大短信、钉钉等告警形式；
  • 13、路由策略：执行器集群部署时提供丰盛的路由策略，包含：第一个、最初一个、轮询、随机、一致性 HASH、最不常常应用、最近最久未应用、故障转移、繁忙转移等；
  • 14、分片播送工作：执行器集群部署时，工作路由策略抉择 ” 分片播送 ” 状况下，一次任务调度将会播送触发集群中所有执行器执行一次工作，可依据分片参数开发分片工作；
  • 15、动静分片：分片播送工作以执行器为维度进行分片，反对动静扩容执行器集群从而动静减少分片数量，协同进行业务解决；在进行大数据量业务操作时可显著晋升工作解决能力和速度。
  • 16、故障转移：工作路由策略抉择 ” 故障转移 ” 状况下，如果执行器集群中某一台机器故障，将会主动 Failover 切换到一台失常的执行器发送调度申请。
  • 17、工作进度监控：反对实时监控工作进度；
  • 18、Rolling 实时日志：反对在线查看调度后果，并且反对以 Rolling 形式实时查看执行器输入的残缺的执行日志；
  • 19、GLUE：提供 Web IDE，反对在线开发工作逻辑代码，动静公布，实时编译失效，省略部署上线的过程。反对 30 个版本的历史版本回溯。
  • 20、脚本工作：反对以 GLUE 模式开发和运行脚本工作，包含 Shell、Python、NodeJS、PHP、PowerShell 等类型脚本;
  • 21、命令行工作：原生提供通用命令行工作 Handler（Bean 工作，”CommandJobHandler”）；业务方只须要提供命令行即可；
  • 22、工作依赖：反对配置子工作依赖，当父工作执行完结且执行胜利后将会被动触发一次子工作的执行, 多个子工作用逗号分隔；
  • 23、一致性：“调度核心”通过 DB 锁保障集群散布式调度的一致性, 一次任务调度只会触发一次执行；
  • 24、自定义工作参数：反对在线配置调度工作入参，即时失效；
  • 25、调度线程池：调度零碎多线程触发调度运行，确保调度准确执行，不被梗塞；
  • 26、数据加密：调度核心和执行器之间的通信进行数据加密，晋升调度信息安全性；
  • 27、邮件报警：工作失败时反对邮件报警，反对配置多邮件地址群发报警邮件；
  • 28、推送 maven 地方仓库: 将会把最新稳定版推送到 maven 地方仓库, 不便用户接入和应用;
  • 29、运行报表：反对实时查看运行数据，如工作数量、调度次数、执行器数量等；以及调度报表，如调度日期分布图，调度胜利分布图等；
  • 30、全异步：任务调度流程全异步化设计实现，如异步调度、异步运行、异步回调等，无效对密集调度进行流量削峰，实践上反对任意时长工作的运行；
  • 31、跨语言：调度核心与执行器提供语言无关的 RESTful API 服务，第三方任意语言可据此对接调度核心或者实现执行器。除此之外，还提供了“多任务模式”和“httpJobHandler”等其余跨语言计划；
  • 32、国际化：调度核心反对国际化设置，提供中文、英文两种可选语言，默认为中文；
  • 33、容器化：提供官网 docker 镜像，并实时更新推送 dockerhub，进一步实现产品开箱即用；
  • 34、线程池隔离：调度线程池进行隔离拆分，慢工作主动降级进入 ”Slow” 线程池，防止耗尽调度线程，进步零碎稳定性；
  • 35、用户治理：反对在线管理系统用户，存在管理员、普通用户两种角色；
  • 36、权限管制：执行器维度进行权限管制，管理员领有全量权限，普通用户须要调配执行器权限后才容许相干操作；

xxl-job 的架构设计

设计思维

将调度行为形象造成“调度核心”公共平台，而平台本身并不承当业务逻辑，“调度核心”负责发动调度申请。

将工作形象成扩散的 JobHandler，交由“执行器”对立治理，“执行器”负责接管调度申请并执行对应的 JobHandler 中业务逻辑。

因而，“调度”和“工作”两局部能够互相解耦，进步零碎整体稳定性和扩展性；

零碎组成

  1. 调度模块 （调度核心）

    1. 负责管理调度信息，依照调度配置收回调度申请，本身不承当业务代码。调度零碎与工作解耦，进步了零碎可用性和稳定性，同时调度零碎性能不再受限于工作模块；
    2. 反对可视化、简略且动静的治理调度信息，包含工作新建，更新，删除，GLUE 开发和工作报警等，所有上述操作都会实时失效，同时反对监控调度后果以及执行日志，反对执行器 Failover。

  2. 执行模块 （执行器）：

    1. 负责接管调度申请并执行工作逻辑。工作模块专一于工作的执行等操作，开发和保护更加简略和高效；
    2. 接管“调度核心”的执行申请、终止申请和日志申请等。

架构图

实现案例

次要介绍 SpringBoot 集成 xxl-job 的形式：Bean 模式（基于办法和基于类）；以及基于在线配置代码 / 脚本的 GLUE 模式。

Bean 模式 (基于办法)

Bean 模式工作，反对基于办法的开发方式，每个工作对应一个办法。基于办法开发的工作，底层会生成 JobHandler 代理，和基于类的形式一样，工作也会以 JobHandler 的模式存在于执行器工作容器中。

长处 ：

  • 每个工作只须要开发一个办法，并增加”@XxlJob”注解即可，更加不便、疾速。
  • 反对主动扫描工作并注入到执行器容器。

毛病 ：要求 Spring 容器环境；

Job 的开发环境依赖

Maven 依赖 

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

application.properties 配置 

# web port
server.port=8081
# 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://127.0.0.1:8080/xxl-job-admin

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

### 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=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

Config 配置 (PS：这里我是间接拿的 xxl-job demo 中的配置，理论开发中能够封装一个 starter 主动注入)

package tech.pdai.springboot.xxljob.config;

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * xxl-job config
 *
 * @author xuxueli 2017-04-28
 */
@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);

        // Bean 办法模式
        // 通过扫描 @XxlJob 形式注册

        // 注册 Bean 类模式
        XxlJobExecutor.registJobHandler("beanClassDemoJobHandler", new BeanClassDemoJob());

        return xxlJobSpringExecutor;
    }

}

Job 的开发

开发步骤：

  1. 工作开发：在 Spring Bean 实例中，开发 Job 办法；
  2. 注解配置：为 Job 办法增加注解 “@XxlJob(value=” 自定义 jobhandler 名称 ”, init = “JobHandler 初始化办法 ”, destroy = “JobHandler 销毁办法 ”)”，注解 value 值对应的是调度核心新建工作的 JobHandler 属性的值。
  3. 执行日志：须要通过 “XxlJobHelper.log” 打印执行日志；
  4. 工作后果：默认工作后果为 “ 胜利 ” 状态，不须要被动设置；如有诉求，比方设置工作后果为失败，能够通过 “XxlJobHelper.handleFail/handleSuccess” 自主设置工作后果；
package tech.pdai.springboot.xxljob.job;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Arrays;

import com.xxl.job.core.context.XxlJobHelper;
import com.xxl.job.core.handler.annotation.XxlJob;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * XxlJob 开发示例（Bean 模式 - 办法）* 
 */
@Slf4j
@Component
public class BeanMethodDemoJob {

    /**
     * 1、简略工作示例（Bean 模式）*/
    @XxlJob("demoJobHandler")
    public void demoJobHandler() {XxlJobHelper.log("demoJobHandler execute...");
    }

    /**
     * 2、分片播送工作
     */
    @XxlJob("shardingJobHandler")
    public void shardingJobHandler() throws Exception {
        // logback console 日志
        log.info("shardingJobHandler execute...");

        // 通过 xxl 记录到 DB 中的日志
        XxlJobHelper.log("shardingJobHandler execute...");

        // 分片参数
        int shardIndex = XxlJobHelper.getShardIndex();
        int shardTotal = XxlJobHelper.getShardTotal();

        XxlJobHelper.log("分片参数：以后分片序号 = {}, 总分片数 = {}", shardIndex, shardTotal);

        // 业务逻辑
        for (int i = 0; i < shardTotal; i++) {if (i==shardIndex) {XxlJobHelper.log("第 {} 片, 命中分片开始解决", i);
            } else {XxlJobHelper.log("第 {} 片, 疏忽", i);
            }
        }

    }


    /**
     * 3、命令行工作
     */
    @XxlJob("commandJobHandler")
    public void commandJobHandler() throws Exception {XxlJobHelper.log("commandJobHandler execute...");

        String command = XxlJobHelper.getJobParam();
        int exitValue = -1;

        BufferedReader bufferedReader = null;
        try {
            // command process
            ProcessBuilder processBuilder = new ProcessBuilder();
            processBuilder.command(command);
            processBuilder.redirectErrorStream(true);

            Process process = processBuilder.start();
            //Process process = Runtime.getRuntime().exec(command);

            BufferedInputStream bufferedInputStream = new BufferedInputStream(process.getInputStream());
            bufferedReader = new BufferedReader(new InputStreamReader(bufferedInputStream));

            // command log
            String line;
            while ((line = bufferedReader.readLine())!=null) {XxlJobHelper.log(line);
            }

            // command exit
            process.waitFor();
            exitValue = process.exitValue();} catch (Exception e) {XxlJobHelper.log(e);
        } finally {if (bufferedReader!=null) {bufferedReader.close();
            }
        }

        if (exitValue==0) {// default success} else {XxlJobHelper.handleFail("command exit value(" + exitValue + ") is failed");
        }

    }


    /**
     * 4、跨平台 Http 工作
     * 参数示例：* "url: http://www.baidu.com\n" +
     * "method: get\n" +
     * "data: content\n";
     */
    @XxlJob("httpJobHandler")
    public void httpJobHandler() throws Exception {XxlJobHelper.log("httpJobHandler execute...");

        // param parse
        String param = XxlJobHelper.getJobParam();
        if (param==null || param.trim().length()==0) {XxlJobHelper.log("param[" + param + "] invalid.");

            XxlJobHelper.handleFail();
            return;
        }

        String[] httpParams = param.split("\n");
        String url = null;
        String method = null;
        String data = null;
        for (String httpParam : httpParams) {if (httpParam.startsWith("url:")) {url = httpParam.substring(httpParam.indexOf("url:") + 4).trim();}
            if (httpParam.startsWith("method:")) {method = httpParam.substring(httpParam.indexOf("method:") + 7).trim().toUpperCase();
            }
            if (httpParam.startsWith("data:")) {data = httpParam.substring(httpParam.indexOf("data:") + 5).trim();}
        }

        // param valid
        if (url==null || url.trim().length()==0) {XxlJobHelper.log("url[" + url + "] invalid.");

            XxlJobHelper.handleFail();
            return;
        }
        if (method==null || !Arrays.asList("GET", "POST").contains(method)) {XxlJobHelper.log("method[" + method + "] invalid.");

            XxlJobHelper.handleFail();
            return;
        }
        boolean isPostMethod = method.equals("POST");

        // request
        HttpURLConnection connection = null;
        BufferedReader bufferedReader = null;
        try {
            // connection
            URL realUrl = new URL(url);
            connection = (HttpURLConnection) realUrl.openConnection();

            // connection setting
            connection.setRequestMethod(method);
            connection.setDoOutput(isPostMethod);
            connection.setDoInput(true);
            connection.setUseCaches(false);
            connection.setReadTimeout(5 * 1000);
            connection.setConnectTimeout(3 * 1000);
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setRequestProperty("Accept-Charset", "application/json;charset=UTF-8");

            // do connection
            connection.connect();

            // data
            if (isPostMethod && data!=null && data.trim().length() > 0) {DataOutputStream dataOutputStream = new DataOutputStream(connection.getOutputStream());
                dataOutputStream.write(data.getBytes("UTF-8"));
                dataOutputStream.flush();
                dataOutputStream.close();}

            // valid StatusCode
            int statusCode = connection.getResponseCode();
            if (statusCode!=200) {throw new RuntimeException("Http Request StatusCode(" + statusCode + ") Invalid.");
            }

            // result
            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
            StringBuilder result = new StringBuilder();
            String line;
            while ((line = bufferedReader.readLine())!=null) {result.append(line);
            }
            String responseMsg = result.toString();

            XxlJobHelper.log(responseMsg);

            return;
        } catch (Exception e) {XxlJobHelper.log(e);

            XxlJobHelper.handleFail();
            return;
        } finally {
            try {if (bufferedReader!=null) {bufferedReader.close();
                }
                if (connection!=null) {connection.disconnect();
                }
            } catch (Exception e2) {XxlJobHelper.log(e2);
            }
        }

    }

    /**
     * 5、生命周期工作示例：工作初始化与销毁时，反对自定义相干逻辑；*/
    @XxlJob(value = "demoJobHandler2", init = "init", destroy = "destroy")
    public void demoJobHandler2() throws Exception {XxlJobHelper.log("demoJobHandler2, execute...");
    }

    public void init() {log.info("init");
    }

    public void destroy() {log.info("destroy");
    }


}

(@pdai: 从设计的角度，xxl-job 能够对上述不同类型进行细分)

Job 的调度配置和执行

新增 Job, 并把上述的 @XxlJob(value=” 自定义 jobhandler 名称 ”, init = “JobHandler 初始化办法 ”, destroy = “JobHandler 销毁办法 ”) 中 自定义 jobhandler 名称 填写到 JobHandler 中。

其它配置如下：

能够抉择操作中执行一次工作，或者启动（依照 Cron 执行 )

能够查看执行的记录

进一步能够看每个执行记录的执行日志

Bean 模式 (基于类)

Bean 模式工作，反对基于类的开发方式，每个工作对应一个 Java 类。

长处 ：不限度我的项目环境，兼容性好。即便是无框架我的项目，如 main 办法间接启动的我的项目也能够提供反对，能够参考示例我的项目“xxl-job-executor-sample-frameless”；

毛病 ：

  • 每个工作须要占用一个 Java 类，造成类的节约；
  • 不反对主动扫描工作并注入到执行器容器，须要手动注入。

Job 的开发环境依赖

同 Bean 模式 (基于办法)

Job 的开发

开发步骤：

  1. 执行器我的项目中，开发 Job 类：

    • 开发一个继承自 ”com.xxl.job.core.handler.IJobHandler” 的 JobHandler 类，实现其中工作办法。
    • 手动通过如下形式注入到执行器容器。

  2. 注册 jobHandler

    • XxlJobExecutor.registJobHandler("xxxxxJobHandler", new xxxxxJobHandler());

Job 开发 

package tech.pdai.springboot.xxljob.job;

import com.xxl.job.core.handler.IJobHandler;
import lombok.extern.slf4j.Slf4j;

/**
 * @author pdai
 */
@Slf4j
public class BeanClassDemoJob extends IJobHandler {

    @Override
    public void execute() throws Exception {log.info("BeanClassDemoJob, execute...");
    }
}

注册 jobHandler(@pdai: 这里 xxl-job 设计的不好，是能够通过 IJobHandler 来主动注册的)

XxlJobExecutor.registJobHandler("beanClassDemoJobHandler", new BeanClassDemoJob());

启动 SpringBoot 利用, 能够发现注册的 

...
20:34:15.385 logback [main] INFO  c.x.job.core.executor.XxlJobExecutor - >>>>>>>>>>> xxl-job register jobhandler success, name:beanClassDemoJobHandler, jobHandler:tech.pdai.springboot.xxljob.job.BeanClassDemoJob@640ab13c
...

Job 的调度配置和执行

同 Bean 模式 (基于办法)

在调度器中增加执行后，后盾执行的日志如下：

20:41:00.021 logback [xxl-job, EmbedServer bizThreadPool-1023773196] INFO  c.x.job.core.executor.XxlJobExecutor - >>>>>>>>>>> xxl-job regist JobThread success, jobId:5, handler:tech.pdai.springboot.xxljob.job.BeanClassDemoJob@640ab13c
20:41:00.022 logback [xxl-job, JobThread-5-1654681260021] INFO  t.p.s.xxljob.job.BeanClassDemoJob - BeanClassDemoJob, execute...

GLUE 模式

工作以源码形式保护在调度核心，反对通过 Web IDE 在线更新，实时编译和失效，因而不须要指定 JobHandler。

配置和启动流程

开发流程如下：

创立 GLUE 类型的 Job（这里以 Java 为例）

选中指定工作，点击该工作右侧“GLUE”按钮，将会返回 GLUE 工作的 Web IDE 界面，在该界面反对对工作代码进行开发（也能够在 IDE 中开发实现后，复制粘贴到编辑中）。

版本回溯性能（反对 30 个版本的版本回溯）：在 GLUE 工作的 Web IDE 界面，抉择右上角下拉框“版本回溯”，会列出该 GLUE 的更新历史，抉择相应版本即可显示该版本代码，保留后 GLUE 代码即回退到对应的历史版本；

执行后的记录如下

GLUE 模式还有哪些

xxl-job 一共反对如下几种 GLUE 模式：

  • GLUE 模式 (Java)：工作以源码形式保护在调度核心；该模式的工作实际上是一段继承自 IJobHandler 的 Java 类代码并 “groovy” 源码形式保护，它在执行器我的项目中运行，可应用 @Resource/@Autowire 注入执行器里中的其余服务；
  • GLUE 模式 (Shell)：工作以源码形式保护在调度核心；该模式的工作实际上是一段 “shell” 脚本；
  • GLUE 模式 (Python)：工作以源码形式保护在调度核心；该模式的工作实际上是一段 “python” 脚本；
  • GLUE 模式 (PHP)：工作以源码形式保护在调度核心；该模式的工作实际上是一段 “php” 脚本；
  • GLUE 模式 (NodeJS)：工作以源码形式保护在调度核心；该模式的工作实际上是一段 “nodejs” 脚本；
  • GLUE 模式 (PowerShell)：工作以源码形式保护在调度核心；该模式的工作实际上是一段 “PowerShell” 脚本；

更多配置的阐明 

+ 根底配置：- 执行器：工作的绑定的执行器，工作触发调度时将会主动发现注册胜利的执行器, 实现工作主动发现性能; 另一方面也能够不便的进行工作分组。每个工作必须绑定一个执行器, 可在 "执行器治理" 进行设置;
  - 工作形容：工作的形容信息，便于工作治理；- 负责人：工作的负责人；- 报警邮件：任务调度失败时邮件告诉的邮箱地址，反对配置多邮箱地址，配置多个邮箱地址时用逗号分隔；+ 触发配置：- 调度类型：+ 无：该类型不会被动触发调度；+ CRON：该类型将会通过 CRON，触发任务调度；+ 固定速度：该类型将会以固定速度，触发任务调度；依照固定的间隔时间，周期性触发；+ 固定提早：该类型将会以固定提早，触发任务调度；依照固定的延迟时间，从上次调度完结后开始计算延迟时间，达到延迟时间后触发下次调度；- CRON：触发工作执行的 Cron 表达式；- 固定速度：固件速度的工夫距离，单位为秒；- 固定提早：固件提早的工夫距离，单位为秒；+ 高级配置：- 路由策略：当执行器集群部署时，提供丰盛的路由策略，包含；FIRST（第一个）：固定抉择第一个机器；LAST（最初一个）：固定抉择最初一个机器；ROUND（轮询）：；RANDOM（随机）：随机抉择在线的机器；CONSISTENT_HASH（一致性 HASH）：每个工作依照 Hash 算法固定抉择某一台机器，且所有工作平均散列在不同机器上。LEAST_FREQUENTLY_USED（最不常常应用）：应用频率最低的机器优先被选举；LEAST_RECENTLY_USED（最近最久未应用）：最久未应用的机器优先被选举；FAILOVER（故障转移）：依照程序顺次进行心跳检测，第一个心跳检测胜利的机器选定为指标执行器并发动调度；BUSYOVER（繁忙转移）：依照程序顺次进行闲暇检测，第一个闲暇检测胜利的机器选定为指标执行器并发动调度；SHARDING_BROADCAST(分片播送)：播送触发对应集群中所有机器执行一次工作，同时零碎主动传递分片参数；可依据分片参数开发分片工作；- 子工作：每个工作都领有一个惟一的工作 ID(工作 ID 能够从工作列表获取)，当本工作执行完结并且执行胜利时，将会触发子工作 ID 所对应的工作的一次被动调度。- 调度过期策略：- 疏忽：调度过期后，疏忽过期的工作，从以后工夫开始从新计算下次触发工夫；- 立刻执行一次：调度过期后，立刻执行一次，并从以后工夫开始从新计算下次触发工夫；- 阻塞解决策略：调度过于密集执行器来不及解决时的解决策略；单机串行（默认）：调度申请进入单机执行器后，调度申请进入 FIFO 队列并以串行形式运行；抛弃后续调度：调度申请进入单机执行器后，发现执行器存在运行的调度工作，本次申请将会被抛弃并标记为失败；笼罩之前调度：调度申请进入单机执行器后，发现执行器存在运行的调度工作，将会终止运行中的调度工作并清空队列，而后运行本地调度工作；- 工作超时工夫：反对自定义工作超时工夫，工作运行超时将会被动中断工作；- 失败重试次数；反对自定义工作失败重试次数，当工作失败时将会依照预设的失败重试次数被动进行重试；

示例源码

https://github.com/realpdai/t…

更多内容

辞别碎片化学习，无套路一站式体系化学习后端开发: Java 全栈常识体系 https://pdai.tech

正文完
java
发表至： java
2022-08-03
 0
关于java:java是什么它能干什么
重新定义-Spring-Cloud-高清带目录-pdf
关于java:GC垃圾回收
nginx-反向代理配置