XXL-JOB之任务调度全流程分析

最新推荐文章于 2025-02-26 09:26:25 发布
最新推荐文章于 2025-02-26 09:26:25 发布
阅读量1.1k 收藏
点赞数
分类专栏： xxl-job 文章标签： java 架构 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/renkeyutian/article/details/131633040
版权
文章分析了XXL-JOB任务调度系统的全流程，包括调度器如何定时查询任务并使用线程池执行，执行器的选择策略，以及任务执行的细节。通过JobTriggerPoolHelper触发任务，根据任务执行时间选择快速或慢速线程池。执行过程中，任务和线程一一对应，使用生产者-消费者模型处理任务。此外，文章还讨论了任务执行的隔离和执行器的动态更新机制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概要

        本次主要分析任务调度的全流程

整体架构流程

        调度器，即服务端会定时查询5秒内的任务，然后请求客户端的netty服务器执行对应的JobHandler，其实质就是一个方法调用。执行器执行完之后，将结果反馈给调度器。如果有回调需要处理的，会调用调度器的回调方法进行处理。其中，任务查询这块，会用到自定义的时间轮。具体逻辑，之前在《XXL-JOB之服务端启动流程分析》中讲解过。下面主要分析一下，从任务调度到完成，这整个过程，具体做了哪些事。

