xxl-job 调度成功却不执行的问题记录

已于 2022-08-28 22:35:18 修改
阅读量1.5w 收藏 28
点赞数 4
文章标签： java spring jvm
于 2022-08-28 21:27:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44760538/article/details/126574203
版权
一.问题 描述

使用xxl-job 日志显示调度成功，但执行器就是没有执行，且没有结果回调，日志如下图。
在这里插入图片描述

二.排查原因

查看xxl-job客户端(执行器)中的源代码JobThread，发现调度和任务执行依靠队列 triggerQueue，这个是参数队列，调度直接往这个队列里面put参数对象。执行依靠是JobThread run方法，从队列中获取参数对象，能获取就执行，任务和线程是一一绑定的关系，调度成功，但没有结果回调。可以发现任务卡在执行任务当中handler.execute();

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.context.XxlJobHelper;
import com.xxl.job.core.executor.XxlJobExecutor;
import com.xxl.job.core.handler.IJobHandler;
import com.xxl.job.core.log.XxlJobFileAppender;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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.*;


/**
 * handler thread
 * @author xuxueli 2016-1-16 19:52:47
 */
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;		// avoid repeat trigger for the same TRIGGER_LOG_ID

	private volatile boolean toStop = false;
	private String stopReason;

    private boolean running = false;    // if running job
	private int idleTimes = 0;			// idel times


	public JobThread(int jobId, IJobHandler handler) {
		this.jobId = jobId;
		this.handler = handler;
		this.triggerQueue = new LinkedBlockingQueue<TriggerParam>();
		this.triggerLogIdSet = Collections.synchronizedSet(new HashSet<Long>());
	}
	public IJobHandler getHandler() {
		return handler;
	}

    /**
     * new trigger to queue
     *
     * @param triggerParam
     * @return
     */
	public ReturnT<String> pushTriggerQueue(TriggerParam triggerParam) {
		// avoid repeat
		if (triggerLogIdSet.contains(triggerParam.getLogId())) {
			logger.info(">>>>>>>>>>> repeate trigger job, logId:{}", triggerParam.getLogId());
			return new ReturnT<String>(ReturnT.FAIL_CODE, "repeate trigger job, logId:" + triggerParam.getLogId());
		}

		triggerLogIdSet.add(triggerParam.getLogId());
		triggerQueue.add(triggerParam);
        return ReturnT.SUCCESS;
	}

    /**
     * kill job thread
     *
     * @param stopReason
     */
	public void toStop(String stopReason) {
		/**
		 * Thread.interrupt只支持终止线程的阻塞状态(wait、join、sleep)，
		 * 在阻塞出抛出InterruptedException异常,但是并不会终止运行的线程本身；
		 * 所以需要注意，此处彻底销毁本线程，需要通过共享变量方式；
		 */
		this.toStop = true;
		this.stopReason = stopReason;
	}

    /**
     * is running job
     * @return
     */
    public boolean isRunningOrHasQueue() {
        return running || triggerQueue.size()>0;
    }

    @Override
	public void run() {

    	// init
    	try {
			handler.init();
		} catch (Throwable e) {
    		logger.error(e.getMessage(), e);
		}

		// execute
		while(!toStop){
			running = false;
			idleTimes++;

            TriggerParam triggerParam = null;
            try {
				// to check toStop signal, we need cycle, so wo cannot use queue.take(), instand of poll(timeout)
				//任务队列，triggerParam是任务参数，调度是直接往这个队列put参数对象 
				triggerParam = triggerQueue.poll(3L, TimeUnit.SECONDS);
				if (triggerParam!=null) {
					running = true;
					idleTimes = 0;
					triggerLogIdSet.remove(triggerParam.getLogId());

					// log filename, like "logPath/yyyy-MM-dd/9999.log"
					String logFileName = XxlJobFileAppender.makeLogFileName(new Date(triggerParam.getLogDateTime()), triggerParam.getLogId());
					XxlJobContext xxlJobContext = new XxlJobContext(
							triggerParam.getJobId(),
							triggerParam.getExecutorParams(),
							logFileName,
							triggerParam.getBroadcastIndex(),
							triggerParam.getBroadcastTotal());

					// init job context
					XxlJobContext.setXxlJobContext(xxlJobContext);

					// execute
					XxlJobHelper.log("<br>----------- xxl-job job execute start -----------<br>----------- Param:" + xxlJobContext.getJobParam());

					if (triggerParam.getExecutorTimeout() > 0) {
						// limit timeout
						Thread futureThread = null;
						try {
							FutureTask<Boolean> futureTask = new FutureTask<Boolean>(new Callable<Boolean>() {
								@Override
								public Boolean call() throws Exception {

									// init job context
									XxlJobContext.setXxlJobContext(xxlJobContext);

									handler.execute();
									return true;
								}
							});
							futureThread = new Thread(futureTask);
							futureThread.start();

							Boolean tempResult = futureTask.get(triggerParam.getExecutorTimeout(), TimeUnit.SECONDS);
						} catch (TimeoutException e) {

							XxlJobHelper.log("<br>----------- xxl-job job execute timeout");
							XxlJobHelper.log(e);

							// handle result
							XxlJobHelper.handleTimeout("job execute timeout ");
						} finally {
							futureThread.interrupt();
						}
					} else {
						// 执行任务 handler是要执行的方法，也就是@XxlJob注解中的执行方法
						//可以发现一个任务在一个执行器当中是对应着唯一一个线程去执行
						handler.execute();
					}

					// valid execute handle data
					if (XxlJobContext.getXxlJobContext().getHandleCode() <= 0) {
						XxlJobHelper.handleFail("job handle result lost.");
					} else {
						String tempHandleMsg = XxlJobContext.getXxlJobContext().getHandleMsg();
						tempHandleMsg = (tempHandleMsg!=null&&tempHandleMsg.length()>50000)
								?tempHandleMsg.substring(0, 50000).concat("...")
								:tempHandleMsg;
						XxlJobContext.getXxlJobContext().setHandleMsg(tempHandleMsg);
					}
					XxlJobHelper.log("<br>----------- xxl-job job execute end(finish) -----------<br>----------- Result: handleCode="
							+ XxlJobContext.getXxlJobContext().getHandleCode()
							+ ", handleMsg = "
							+ XxlJobContext.getXxlJobContext().getHandleMsg()
					);

				} else {
					if (idleTimes > 30) {
						if(triggerQueue.size() == 0) {	// avoid concurrent trigger causes jobId-lost
							XxlJobExecutor.removeJobThread(jobId, "excutor idel times over limit.");
						}
					}
				}
			} catch (Throwable e) {
				if (toStop) {
					XxlJobHelper.log("<br>----------- JobThread toStop, stopReason:" + stopReason);
				}

				// handle result
				StringWriter stringWriter = new StringWriter();
				e.printStackTrace(new PrintWriter(stringWriter));
				String errorMsg = stringWriter.toString();

				XxlJobHelper.handleFail(errorMsg);

				XxlJobHelper.log("<br>----------- JobThread Exception:" + errorMsg + "<br>----------- xxl-job job execute end(error) -----------");
			} finally {
                if(triggerParam != null) {
                    // callback handler info
                    if (!toStop) {
                        // 结果回调
                        TriggerCallbackThread.pushCallBack(new HandleCallbackParam(
                        		triggerParam.getLogId(),
								triggerParam.getLogDateTime(),
								XxlJobContext.getXxlJobContext().getHandleCode(),
								XxlJobContext.getXxlJobContext().getHandleMsg() )
						);
                    } else {
                         // 结果回调
                        TriggerCallbackThread.pushCallBack(new HandleCallbackParam(
                        		triggerParam.getLogId(),
								triggerParam.getLogDateTime(),
								XxlJobContext.HANDLE_COCE_FAIL,
								stopReason + " [job running, killed]" )
						);
                    }
                }
            }
        }

		// callback trigger request in queue
		while(triggerQueue !=null && triggerQueue.size()>0){
			TriggerParam triggerParam = triggerQueue.poll();
			if (triggerParam!=null) {
				// is killed
				TriggerCallbackThread.pushCallBack(new HandleCallbackParam(
						triggerParam.getLogId(),
						triggerParam.getLogDateTime(),
						XxlJobContext.HANDLE_COCE_FAIL,
						stopReason + " [job not executed, in the job queue, killed.]")
				);
			}
		}

		// destroy
		try {
			handler.destroy();
		} catch (Throwable e) {
			logger.error(e.getMessage(), e);
		}

		logger.info(">>>>>>>>>>> xxl-job JobThread stoped, hashCode:{}", Thread.currentThread());
	}
}

