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

最新推荐文章于 2024-07-11 17:37:13 发布

2401_84619287

最新推荐文章于 2024-07-11 17:37:13 发布

阅读量387

点赞数 4

分类专栏：程序员文章标签：前端面试学习

本文链接：https://blog.csdn.net/2401_84619287/article/details/138923039

版权

程序员专栏收录该内容

98 篇文章 0 订阅

订阅专栏

ES6

列举常用的ES6特性：
箭头函数需要注意哪些地方？
let、const、var
拓展：var方式定义的变量有什么样的bug？
Set数据结构
拓展：数组去重的方法
箭头函数this的指向。
手写ES6 class继承。

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

微信小程序

简单描述一下微信小程序的相关文件类型?
你是怎么封装微信小程序的数据请求？
有哪些参数传值的方法？
你使用过哪些方法，来提高微信小程序的应用速度？
小程序和原生App哪个好？
简述微信小程序原理？
分析微信小程序的优劣势
怎么解决小程序的异步请求问题？

其他知识点面试

webpack的原理
webpack的loader和plugin的区别？
怎么使用webpack对项目进行优化?
防抖、节流
浏览器的缓存机制
描述一下二叉树, 并说明二叉树的几种遍历方式?
项目类问题
笔试编程题：

最后

技术栈比较搭，基本用过的东西都是一模一样的。快手终面喜欢问智力题，校招也是终面问智力题，大家要准备一下一些经典智力题。如果排列组合、概率论这些基础忘了，建议回去补一下。

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) {
## ❤️ 谢谢支持

喜欢的话别忘了 关注、点赞哦~。

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0)**

> ![前端校招面试题精编解析大全](https://img-blog.csdnimg.cn/img_convert/43af31d1d5e033bae1f7c84b43f05af0.webp?x-oss-process=image/format,png)
> 









---------", new Object[0]);
                var16 = false;
            } finally {
                if (var16) {
                    // 如果触发器参数不为空
                    if (triggerParam != null) {
## ❤️ 谢谢支持

喜欢的话别忘了 关注、点赞哦~。

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0)**

> [外链图片转存中...(img-sTcgQK9c-1715777401818)]
>

2401_84619287

关注

4
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
docker和K8S环境xxl-job定时任务不执行问题总结_dcoker部署xxljob,无法调用其他服务的定时任务(1)

技术栈比较搭，基本用过的东西都是一模一样的。快手终面喜欢问智力题，校招也是终面问智力题，大家要准备一下一些经典智力题。如果排列组合、概率论这些基础忘了，建议回去补一下。数据库JDBC URL上的设置时区容器内时间设置，这一步要确保宿主机时间的正确ENV TZ=PRCJava应用程序时区问题启动jar包添加参数 -Duser.timezone=GMT+08。
复制链接

扫一扫