xxl-job 源码解析，分布式任务调度xxl-job 线程抽象优化 代码优化 xxl-job如何优化 尝试优化xxl-job. 如果让你优化xxljob，该如何优化呢？（三）

最新推荐文章于 2025-08-01 17:14:30 发布
原创 最新推荐文章于 2025-08-01 17:14:30 发布 · 344 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#分布式 #rocketmq

1. 上文提到，有些地方感觉不是很好，但是又说不上来，今天对比rocket-mq 代码，修改下。二者进行对比，尝试优化一把，xxl-job不是说不好，但是毕竟是16年左右代码，改不动rocketmq xxl 还是改的动的== 哈哈

2. 下方是xxl-job源码的一个helper类 ==> JobFailMonitorHelper

package com.xxl.job.admin.core.thread;

import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
import com.xxl.job.admin.core.model.XxlJobInfo;
import com.xxl.job.admin.core.model.XxlJobLog;
import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
import com.xxl.job.admin.core.util.I18nUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * job monitor instance
 *
 * @author xuxueli 2015-9-1 18:05:56
 */
public class JobFailMonitorHelper {
	private static Logger logger = LoggerFactory.getLogger(JobFailMonitorHelper.class);
	
	private static JobFailMonitorHelper instance = new JobFailMonitorHelper();
	public static JobFailMonitorHelper getInstance(){
		return instance;
	}

	// ---------------------- monitor ----------------------

	private Thread monitorThread;
	private volatile boolean toStop = false;
	public void start(){
		monitorThread = new Thread(new Runnable() {

			@Override
			public void run() {

				// monitor
				while (!toStop) {
					try {

						List<Long> failLogIds = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findFailJobLogIds(1000);
						if (failLogIds!=null && !failLogIds.isEmpty()) {
							for (long failLogId: failLogIds) {

								// lock log
								int lockRet = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId, 0, -1);
								if (lockRet < 1) {
									continue;
								}
								XxlJobLog log = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().load(failLogId);
								XxlJobInfo info = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().loadById(log.getJobId());

								// 1、fail retry monitor
								if (log.getExecutorFailRetryCount() > 0) {
									JobTriggerPoolHelper.trigger(log.getJobId(), TriggerTypeEnum.RETRY, (log.getExecutorFailRetryCount()-1), log.getExecutorShardingParam(), log.getExecutorParam(), null);
									String retryMsg = "<br><br><span style=\"color:#F39C12;\" > >>>>>>>>>>>"+ I18nUtil.getString("jobconf_trigger_type_retry") +"<<<<<<<<<<< </span><br>";
									log.setTriggerMsg(log.getTriggerMsg() + retryMsg);
									XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateTriggerInfo(log);
								}

								// 2、fail alarm monitor
								int newAlarmStatus = 0;		// 告警状态：0-默认、-1=锁定状态、1-无需告警、2-告警成功、3-告警失败
								if (info != null) {
									boolean alarmResult = XxlJobAdminConfig.getAdminConfig().getJobAlarmer().alarm(info, log);
									newAlarmStatus = alarmResult?2:3;
								} else {
									newAlarmStatus = 1;
								}

								XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId, -1, newAlarmStatus);
							}
						}

					} catch (Throwable e) {
						if (!toStop) {
							logger.error(">>>>>>>>>>> xxl-job, job fail monitor thread error:{}", e);
						}
					}

                    try {
                        TimeUnit.SECONDS.sleep(10);
                    } catch (Throwable e) {
                        if (!toStop) {
                            logger.error(e.getMessage(), e);
                        }
                    }

                }

				logger.info(">>>>>>>>>>> xxl-job, job fail monitor thread stop");

			}
		});
		monitorThread.setDaemon(true);
		monitorThread.setName("xxl-job, admin JobFailMonitorHelper");
		monitorThread.start();
	}

	public void toStop(){
		toStop = true;
		// interrupt and wait
		monitorThread.interrupt();
		try {
			monitorThread.join();
		} catch (Throwable e) {
			logger.error(e.getMessage(), e);
		}
	}

}

3. 那如果使用rocketmq的抽象 复写上述逻辑呢：

    3.1 如下代码优点：

                         ==> a. 代码简洁

                        ==> b. 逻辑清晰

package org.apache.rocketmq.remoting.common;

public class TestThread extends ServiceThread{

    @Override
    public String getServiceName() {
        return "[test-thread]";
    }

    @Override
    public void run() {

        while (true) {

            if (isStopped()) {
                break;
            }
            // xxl helper logic
            System.out.println(1);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }

}

      3.2 核心就是ServiceThread:

            3.2.1 我觉得有意思的就是实现runable接口，然后把Runnable 放入抽象类的Thread. 挺妙的，最终在子类实现run方法，写具体逻辑, rocketmq另外一个抽象就是 RequestTask类，也是这个逻辑，感兴趣可以去rocketmq 源码搜索查看！ （貌似nacos 也有相似的抽象，具体忘了是哪里了==！）

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.rocketmq.remoting.common;


import org.apache.rocketmq.common.constant.LoggerName;
import org.apache.rocketmq.logging.org.slf4j.Logger;
import org.apache.rocketmq.logging.org.slf4j.LoggerFactory;

/**
 * Base class for background thread
 */
public abstract class ServiceThread implements Runnable {
    private static final Logger log = LoggerFactory.getLogger(LoggerName.ROCKETMQ_REMOTING_NAME);

    private static final long JOIN_TIME = 90 * 1000;
    protected final Thread thread;
    protected volatile boolean hasNotified = false;
    protected volatile boolean stopped = false;

    public ServiceThread() {
        this.thread = new Thread(this, this.getServiceName());
    }

    public abstract String getServiceName();

    public void start() {
        this.thread.start();
    }

    public void shutdown() {
        this.shutdown(false);
    }

    public void shutdown(final boolean interrupt) {
        this.stopped = true;
        log.info("shutdown thread " + this.getServiceName() + " interrupt " + interrupt);
        synchronized (this) {
            if (!this.hasNotified) {
                this.hasNotified = true;
                this.notify();
            }
        }

        try {
            if (interrupt) {
                this.thread.interrupt();
            }

            long beginTime = System.currentTimeMillis();
            this.thread.join(this.getJointime());
            long elapsedTime = System.currentTimeMillis() - beginTime;
            log.info("join thread " + this.getServiceName() + " elapsed time(ms) " + elapsedTime + " "
                + this.getJointime());
        } catch (InterruptedException e) {
            log.error("Interrupted", e);
        }
    }

    public long getJointime() {
        return JOIN_TIME;
    }

    public boolean isStopped() {
        return stopped;
    }
}

4. 下面就是我写的抽象类，BaseThread:

package com.xxl.job.admin.core.thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public abstract class BaseThread implements Runnable {
    public static Logger logger = LoggerFactory.getLogger(BaseThread.class);

    private static final long JOIN_TIME = 90 * 1000L;
    public Thread defaultThread;
    public volatile boolean toStop = false;

    public BaseThread() {
        defaultThread = new Thread(this, getThreadName());
        defaultThread.setDaemon(true);
    }

    public abstract String getThreadName();

    public void start() {
        defaultThread.start();
    }

    /**
     * 新方法名
     */
    public void shutdown() {
        toStop = true;
        // interrupt and wait
        defaultThread.interrupt();
        try {
            defaultThread.join(JOIN_TIME);
        } catch (Throwable e) {
            logger.error("Interrupted", e);
        }
    }

    /**
     * 适配老代码
     */
    public void toStop() {
        this.shutdown();
    }

}

4.1 改动的JobFailMonitorHelperV2版本：

package com.xxl.job.admin.core.thread;

import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
import com.xxl.job.admin.core.model.XxlJobInfo;
import com.xxl.job.admin.core.model.XxlJobLog;
import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
import com.xxl.job.admin.core.util.I18nUtil;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * job monitor instance
 *
 * @author xuxueli 2015-9-1 18:05:56
 */
public class JobFailMonitorHelperV2 extends BaseThread {

    private static JobFailMonitorHelperV2 instance = new JobFailMonitorHelperV2();

    public static JobFailMonitorHelperV2 getInstance() {
        return instance;
    }

    // ---------------------- monitor ----------------------
    @Override
    public void run() {
        // monitor
        while (!toStop) {
            try {

                List<Long> failLogIds = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findFailJobLogIds(1000);
                if (failLogIds != null && !failLogIds.isEmpty()) {
                    for (long failLogId : failLogIds) {

                        // lock log
                        int lockRet = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId, 0, -1);
                        if (lockRet < 1) {
                            continue;
                        }
                        XxlJobLog log = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().load(failLogId);
                        XxlJobInfo info = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().loadById(log.getJobId());

                        // 1、fail retry monitor
                        if (log.getExecutorFailRetryCount() > 0) {
                            JobTriggerPoolHelper.trigger(log.getJobId(), TriggerTypeEnum.RETRY, (log.getExecutorFailRetryCount() - 1), log.getExecutorShardingParam(), log.getExecutorParam(), null);
                            String retryMsg = "<br><br><span style=\"color:#F39C12;\" > >>>>>>>>>>>" + I18nUtil.getString("jobconf_trigger_type_retry") + "<<<<<<<<<<< </span><br>";
                            log.setTriggerMsg(log.getTriggerMsg() + retryMsg);
                            XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateTriggerInfo(log);
                        }

                        // 2、fail alarm monitor
                        int newAlarmStatus = 0;        // 告警状态：0-默认、-1=锁定状态、1-无需告警、2-告警成功、3-告警失败
                        if (info != null) {
                            boolean alarmResult = XxlJobAdminConfig.getAdminConfig().getJobAlarmer().alarm(info, log);
                            newAlarmStatus = alarmResult ? 2 : 3;
                        } else {
                            newAlarmStatus = 1;
                        }

                        XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId, -1, newAlarmStatus);
                    }
                }

            } catch (Throwable e) {
                if (!toStop) {
                    logger.error(">>>>>>>>>>> xxl-job, job fail monitor thread error:{}", e);
                }
            }

            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (Throwable e) {
                if (!toStop) {
                    logger.error(e.getMessage(), e);
                }
            }

        }