看看执行器中的代码，没有发现问题，问题也没法线下复现。我猜测是这个方法线程阻塞了，或者线程挂掉了。

	@XxlJob("liveStatusTask")
	public void liveStatusTask() {
		List<LiveStatusVO> ids = tchLiveService.getNotStartAndLivingLiveIds();
		if (CollectionUtil.isEmpty(ids)) {
			return;
		}
		Map<Integer, Integer> map = ids.stream().collect(Collectors.toMap(LiveStatusVO::getLiveId, LiveStatusVO::getStatus));
		//这里是远程调用其他项目api使用的httpClient工具
		List<LiveVO> vos = ctydLiveService.listLiveVO(ids.stream().map(LiveStatusVO::getLiveId).collect(Collectors.toList()));
		Map<Integer, Integer> idMap = ids.stream().collect(Collectors.toMap(LiveStatusVO::getLiveId, LiveStatusVO::getId));
		vos.forEach(vo -> {
			if (Objects.equals(map.get(vo.getLiveId()), vo.getStatus())) {
				return;
			}
			log.info("status:{} liveId:{}", vo.getStatus(), vo.getLiveId());
			LambdaUpdateWrapper<TchLive> updateWrapper = Wrappers.lambdaUpdate(TchLive.class)
					.in(TchLive::getLiveId, vo.getLiveId())
					.eq(TchLive::getDelFlag, DelFlagEnum.NORMAL)
					.set(TchLive::getStatus, vo.getStatus())
					.set(!Objects.isNull(vo.getStartTime()), TchLive::getStartTime, vo.getStartTime())
					.set(!Objects.isNull(vo.getEndTime()), TchLive::getEndTime, vo.getEndTime());
			if (ObjectUtil.isAllNotEmpty(vo.getStartTime(), vo.getEndTime())) {
				long timeLength = (vo.getEndTime() - vo.getStartTime()) / 1000 / 60;
				updateWrapper.set(TchLive::getTimeLength, (int) timeLength);
			}
			tchLiveService.update(updateWrapper);
			if (Objects.equals(vo.getStatus(), LiveStatusEnum.CLOSED.getValue())) {
				tchLiveStudentService.updateOnlineTime(vo.getLiveId(), idMap.get(vo.getLiveId()));
			}
		});
		}
	}

