任务调度的详细原理主要包括以下几个步骤:
- 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)