        logger.info(">>>>>>>>>>> xxl-job, job fail monitor thread stop");

    }

    @Override
    public String getThreadName() {
        return "xxl-job, admin JobFailMonitorHelper";
    }

}

 妙不妙？？？

    是否学会了一个新技能？后续在自己的业务，也可以进行复用，对于线程使用的复用。核心能力：对于很多地方都使用到的方法，是可以进行抽象的。高内聚 低耦合

  5. 总结：

               多复用，多思考，对于公用的代码，进行抽象，抽出来！

 抛出问题：上述JobFailMonitorHelperV2代码，run内容还是很多，你是否可以简化下，继续抽离出一个方法？比如 doFailMonitor(); 将他升级到JobFailMonitorHelperV3 ！！！

      作者水平有限，如有错误，欢迎指正！！！感谢阅读到最后==

从零搭建xxl-job(四)：xxljob进行一些性能优化
qq_38482920的博客
08-12 1131
上面的代码就目前来说很简单，因为我的调度中心要去触发定时任务，让定时任务执行了，所有我就又搞了一个触发任务的类，这个类就负责把定时任务的信息向程序内部继续传递下去。其实很简单，就是定时任务方法的名 字。并且，调度任务去执行时，最终会一路调用YyJobTrigger类中的runExecutor方法，在该方法中，会通过http协议，把封装好的定时任务信息的对象发送给定时任务程序，并且——注意里这是是必须要强调清楚的——scheduleThread会等待定时任务程序执行完定时任务后把执行的结果回复过来。
Springboot整合分布式任务调度平台XXL-Job实现定时任务
qq_64734490的博客
11-25 2061
XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。
xxl-job 使用与优化
空明的博客
06-28 934
XXL-JOB 是一款轻量级分布式任务调度平台，具有开发简单、易于扩展的特点。本文介绍了XXL-JOB 2.5.0版本的部署和接入方法。环境要求包括Maven 3+、MySQL 8.0+和JDK 8。
xxl-job源码解读：触发器Trigger
Azhuzhu_chaste的博客
09-14 1669
本文基于xxl-job的2.3.1版本。
分布式定时任务系列7：XXL-job源码分析之任务触发
weigeshikebi的博客
12-13 1425
分布式定时任务系列7：XXL-job源码分-任务触发。
8. xxl-job 原理-- 任务执行或触发
小小鸟的博客
05-30 7680
xxl-job: v2.0.2 原理 目录学习 0. xxl-job原理 1. xxl-job原理—定时任务架构 2. xxl-job原理-- 调度中心 3. xxl-job原理-- 执行器注册 4. xxl-job原理-- 执行器注册问题 5 xxl-job原理-- 执行器注册问题 6. xxl-job 原理-- 调度中心注册 7. xxl-job 原理-- 任务管理 8. xxl-job 原...
分布式任务调度平台 XXL-JOB
꯭ 瞎꯭扯꯭蛋꯭的博客
04-26 1146
任务调度某电商平台需要每天上午10点，下午3点，晚上8点发放一批优惠券某银行系统需要在信用卡到期还款日的前三天进行短信提醒某财务系统需要在每天凌晨0:10分结算前一天的财务数据，统计汇总以上场景就是任务调度所需要解决的问题任务调度是为了自动完成特定任务，在约定的特定时刻去执行任务的过程XXL-Job：是大众点评的分布式任务调度平台，是一个轻量级分布式任务调度平台, 其核心设计目标是开发迅速、学习简单、轻量级、易扩展大众点评目前已接入XXL-JOB，该系统在内部已调度约100万次，表现优异。
深入理解XXL-JOB：打造高可用分布式任务调度
欢迎来到我的博客
08-24 1019
在现代系统架构中，任务调度是一个至关重要的组成部分。无论是电商平台的优惠券发放，银行系统的到期还款提醒，还是财务系统的日常数据结算，任务调度都能帮助我们在指定时间自动完成特定任务。
XXL-JOB调度系统学习、调度流程、spring生命周期
07-23
XXL-JOB是一个分布式任务调度平台，其设计思想是将调度行为抽象成一个独立的“调度中心”，这个中心不承担具体的业务逻辑，而是负责发起调度请求。任务则被抽象为分散的`JobHandler`，由“执行器”来统一管理和执行...
XXL-JOB快速上手
qq_22075913的博客
02-22 688
某电商平台需要每天上午10点，下午3点，晚上8点发放一批优惠券某银行系统需要在信用卡到期还款日的前三天进行短信提醒某财务系统需要在每天凌晨0:10分结算前一天的财务数据，统计汇总以上场景就是任务调度所需要解决的问题视频地址:XXL-JOB资料地址:资料任务调度是为了自动完成特定任务，在约定的特定时刻去执行任务的过程XXL-Job：是大众点评的分布式任务调度平台，是一个轻量级分布式任务调度平台, 其核心设计目标是开发迅速、学习简单、轻量级、易扩展。
03 xxl-job任务执行流程
god_86的专栏
03-10 4615
作业类型xxl-job支持七种作业类型：Bean、GLUE(Java)、GLUE(Shell)、GLUE(Python)、GLUE(PHP)、GLUE(Nodejs)、GLUE(Power...
xxl-job总结 一（调度器任务调用原理）
weixin_43868973的博客
10-26 3462
xxl-job学习总结 一（任务调用原理） 1、通过XxlJobAdminConfig加在配置，属性配置文件配置完成后执行afterPropertiesSet()，执行XxlJobScheduler.init()方法启动相关配置 @Component public class XxlJobAdminConfig implements InitializingBean, DisposableBean { private static XxlJobAdminConfig adminConfig = n
xxl-job源码解析(看这一篇就够了，超简约且详细)
热门推荐
Nuan_Feng的博客
04-12 3万+
服务端启动流程 首先找到配置类 XxlJobAdminConfig 可以发现该类实现 InitializingBean接口，这里直接看 afterPropertiesSet方法即可。 @Override public void afterPropertiesSet() throws Exception { //利用静态声明的只会加载一次的特性，初始化一个单例对象。 adminConfig = this; //初始化xxjob调度器
XXL-JOB原理--任务执行（五）
井底之蛙
09-15 3万+
一、任务调度中心发送任务执行请求 任务发送执行的操作有两种： （1）根据配置的cron表达式周期性执行相关任务 （2）在任务调度中心主动执行任务 在注册quartz定时任务时已经注册执行类为RemoteHttpJobBean，所以周期性执行定时任务会调用RemoteHttpJobBean的executeInternal方法，在executeInternal中会调用JobTriggerPoo...
【xxl-job】源码分析 - 任务触发
Dream it Possible
10-19 1703
【引言】
分布式任务调度框架XXL-JOB解析（三）任务调度
u012791263的专栏
11-25 3323
一、前言 前篇我们跟读了代码，了解调度中心和执行器之间的注册心跳是如何实现的，接下来两篇我们来看看这个框架中非常重要的逻辑——任务的调度和分发是如何实现的。 二、调度中心初始化 在application.properties配置正确的数据库连接信息后，直接启动XxlJobAdminApplication即可。 配置类XxlJobAdminConfig，里面维护了一些调度中心端的配...
Xxl-Job调度器原理解析
Lisam Blog
06-01 4091
项目解析源码地址：https://gitee.com/lidishan/xxl-job-code-analysis xxl-job版本：2.3.0 Xxl-Job分为执行器、调度器。而我们平时的客户端就属于一个执行器，执行器启动的时候会自动注册到调度器上，然后调度器进行远程调度。 调度器初始化过程步骤如下 1 国际化相关 配置参数： xxl.job.i18n=zh_CN,这里设置为中文简体 2 初始化快线程fastTriggerPool、慢线程池slowTr...
ABP VNext + Dapr Workflows：轻量级分布式工作流
最新发布
Kookoos的博客
08-01 933
本文展示了如何在 .NET 9 + ABP 9 应用中，通过一行 AddDaprWorkflow(...) 集成 Dapr Workflows SDK，定义继承自 Workflow<TInput,TOutput> 与 WorkflowActivity<TArg,TResult> 的流程与活动，实现“下单→保留库存→扣款→失败补偿”Saga 场景。涵盖环境依赖、组件注册、工作流编写、触发启动、状态查询、Dapr Dashboard 监控，以及幂等设计、重试策略和生产环境优化等最佳实践。
Java实现的xxl-job分布式任务调度系统源码解析
资源摘要信息:"基于Java的xxl-job分布式任务调度系统设计源码" xxl-job是一个高效的分布式任务调度系统，它是由Java语言开发的，拥有301个文件，其中包括Java源文件、图片文件、JavaScript文件、XML文件、CSS文件、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值