使用 jstack 1147643(进程id),查看jvm中的线程情况，找到了其执行线程，发现就是阻塞到ctydLiveService.listLiveVO中使用httpClient中没有设置超时时间导致线程阻塞了，网上搜索at java.net.SocketInputStream.socketRead0(Native Method)还是有很多类似问题，致此找到了原因。

"Thread-34" #2044 prio=10 os_prio=0 tid=0x00007f4474010800 nid=0x124ace runnable [0x00007f44649e1000]
   java.lang.Thread.State: RUNNABLE
        at java.net.SocketInputStream.socketRead0(Native Method)
        at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
        at java.net.SocketInputStream.read(SocketInputStream.java:171)
        at java.net.SocketInputStream.read(SocketInputStream.java:141)
        at org.apache.http.impl.io.SessionInputBufferImpl.streamRead(SessionInputBufferImpl.java:137)
        at org.apache.http.impl.io.SessionInputBufferImpl.fillBuffer(SessionInputBufferImpl.java:153)
        at org.apache.http.impl.io.SessionInputBufferImpl.readLine(SessionInputBufferImpl.java:280)
        at org.apache.http.impl.conn.DefaultHttpResponseParser.parseHead(DefaultHttpResponseParser.java:138)
        at org.apache.http.impl.conn.DefaultHttpResponseParser.parseHead(DefaultHttpResponseParser.java:56)
        at org.apache.http.impl.io.AbstractMessageParser.parse(AbstractMessageParser.java:259)
        at org.apache.http.impl.DefaultBHttpClientConnection.receiveResponseHeader(DefaultBHttpClientConnection.java:163)
        at org.apache.http.impl.conn.CPoolProxy.receiveResponseHeader(CPoolProxy.java:157)
        at org.apache.http.protocol.HttpRequestExecutor.doReceiveResponse(HttpRequestExecutor.java:273)
        at org.apache.http.protocol.HttpRequestExecutor.execute(HttpRequestExecutor.java:125)
        at org.apache.http.impl.execchain.MainClientExec.execute(MainClientExec.java:272)
        at org.apache.http.impl.execchain.ProtocolExec.execute(ProtocolExec.java:186)
        at org.apache.http.impl.execchain.RetryExec.execute(RetryExec.java:89)
        at org.apache.http.impl.execchain.RedirectExec.execute(RedirectExec.java:110)
        at org.apache.http.impl.client.InternalHttpClient.doExecute(InternalHttpClient.java:185)
        at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:72)
        at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:221)
        at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:165)
        at org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:140)
        at com.yunduan.ykxt.common.core.util.HttpClientUtil.doGet(HttpClientUtil.java:416)
        at com.yunduan.ykxt.manage.external.ctydcourseware.CtydLiveClient.listLiveVO(CtydLiveClient.java:86)
        at com.yunduan.ykxt.manage.external.ctydcourseware.service.impl.CtydLiveServiceImpl.listLiveVO(CtydLiveServiceImpl.java:68)
        at com.yunduan.ykxt.manage.jobs.JobsService.liveStatusTask(JobsService.java:97)
        at sun.reflect.GeneratedMethodAccessor3154.invoke(Unknown Source)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:498)
        at com.xxl.job.core.handler.impl.MethodJobHandler.execute(MethodJobHandler.java:31)
        at com.xxl.job.core.thread.JobThread.run(JobThread.java:163)