技术细节

        调度器对任务进行调度，是通过JobTriggerPoolHelper#trigger这个方法处理的：

         默认使用快线程池进行执行。如果该任务在执行过程中，执行时间超过了500ms，就记录一下，达到10次之后，后面再执行这个任务，就使用慢线程池执行。这样做的好处是，将执行快的任务和执行慢的任务进行隔离，避免慢任务占用线程资源，拖慢执行快的任务。

        进一步调用XxlJobTrigger#trigger：

         获取任务的信息，任务的地址，重试次数，分片信息等。进到processTrigger方法：

   private static void processTrigger(XxlJobGroup group, XxlJobInfo jobInfo, int finalFailRetryCount, TriggerTypeEnum triggerType, int index, int total){

        // param
        ExecutorBlockStrategyEnum blockStrategy = ExecutorBlockStrategyEnum.match(jobInfo.getExecutorBlockStrategy(), ExecutorBlockStrategyEnum.SERIAL_EXECUTION);  // block strategy
        ExecutorRouteStrategyEnum executorRouteStrategyEnum = ExecutorRouteStrategyEnum.match(jobInfo.getExecutorRouteStrategy(), null);    // route strategy
        String shardingParam = (ExecutorRouteStrategyEnum.SHARDING_BROADCAST==executorRouteStrategyEnum)?String.valueOf(index).concat("/").concat(String.valueOf(total)):null;
        // 1、save log-id
        XxlJobLog jobLog = new XxlJobLog();
        jobLog.setJobGroup(jobInfo.getJobGroup());
        jobLog.setJobId(jobInfo.getId());
        jobLog.setTriggerTime(new Date());
        XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().save(jobLog);
        logger.debug(">>>>>>>>>>> xxl-job trigger start, jobId:{}", jobLog.getId());
        // 2、init trigger-param
        TriggerParam triggerParam = new TriggerParam();
        triggerParam.setJobId(jobInfo.getId());
        triggerParam.setExecutorHandler(jobInfo.getExecutorHandler());
        triggerParam.setExecutorParams(jobInfo.getExecutorParam());
        triggerParam.setExecutorBlockStrategy(jobInfo.getExecutorBlockStrategy());
        triggerParam.setExecutorTimeout(jobInfo.getExecutorTimeout());
        triggerParam.setLogId(jobLog.getId());
        triggerParam.setLogDateTime(jobLog.getTriggerTime().getTime());
        triggerParam.setGlueType(jobInfo.getGlueType());
        triggerParam.setGlueSource(jobInfo.getGlueSource());
        triggerParam.setGlueUpdatetime(jobInfo.getGlueUpdatetime().getTime());
        triggerParam.setBroadcastIndex(index);
        triggerParam.setBroadcastTotal(total);
        // 3、init address
        String address = null;
        ReturnT<String> routeAddressResult = null;
        if (group.getRegistryList()!=null && !group.getRegistryList().isEmpty()) {
            if (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == executorRouteStrategyEnum) {
                if (index < group.getRegistryList().size()) {
                    address = group.getRegistryList().get(index);
                } else {
                    address = group.getRegistryList().get(0);
                }
            } else {
                routeAddressResult = executorRouteStrategyEnum.getRouter().route(triggerParam, group.getRegistryList());
                if (routeAddressResult.getCode() == ReturnT.SUCCESS_CODE) {
                    address = routeAddressResult.getContent();
                }
            }
        } else {
            routeAddressResult = new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("jobconf_trigger_address_empty"));
        }

        // 4、trigger remote executor
        ReturnT<String> triggerResult = null;
        if (address != null) {
            triggerResult = runExecutor(triggerParam, address);
        } else {
            triggerResult = new ReturnT<String>(ReturnT.FAIL_CODE, null);
        }

        // 5、collection trigger info
        StringBuffer triggerMsgSb = new StringBuffer();
        triggerMsgSb.append(I18nUtil.getString("jobconf_trigger_type")).append("：").append(triggerType.getTitle());
        triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_admin_adress")).append("：").append(IpUtil.getIp());
        triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_exe_regtype")).append("：")
                .append( (group.getAddressType() == 0)?I18nUtil.getString("jobgroup_field_addressType_0"):I18nUtil.getString("jobgroup_field_addressType_1") );
        triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_exe_regaddress")).append("：").append(group.getRegistryList());
        triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorRouteStrategy")).append("：").append(executorRouteStrategyEnum.getTitle());
        if (shardingParam != null) {
            triggerMsgSb.append("("+shardingParam+")");
        }
        triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorBlockStrategy")).append("：").append(blockStrategy.getTitle());
        triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_timeout")).append("：").append(jobInfo.getExecutorTimeout());
        triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorFailRetryCount")).append("：").append(finalFailRetryCount);

        triggerMsgSb.append("<br><br><span style=\"color:#00c0ef;\" > >>>>>>>>>>>"+ I18nUtil.getString("jobconf_trigger_run") +"<<<<<<<<<<< </span><br>")
                .append((routeAddressResult!=null&&routeAddressResult.getMsg()!=null)?routeAddressResult.getMsg()+"<br><br>":"").append(triggerResult.getMsg()!=null?triggerResult.getMsg():"");

        // 6、save log trigger-info
        jobLog.setExecutorAddress(address);
        jobLog.setExecutorHandler(jobInfo.getExecutorHandler());
        jobLog.setExecutorParam(jobInfo.getExecutorParam());
        jobLog.setExecutorShardingParam(shardingParam);
        jobLog.setExecutorFailRetryCount(finalFailRetryCount);
        //jobLog.setTriggerTime();
        jobLog.setTriggerCode(triggerResult.getCode());
        jobLog.setTriggerMsg(triggerMsgSb.toString());
        XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateTriggerInfo(jobLog);

        logger.debug(">>>>>>>>>>> xxl-job trigger end, jobId:{}", jobLog.getId());
    }

        再次封装了执行参数，获取执行器地址，并记录日志。主要逻辑在 runExecutor：

         这里主要逻辑是将，执行器的地址 和token封装成一个ExecutorBiz，并且进行了缓存。那么ExecutorBiz是做什么的呢？它其实就是一个用来调用客户端netty服务器的工具类：

        下面是客户端netty构建的api，我们对比着看看：

         从而我们知道，调度器触发任务执行，最终调用的是/run这个api，在ExecutorBizImpl#run中

