docker和K8S环境xxl-job定时任务不执行问题总结_dcoker部署xxljob,无法调用其他服务的定时任务

最新推荐文章于 2024-09-03 14:53:41 发布

2301_82241847

最新推荐文章于 2024-09-03 14:53:41 发布

阅读量1.1k

点赞数 20

文章标签： docker kubernetes 容器

本文链接：https://blog.csdn.net/2301_82241847/article/details/139707507

版权

任务调度的详细原理主要包括以下几个步骤：

Cron表达式解析: Cron表达式是一种用于配置定时任务的表达式，它描述了一个定时规则。这个规则会被调度中心解析并生成具体的触发时间。
触发时间监控: 调度中心会实时监控当前时间，一旦当前时间达到了Cron表达式解析出的触发时间，就会开始进行任务调度。
任务参数获取: 调度中心调度任务时，首先会从数据库或内存中获取需要调度的任务的信息，包括任务类型、执行参数、执行器地址等。
任务路由策略选择: 根据预设的任务路由策略，调度中心会选择一个或多个执行器进行任务调度。路由策略可能是轮询、随机、一致性哈希、最少负载等。
执行器调度: 调度中心根据选择的执行器地址，通过RPC（远程过程调用）或者HTTP请求将任务调度请求发送到执行器。
调度日志记录: 调度中心在完成任务调度后，会记录任务调度日志，包括调度时间、执行器地址、任务参数等信息，以便后续分析和排查问题。
调度结果反馈: 执行器在接收到任务调度请求后，会立即返回一个调度结果给调度中心，调度中心根据这个结果更新任务调度日志。

1 问题1 时区导致的任务没有执行的问题

这个是最常见的问题。因为xxl-job 最核心的是通过时间计算获得下次任务执行的时间点，然后通过内置线程检查进行调度。
所以时间计算错误和时间点检查不匹配也是不会调度的。还有一种是调度了，执行器实际没有执行。我们后面也会讲到。

XXL-JOB是一种任务调度平台。虽然在配置时可能不需要你直接指定时区，但它实际上是根据服务器的时区设定来执行定时任务的。如果你没有特意去修改服务器的时区，那么它就会使用服务器默认的时区。

所以，你在配置XXL-JOB时实际上是考虑了时区的，只不过你可能并没有显式地去设定它。如果你的服务器在不同的时区，或者你需要调度的任务需要在特定的时区执行，那么你可能需要考虑到时区的影响。

如果需要修改服务器的时区，你可以通过在服务器上执行特定的命令来实现。这通常需要管理员权限。具体的命令可能会因操作系统的不同而不同。

如果你需要在XXL-JOB中设置定时任务在特定的时区执行，你可能需要查看XXL-JOB的文档或者联系其支持人员，看看它是否支持这种设定。

解决方案

将系统时间，数据库时间，容器时间设置统一。

MySQL数据库时区

show variables like "%time\_zone%";

数据库JDBC URL上的设置时区

 url=jdbc:mysql://xxxx:3306/dddd?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8

容器内时间设置，这一步要确保宿主机时间的正确

FROM openjdk:8-jre-slim
MAINTAINER xuxueli
 
ENV PARAMS=""
 
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 
ADD target/xxl-job-admin-*.jar /app.jar
 
ENTRYPOINT ["sh","-c","java -jar /app.jar $PARAMS"]

Java应用程序时区问题

启动jar包添加参数 -Duser.timezone=GMT+08

在Java应用程序中，使用参数-Duser.timezone=GMT+08启动jar包可以设置应用程序的默认时区为GMT+08，也就是东八区（中国标准时间）。

当Java应用程序需要进行日期和时间相关的操作时，它会使用默认的时区来解释和表示日期和时间。默认情况下，Java使用操作系统的默认时区作为应用程序的默认时区。但是，通过使用-Duser.timezone参数，可以覆盖默认的时区设置，使应用程序在运行时使用指定的时区。

2 执行器注册和下线导致的问题（IP问题）

我们先来看执行器的配置

### 调度中心部署根地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin
### 执行器通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=
### 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
xxl.job.executor.appname=xxl-job-executor-sample
### 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
xxl.job.executor.address=
### 执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
xxl.job.executor.ip=
### 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
xxl.job.executor.port=9999
### 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
### 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
xxl.job.executor.logretentiondays=30

这两行配置

xxl.job.executor.address=：执行器地址，一般不需要手动配置，系统会自动获取。如果手动配置，那么优先级会比自动获取的方式更高。
xxl.job.executor.ip=：执行器IP地址，可以手动配置，如果不配置则系统会自动获取。

这两个配置项的值取决于你的具体需求和实际的服务器情况。如果你的执行器是在本地服务器上，那么可能不需要填写这两个配置项，系统会自动获取。但是如果你的执行器在远程服务器上，那么你可能需要手动配置这两个项，指定执行器的地址和IP。

需要注意的是，通常情况下只需要配置xxl.job.executor.address=即可，因为XXL-JOB执行器会自动获取本机IP地址进行注册和通信。只有在特定需求下才需要同时配置两个地址。