前面可以知道是执行线程阻塞了，一直阻塞的话，时间够长是可以导致OOM错误的，应为调度一直往队列里面丢任务。却没有线程去消费掉。用命令:jmap -histo 1147643 | grep “com.xxl.job.core.biz.model”
查看一下有多少个任务实例，有积压了50906任务。
在这里插入图片描述

解决以及优化方案

一.设置超时时间
二.创建线程池去执行xxl-job的任务，万一有一个线程被阻塞住了不影响整体的任务执行。
注意：使用线程池的时候，使用XxlJobHelper.log记录日志的时候会出现问题，要对记录日志方法进行修改。

程序员螃蟹
关注
【异常】为啥我的XXL-JOB的定时任务会执行失败？
本本本添哥
06-12 308
业务反馈，报表部分日期没有数据，这个数据是通过定时任务生成的，这个会让业务连续性降低横展其他日期，4月份一次执行失败，5月份一次执行失败，都是周日，报错都是一样的，500状态码。看XXL-job的执行日志，可以看到定时任务执行报错，报错如下，但是在ELK没有看到对应的日志。
docker和K8S环境xxl-job定时任务不执行问题总结
日拱一卒无有尽，功不唐捐终入海
10-24 3472
xxl-job 任务不执行，或者执行异常问题整理归纳
xxjob调度成功任务无响应问题
weixin_44770756的博客
03-09 2461
到这里就基本可以确定我们问题出现的原因，应为我的job任务中会有访问其他网址进行检查的情况，其中某一个网址访问的时候会一直等待，这就导致我的任务会一直阻塞，而job又是一分钟执行一次，就出现了大量的任务往队列中写，但是没有线程去消费掉。这里的结果之前是空的，应为我把服务下线之后，xxJob就找不到服务了，所以就会变成失败，通过日志还是可以看到是没有任何报错信息的。我们可以在控制台中设置超时时间，这样我们就不会有很多一直在等待执行中的任务了，就不会去创建大量的任务，导致我们的线程阻塞了。
xxl-job定时任务执行日志部分“消失”
最新发布
trtrtg的专栏
07-31 298
XXJobTrigger方法执行与外层的调用者XXJobScheduleHelper调度器的scheduleUpdate方法（更新调度状态）不在一个线程、一个事务里面，导致内层的loadId报错了，业务还未执行，但调度状态确已持久化，调度状态决定了下次执行时间。其次，通过查看数据库xxl-job执行日志，发现132处理了大部分任务，131承担了小部分任务，而18日的10:30定时任务轮给131执行，排除压力问题导致131执行异常。进而怀疑131执行少的原因依旧是大量的“连接不可用”异常导致；
xxl-job 执行程序没有反馈
wgl04193410的博客
07-03 2205
昨天电脑重装了以后，发现同样的配置xxl-job始终执行不了 后面发现是防火墙的问题，加了一个入站规则就解决了记录下
踩坑Xxljob本地部署后调度一半成功一半失败原因分析及解决方案记录
slipperySoap的博客
12-11 2881
踩坑xxljob本地部署，出现一半调度成功，一半调度失败现象，具体分析原因以及给出解决方案
xxl-job任务调度成功，但是执行结果失败问题
热门推荐
alwaysRise的博客
05-27 2万+
xxl-job任务调度成功，但是执行结果失败问题 在跟着知乎上面的一个大佬入门xxl-job的时候，发现了一个小坑 文章链接（https://zhuanlan.zhihu.com/p/263051022）这篇文章基本能带你入门xxl-job了， 如果有能力直接去GitHub上面看教程也非常详细。（https://www.xuxueli.com/xxl-job/#5.8%20%E4%BB%BB%E5%8A%A1%E6%89%A7%E8%A1%8C%E7%BB%93%E6%9E%9C） 以下是该文章的demo的
使用xxl-job踩的坑，调度成功，执行失败
imning1的博客
03-08 1万+
调度日志返回结果为200. 执行日志返回结果为500，然后代码 中明明返回的是200.其实程序是执行成功了。 最后发现是因为不知什么时候鬼使神差的在job类上加了个@Async注解
docker和K8S环境xxl-job定时任务不执行问题总结_dcoker部署xxljob,无法调用其他服务的定时任务(1)
2401_84619287的博客
05-15 438
技术栈比较搭，基本用过的东西都是一模一样的。快手终面喜欢问智力题，校招也是终面问智力题，大家要准备一下一些经典智力题。如果排列组合、概率论这些基础忘了，建议回去补一下。数据库JDBC URL上的设置时区容器内时间设置，这一步要确保宿主机时间的正确ENV TZ=PRCJava应用程序时区问题启动jar包添加参数 -Duser.timezone=GMT+08。
Xxl-Job定时任务调度失败的排查与解决
Azir_的博客
02-26 3413
一次线上定时任务调度失败原因的排查，一步步地从调度中心到执行器，再到K8S中的Istio进行问题的排查。
xxl-job调度日志一直显示失败
qq_35866291的博客
04-09 1675
xxl-job 容器 映射 手动注册
解决k8s中xxl-job执行器pod重建后无法读取到执行日志的问题
08-24
xxl-job-admin读取执行日志的逻辑为：向执行了该任务的执行器发送请求，让执行器从本地读取执行日志。但在k8s中，即使将本地文件通过nfs独立存储，在pod重建后也通常会因为ip变更，找不到执行器，导致读取不到执行...
XXL-JOB分布式任务调度系统培训PPT
08-09
同时，XXL-JOB 也提供了任务流程图、任务执行记录、任务执行详情等功能，方便用户快速了解任务的执行情况。 XXL-JOB 的使用场景非常广泛，如每天凌晨 1 点跑批、每月 1 号进行上个月清算、电商整点抢购、商品价格 8...
xxl-job适配达梦数据库
02-02
XXL-JOB由两部分组成：调度中心（XXL-JOB-Scheduler）和执行器（XXL-JOB-Executor）。调度中心负责任务的调度策略配置、触发以及监控，而执行器则执行实际的任务逻辑。在适配达梦数据库之前，XXL-JOB通常默认使用...
分布式调度xxl-job
01-17
* XXLJob2.3：XXL-Job支持XXLJob2.3版本。 知识点四：XXL-Job的学习.form * 视频讲解：XXL-Job的学习形式包括视频讲解。 * 文字笔记：XXL-Job的学习形式包括文字笔记。 * 原理分析：XXL-Job的学习形式包括原理分析...
分布式调度任务XXL-JOB架构图
02-11
分布式调度任务XXL-JOB架构图是一种基于quartz调度器的分布式任务调度框架，旨在解决大规模任务的调度和执行问题。下面是该架构图中的关键知识点： 1. 分布式调度中心：XXL-JOB架构图的核心组件是分布式调度中心，...
3千字带你搞懂XXL-JOB任务调度平台
yehongzhi1994的博客
10-06 1746
什么是任务调度平台？为什么选择XXL-JOB？如何搭建XXL-JOB？看这篇文章你就懂了！
docker和K8S环境xxl-job定时任务不执行问题总结_dcoker部署xxljob,无法调用其他服务的定时任务(3)
2401_84619342的博客
05-15 899
小编的一位同事在校期间连续三年参加ACM-ICPC竞赛。从参赛开始，原计划每天刷一道算法题，实际上每天有时候不止一题，一年最终完成了 600+：凭借三年刷题经验，他在校招中很快拿到了各大公司的offer。入职前，他把他的刷题经验总结成1121页PDF书籍，作为礼物赠送给他的学弟学妹，希望同学们都能在最短时间内掌握校招常见的算法及解题思路。整本书，我仔细看了一遍，作者非常细心地将常见核心算法题和汇总题拆分为4个章节。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】
xxljob 获取执行时间
09-22
xxl-job是一个用于执行定时任务的框架，可以通过编写cron表达式来指定任务的执行时间。在xxl_job_info表中，schedule_conf字段用于存储cron表达式，而trigger_next_time字段则是下次执行任务的时间。为了将下次执行时间更新到xxl-job的执行日志中，你可以将trigger_next_time转换为时间戳格式，并更新到相应的字段中。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值