public ReturnT<String> run(TriggerParam triggerParam) {
        // load old：jobHandler + jobThread
        JobThread jobThread = XxlJobExecutor.loadJobThread(triggerParam.getJobId());
        IJobHandler jobHandler = jobThread!=null?jobThread.getHandler():null;
        String removeOldReason = null;
        // valid：jobHandler + jobThread
        GlueTypeEnum glueTypeEnum = GlueTypeEnum.match(triggerParam.getGlueType());
        if (GlueTypeEnum.BEAN == glueTypeEnum) {
            // new jobhandler
            IJobHandler newJobHandler = XxlJobExecutor.loadJobHandler(triggerParam.getExecutorHandler());
            // valid old jobThread
            if (jobThread!=null && jobHandler != newJobHandler) {
                // change handler, need kill old thread
                removeOldReason = "change jobhandler or glue type, and terminate the old job thread.";
                jobThread = null;
                jobHandler = null;
            }
            // valid handler
            if (jobHandler == null) {
                jobHandler = newJobHandler;
                if (jobHandler == null) {
                    return new ReturnT<String>(ReturnT.FAIL_CODE, "job handler [" + triggerParam.getExecutorHandler() + "] not found.");
                }
            }

        } else if (GlueTypeEnum.GLUE_GROOVY == glueTypeEnum) {
            // valid old jobThread
            if (jobThread != null &&
                    !(jobThread.getHandler() instanceof GlueJobHandler
                        && ((GlueJobHandler) jobThread.getHandler()).getGlueUpdatetime()==triggerParam.getGlueUpdatetime() )) {
                // change handler or gluesource updated, need kill old thread
                removeOldReason = "change job source or glue type, and terminate the old job thread.";

                jobThread = null;
                jobHandler = null;
            }
            // valid handler
            if (jobHandler == null) {
                try {
                    IJobHandler originJobHandler = GlueFactory.getInstance().loadNewInstance(triggerParam.getGlueSource());
                    jobHandler = new GlueJobHandler(originJobHandler, triggerParam.getGlueUpdatetime());
                } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                    return new ReturnT<String>(ReturnT.FAIL_CODE, e.getMessage());
                }
            }
        } else if (glueTypeEnum!=null && glueTypeEnum.isScript()) {

            // valid old jobThread
            if (jobThread != null &&
                    !(jobThread.getHandler() instanceof ScriptJobHandler
                            && ((ScriptJobHandler) jobThread.getHandler()).getGlueUpdatetime()==triggerParam.getGlueUpdatetime() )) {
                // change script or gluesource updated, need kill old thread
                removeOldReason = "change job source or glue type, and terminate the old job thread.";

                jobThread = null;
                jobHandler = null;
            }

            // valid handler
            if (jobHandler == null) {
                jobHandler = new ScriptJobHandler(triggerParam.getJobId(), triggerParam.getGlueUpdatetime(), triggerParam.getGlueSource(), GlueTypeEnum.match(triggerParam.getGlueType()));
            }
        } else {
            return new ReturnT<String>(ReturnT.FAIL_CODE, "glueType[" + triggerParam.getGlueType() + "] is not valid.");
        }
        // executor block strategy
        if (jobThread != null) {
            ExecutorBlockStrategyEnum blockStrategy = ExecutorBlockStrategyEnum.match(triggerParam.getExecutorBlockStrategy(), null);
            if (ExecutorBlockStrategyEnum.DISCARD_LATER == blockStrategy) {
                // discard when running
                if (jobThread.isRunningOrHasQueue()) {
                    return new ReturnT<String>(ReturnT.FAIL_CODE, "block strategy effect："+ExecutorBlockStrategyEnum.DISCARD_LATER.getTitle());
                }
            } else if (ExecutorBlockStrategyEnum.COVER_EARLY == blockStrategy) {
                // kill running jobThread
                if (jobThread.isRunningOrHasQueue()) {
                    removeOldReason = "block strategy effect：" + ExecutorBlockStrategyEnum.COVER_EARLY.getTitle();
                    jobThread = null;
                }
            } else {
                // just queue trigger
            }
        }
        // replace thread (new or exists invalid)
        if (jobThread == null) {
            jobThread = XxlJobExecutor.registJobThread(triggerParam.getJobId(), jobHandler, removeOldReason);
        }
        // push data to queue
        ReturnT<String> pushResult = jobThread.pushTriggerQueue(triggerParam);
        return pushResult;
    }

        1、第一次执行的时候，会将任务id、任务对应执行的执行器和一个线程进行绑定，并且以任务id作为key进行了缓存；

       2、下次再执行的时候，直接从缓存中通过任务id，获取一个线程进行任务的处理。从而可以看出，有多少个任务，就会产生多少个线程。这里为啥不使用线程池处理？我的理解：①线程池的初始化指标不太好指定，线程数少了，容易产生任务堆积，从而发生阻塞。多了又浪费资源；②线程池没法做到隔离。每个任务的执行时间是不一样的，执行慢的任务，会长久占用线程资源，影响其他任务的执行。

        3、作者的做法是，一个任务分配一个线程，一个线程配置个队列。并且也会将线程和任务id进行绑定之后，缓存起来，方便根据任务id查找对应处理的线程。这其实也运用了线程池化的思想。任务的执行相互隔离，也便于进行个性化处理。上面代码中还有一个细节：IJobHandler newJobHandler = XxlJobExecutor.loadJobHandler(triggerParam.getExecutorHandler());每次都会重新查一下，这是为什么？我们分析过，客户端在启动时，会找到所有的执行器，并以执行器的名字作为key，缓存在map中，这里的loadJobHandler就是根据名字从缓存中找到对应的执行器。那什么情况下，线程中绑定的执行器和初始化时缓存的执行器会不一样呢？只有一种场景，就是在可视化界面改了执行器的名字，相当于改了任务绑定的执行器的名字。那么又会出现2种情况：如果新名字可以在初始化缓存中找到对应的执行器，就将原来绑定的线程终止掉，然后生成一个新的线程，重新绑定任务id和执行器，后面的任务就都用新的执行器执行了；如果找不到，就直接返回执行错误，并记录日志。找不到执行器这种情况，应该是客户端没有进行重启导致的。

        4、任务的执行，就是向任务对应线程配置的队列里面丢任务，线程再从自己的队列里面获取任务执行，典型的生产者-消费者模型：

	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 = 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 {
						// just execute
						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) {
                        // commonm
                        TriggerCallbackThread.pushCallBack(new HandleCallbackParam(
                        		triggerParam.getLogId(),
								triggerParam.getLogDateTime(),
								XxlJobContext.getXxlJobContext().getHandleCode(),
								XxlJobContext.getXxlJobContext().getHandleMsg() )
						);
                    } else {
                        // is killed
                        TriggerCallbackThread.pushCallBack(new HandleCallbackParam(
                        		triggerParam.getLogId(),
								triggerParam.getLogDateTime(),
								XxlJobContext.HANDLE_CODE_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_CODE_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());
	}

         依次执行执行器的init方法、execute方法和destroy方法。然后将执行结果通过回调的方式告诉调度器。

小结

1、在执行execute方法时，如果需要使用任务绑定的参数，可以直接从XxlJobContext这个上下文中获取；

2、大量使用了生产者-消费者模型进行了解耦，提高了吞吐量。

微服务架构之旅-xxl-job任务触发流程
weixin_66129233的博客
12-13 1122
xxl-job老版本是依赖quartz的定时任务触发，在v2.1.0版本开始 移除quartz依赖：一方面是为了精简系统降低冗余依赖，另一方面是为了提供系统的可控度与稳定性。（本文 相应代码版本 2.2.0-SNAPSHOT）以下是本文的目录大纲：一.任务触发执行总体流程二.任务定时触发流程三.关于这么设计的感悟。
XXL-JOB分布式任务调度系统培训PPT
08-09
同时，XXL-JOB 也提供了任务流程图、任务执行记录、任务执行详情等功能，方便用户快速了解任务的执行情况。 XXL-JOB 的使用场景非常广泛，如每天凌晨 1 点跑批、每月 1 号进行上个月清算、电商整点抢购、商品价格 8...
【分布式任务调度】（四）XXL-JOB的任务调度执行流程及实现原理
热门推荐
积木成林，聚沙成塔
10-29 2万+
调度中心调用执行器，执行定时任务。执行器回调调度中心，上报定时任务执行结果。在调度和执行的整个流程中，XXL-JOB使用了大量的异步操作，减少调度中心的资源压力，以此在集中式调度配置与性能之间找到平衡点。异步实践通过线程池来执行异步操作通过自旋线程 + 阻塞队列的方式来执行异步操作。
XXL-Job中获取任务执行参数的方法
最新发布
ttyy1112的专栏
02-26 1241
如果任务处理器中无法直接通过方法参数获取（例如使用旧版API），可以通过 XxlJobContext 获取上下文中的参数。在XXL-Job管理界面创建或编辑任务时，在“任务参数”输入框中填写需要传递的参数（支持任意格式，如JSON、键值对等）。JSON格式：使用JSON解析工具（如FastJSON、Jackson）转换为对象。若需在触发任务时动态传递参数，可通过API调用或手动触发任务时指定参数。通过以上方式，您可以灵活地在XXL-Job中获取和处理任务参数。多个参数：约定分隔符（如逗号）分割后解析。
uCOS-II任务调度过程
gtkknd的专栏
08-15 1万+
uCOS-II任务调度过程 ucos-II是基于任务优先级抢占式任务调度法的，就是内核在管理调度时，调用任务切换函数（一般为SSched()），在该函数中将此时已处于就绪状态（条件一）并且为最高优先级（条件二）的任务的保存于其栈中的相应信息压入cpu寄存器中（软中断完成），然后cpu开始运行该任务的代码。    内核是何时进行任务调度的呢？虽然uC/OS-II是可被剥夺资源的内核（高优先级可强
XXL-JOB任务调度
LX1232456的博客
06-26 523
XXL-JOB 是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。 官网：https://www.xuxueli.com/xxl-job/
分布式任务调度平台xxl-job
weixin_30508241的博客
08-13 205
1，在工作中，经常会涉及到定时任务，那么定时任务的实现方式有哪些？ 实现方式1：Thread类下通过sleep方法来实现定时任务的效果 缺点：过于简单，只能实现很简单的定时任务的逻辑，不够灵活 public class Demo01 { static long count = 0; public static void...
基于Java核心的xxl-job分布式任务调度平台设计源码
09-26
基于Java核心的xxl-job分布式任务调度平台是为了解决在分布式系统环境下任务调度的需求而设计的，其源代码已经向公众开放。该平台源代码结构丰富，涉及不同类型的文件，其中包括Java源文件、图片、脚本文件、配置...
xxl-job分布式任务调度平台 v2.4.0.zip
04-02
XXL-JOB是一个开源的分布式任务调度平台，其主要功能是为了解决在分布式环境下的任务调度问题。在v2.4.0版本中，它提供了更稳定、更高效的调度能力，适用于各种复杂的业务场景。这个压缩包包含了该平台的源码以及...
基于Java核心技术的XXL-JOB分布式任务调度平台源码分析
02-12
XXL-JOB是由许雪里开发的一款轻量级分布式任务调度框架，其源码分析项目基于Java核心技术。XXL-JOB框架的设计初衷是为了提供一个高效、可靠且易于使用的分布式任务调度系统。框架的核心特点包括了分布式任务调度和...
基于Java核心技术的xxl-job分布式任务调度平台源码解析
10-03
xxl-job是一个轻量级、易于使用的分布式任务调度系统，广泛应用于生产环境之中，尤其适合中小型企业。本项目通过深入分析xxl-job的源码，旨在帮助开发者更好地理解其内部工作原理，以及如何利用Java核心技术去实现一...
ucos-ii嵌入式操作系统任务调度(一)----任务调度的过程及实现原理
myselfzhangji的博客
04-29 9213
一 概念 在单片机裸机程序中，我们以函数最最小单位来划分代码功能的，所有函数之间都存在一个先后调用的关系(不是你调用我，就是我调用你，或者你我都被他调用)；但是在嵌入式操作系统中，我们可以以任务为最小单位来看待一个程序代码(当然函数仍然是每个任务的最小单位)，各个任务之间没有调用关系，它们可以说是各自为营。 可以把嵌入式系统程序看成各个单片机裸机程序的集合，跑操作系统的本质原因就是因为系统程序需要...
一、分布式任务调度 —— XXL-JOB
清风明月独相伴
04-25 3949
一、简介1.1 概述XXL-JOB是一个轻量级分布式任务调度框架，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。1.2 特性1、简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手；2、动态：支持动态修改任务状态、暂停/恢复任务，以及终止运行中任务，即时生效；3、调度中心HA（中心式）：调度采用中心式设计，“调度中心”基于集群...
spring boot + xxl-job 分布式任务调度
weixin_49107940的博客
06-11 1433
某电商系统需要在每天上午10点，下午3点，晚上8点发放一批优惠券。某财务系统需要在每天上午10点前结算前一天的账单数据，统计汇总。某电商平台每天凌晨3点，要对订单中的无效订单进行清理。12306网站会根据车次不同，设置几个时间点分批次放票。电商整点抢购，商品价格某天上午8点整开始优惠。商品成功发货后，需要向客户发送短信提醒。类似的场景还有很多，我们该如何实现？以上这些场景，就是任务调度所需要解决的问题。
10. xxl-job原理---回调
小小鸟的博客
05-30 4991
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执行器的任务执行流程
2401_87704405的博客
10-06 1625
任务的调度处理、执行、结果回调，是3个依次执行的独立过程，由不同的线程来运行；执行器中，不同任务的执行，是线程隔离，避免互相影响；JobThread实例创建后会被缓存，当空闲超过90秒，就会被回收，在任务再次执行时再创建新实例；当一个任务的执行周期，小于一次执行的平均耗时时，可能导致任务在执行器中积压；默认的阻塞策略是单机串行；当阻塞策略使用，正在执行中的旧任务，和本次新提交的任务，可能会存在并发；任务体应当正确响应interrupt；执行结果通过异步批量回调。
xxl-job手动注册JobHandler
wsdhla的专栏
09-29 8035
xxl-job手动注册JobHandler
分布式任务处理XXL-JOB
weixin_44793245的博客
03-21 1677
分布式任务调度XXL-JOB
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值