一般容器环境出现问题核心的点就在这个配置上。

导致调度中心服务无法与定时任务执行器进行通信

容器环境的特殊性，在容器环境中，网络是隔离的。因此，容器中的应用程序在默认情况下只能看到容器内部的网络环境。这就导致了一些问题，比如 xxl.job.executor.address 和 xxl.job.executor.ip 配置问题。

无法预知容器的 IP 地址，因为它是在容器启动时动态分配的。这就导致了如果在配置文件中硬编码了这些值，可能会导致调度中心无法和执行器通信。

解决方案

将IP地址xxl.job.executor.ip=或者注册地址xxl.job.executor.address尝试改为k8s服务名，如果夸namespace的话，服务名前带上namespace 如 nsname.service名称
以下只是示例，实际根据你的的serveci命名命名替换


xxl.iob.admin.addresses = http://xxl-job-admin-service:8080/xxl-iob-admin 
xxl.job.executor.ip=service名称:端口
xxl.job.executor.address=http://service名称:port/

3 问题3 `调度成功，但是执行器的定时任务未执行`

这个问题最诡异，最坑，还无法快速的定位问题。

我们再聊一下xxl-job执行器执行任务的原理
show you code 然后talk


package com.xxl.job.core.thread;

import com.xxl.job.core.biz.model.HandleCallbackParam;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.biz.model.TriggerParam;
import com.xxl.job.core.context.XxlJobContext;
import com.xxl.job.core.executor.XxlJobExecutor;
import com.xxl.job.core.handler.IJobHandler;
import com.xxl.job.core.log.XxlJobFileAppender;
import com.xxl.job.core.log.XxlJobLogger;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class JobThread extends Thread {
    private static Logger logger = LoggerFactory.getLogger(JobThread.class);
    private int jobId;
    private IJobHandler handler;
    private LinkedBlockingQueue<TriggerParam> triggerQueue;
    private Set<Long> triggerLogIdSet;
    private volatile boolean toStop = false;
    private String stopReason;
    private boolean running = false;
    private int idleTimes = 0;

    public JobThread(int jobId, IJobHandler handler) {
        this.jobId = jobId;
        this.handler = handler;
        this.triggerQueue = new LinkedBlockingQueue();
        this.triggerLogIdSet = Collections.synchronizedSet(new HashSet());
    }

    public IJobHandler getHandler() {
        return this.handler;
    }

    public ReturnT<String> pushTriggerQueue(TriggerParam triggerParam) {
        if (this.triggerLogIdSet.contains(triggerParam.getLogId())) {
            logger.info(">>>>>>>>>>> repeate trigger job, logId:{}", triggerParam.getLogId());
            return new ReturnT(500, "repeate trigger job, logId:" + triggerParam.getLogId());
        } else {
            this.triggerLogIdSet.add(triggerParam.getLogId());
            this.triggerQueue.add(triggerParam);
            return ReturnT.SUCCESS;
        }
    }

    public void toStop(String stopReason) {
        this.toStop = true;
        this.stopReason = stopReason;
    }

    public boolean isRunningOrHasQueue() {
        return this.running || this.triggerQueue.size() > 0;
    }

 
public void run() {
    // 尝试初始化处理器
    try {
        this.handler.init();
    } catch (Throwable var26) {
        // 如果有错误，记录错误日志
        logger.error(var26.getMessage(), var26);
    }

    final TriggerParam triggerParam;
    ReturnT executeResult;

    // 当线程没有被要求停止时
    while(!this.toStop) {
        this.running = false;
        ++this.idleTimes;
        triggerParam = null;
        executeResult = null;
        boolean var16 = false;

        ReturnT stopResult;
        label348: {
            try {
                var16 = true;
                // 从触发队列中获取触发器参数，如果在3秒内获取不到，返回null
                triggerParam = (TriggerParam)this.triggerQueue.poll(3L, TimeUnit.SECONDS);
                // 如果触发器参数不为空
                if (triggerParam != null) {
                    this.running = true;
                    this.idleTimes = 0;
                    // 从日志ID集合中移除触发器参数的日志ID
                    this.triggerLogIdSet.remove(triggerParam.getLogId());
                    // 创建日志文件名称
                    String logFileName = XxlJobFileAppender.makeLogFileName(new Date(triggerParam.getLogDateTime()), triggerParam.getLogId());
                    // 设置XxlJob上下文
                    XxlJobContext.setXxlJobContext(new XxlJobContext(triggerParam.getLogId(), logFileName, triggerParam.getBroadcastIndex(), triggerParam.getBroadcastTotal()));
                    // 记录任务启动日志
                    XxlJobLogger.log("<br>----------- xxl-job job execute start -----------<br>----------- Param:" + triggerParam.getExecutorParams(), new Object[0]);
                    // 如果执行超时时间大于0
                    if (triggerParam.getExecutorTimeout() > 0) {
                        Thread futureThread = null;

                        try {
                            // 创建一个新的任务
                            FutureTask<ReturnT<String>> futureTask = new FutureTask(new Callable<ReturnT<String>>() {
                                public ReturnT<String> call() throws Exception {
                                    // 执行处理器
                                    return JobThread.this.handler.execute(triggerParam.getExecutorParams());
                                }
                            });
                            // 在新线程中执行任务
                            futureThread = new Thread(futureTask);
                            futureThread.start();
                            // 获取执行结果，如果在指定的超时时间内没有结果，抛出超时异常
                            executeResult = (ReturnT)futureTask.get((long)triggerParam.getExecutorTimeout(), TimeUnit.SECONDS);
                        } catch (TimeoutException var24) {
                            // 记录任务超时日志
                            XxlJobLogger.log("<br>----------- xxl-job job execute timeout", new Object[0]);
                            XxlJobLogger.log(var24);
                            // 设置超时的执行结果
                            executeResult = new ReturnT(IJobHandler.FAIL\_TIMEOUT.getCode(), "job execute timeout ");
                        } finally {
                            // 中断线程
                            futureThread.interrupt();
                        }
                    } else {
                        // 如果没有设置超时时间，则直接执行处理器
                        executeResult = this.handler.execute(triggerParam.getExecutorParams());
                    }

                    // 如果执行结果为空
                    if (executeResult == null) {
                        // 设置执行失败的结果
                        executeResult = IJobHandler.FAIL;
                    } else {
                        // 否则，设置执行结果的消息和内容
                        executeResult.setMsg(executeResult != null && executeResult.getMsg() != null && executeResult.getMsg().length() > 50000 ? executeResult.getMsg().substring(0, 50000).concat("...") : executeResult.getMsg());
                        executeResult.setContent((Object)null);
                    }

                    // 记录任务结束日志
                    XxlJobLogger.log("<br>----------- xxl-job job execute end(finish) -----------<br>----------- ReturnT:" + executeResult, new Object[0]);
                    var16 = false;
                } else if (this.idleTimes > 30) {
                    // 如果连续30次都没有获取到触发器参数
                    if (this.triggerQueue.size() == 0) {
                        // 如果触发队列为空，则移除Job线程
                        XxlJobExecutor.removeJobThread(this.jobId, "executor idle times over limit.");
                        var16 = false;
                    } else {
                        var16 = false;
                    }
                } else {
                    var16 = false;
                }
                break label348;
            } catch (Throwable var27) {
                // 如果在执行过程中抛出异常
                if (this.toStop) {
                    // 如果被要求停止，记录停止原因
                    XxlJobLogger.log("<br>----------- JobThread toStop, stopReason:" + this.stopReason, new Object[0]);
                }

                // 获取异常信息
                StringWriter stringWriter = new StringWriter();
                var27.printStackTrace(new PrintWriter(stringWriter));
                String errorMsg = stringWriter.toString();
                // 设置执行结果为异常信息
                executeResult = new ReturnT(500, errorMsg);
                // 记录任务异常日志
                XxlJobLogger.log("<br>----------- JobThread Exception:" + errorMsg + "<br>----------- xxl-job job execute end(error) -----------", new Object[0]);
                var16 = false;
            } finally {
                if (var16) {
                    // 如果触发器参数不为空
                    if (triggerParam != null) {
                        if (!this.toStop) {
                            // 如果没有被要求停止，向回调队列中推送回调参数
                            TriggerCallbackThread.pushCallBack(new HandleCallbackParam(triggerParam.getLogId(), triggerParam.getLogDateTime(), executeResult));
                        } else {
                            // 如果被要求停止，设置停止结果，并向回调队列中推送回调参数
                            ReturnT<String> stopResult = new ReturnT(500, this.stopReason + " [job running, killed]");
                            TriggerCallbackThread.pushCallBack(new HandleCallbackParam(triggerParam.getLogId(), triggerParam.getLogDateTime(), stopResult));
                        }
                    }

                }
            }


### 最后

中年危机是真实存在的，即便有技术傍身，还是难免对自己的生存能力产生质疑和焦虑，这些年职业发展，一直在寻求消除焦虑的依靠。

*   技术要深入到什么程度？

*   做久了技术总要转型管理？

*   我能做什么，我想做什么？

*   **一技之长，就是深耕你的专业技能，你的专业技术。**（重点）

*   独立做事，当你的一技之长达到一定深度的时候，需要开始思考如何独立做事。（创业）

*   拥有事业，选择一份使命，带领团队实现它。（创业）

**一技之长分五个层次**

*   栈内技术 - 是指你的前端专业领域技术

*   栈外技术 - 是指栈内技术的上下游，领域外的相关专业知识

*   工程经验 - 是建设专业技术体系的“解决方案”

*   带人做事 - 是对团队协作能力的要求

*   业界发声 - 工作经验总结对外分享，与他人交流



> 永远不要放弃一技之长，它值得你长期`信仰持有`。



> 主要内容包括html，css，html5，css3，JavaScript，正则表达式，函数，BOM，DOM，jQuery，AJAX，vue 等等。

![](https://img-blog.csdnimg.cn/img_convert/44bc3d1e2743a7cf1e94e28026aedf8d.png)