pursuing_tech
pursuing_tech

elasticjob-lite源码解析

写在前面

elasticjob是当当开源的分布式定时任务调度中间件，目前在github上有6k+的star。elasticjob有两种模式：lite模式和cloud模式，本文只是想探究主流分布式定时任务调度中间件的实现原理，因此只解析较为简单的lite模式。

不知道大家有没有想过一个单机定时任务是怎么去驱动的？我们很容易想到jdk的ScheduledExecutorService，它的原理就是将任务丢进按照执行时间排序的队列，然后线程池中的线程不断扫描最近的任务，如果任务已经到了执行时间，取出并执行任务即可。那还有没有其他方式呢？是不是也可以把任务存储在非本地内存上，存在本地文件或者redis zetset或者db，然后也是通过线程不断扫描取出任务执行，这样做能够有效避免本地内存任务数据的丢失。或者也可以通过更好的数据结构如时间轮存储任务数据，这样做能够有效减少任务的扫描范围，提高执行效率。

理解了这一单机定时任务的实现原理后，对于分布式的定时任务就很容易理解了，需要解决的就是如何跟执行同一任务的集群协调、如何获取分布式任务、如何将分布式任务分片"降级"成单机任务罢了。重点已经不是最后的单机任务执行，而是集群的任务协调处理方式。

elasticjob的分布式任务的集群协调通过成熟的分布式协调服务zookeeper来实现，而单机定时任务通过成熟的定时任务框架quartz来实现。elasticjob的架构图如下。

elasticjob-lite架构图

job的初始化

下面开始源码解析，ScheduleJobBootstrap是elasticjob的启动器，JobScheduler的构造方法拥有三个必选的入参：CoordinatorRegistryCenter协调中心、ElasticJob自定义任务处理器、JobConfiguration任务配置，一个可选入参：ElasticJobListener任务监听器。然后调用schedule方法，进而调用jobScheduler.getJobScheduleController().scheduleJob进行定时任务的调度。

    public ScheduleJobBootstrap(final CoordinatorRegistryCenter regCenter, final ElasticJob elasticJob, final JobConfiguration jobConfig, final ElasticJobListener... elasticJobListeners) {
        jobScheduler = new JobScheduler(regCenter, elasticJob, jobConfig, elasticJobListeners);
    }

    public void schedule() {
        Preconditions.checkArgument(!Strings.isNullOrEmpty(jobScheduler.getJobConfig().getCron()), "Cron can not be empty.");
        jobScheduler.getJobScheduleController().scheduleJob(jobScheduler.getJobConfig().getCron());
    }

进入JobScheduler的构造方法，主要有5种类型的方法：生成SetUpFacade、SchedulerFacade、LiteJobFacade，生成ElasticJobExecutor，调用setUpFacade.setUpJobConfiguration初始化配置，调用setGuaranteeServiceForElasticJobListeners为listener设置GuaranteeService，createJobScheduleController完成收尾，接下来一个个分析这些方法。

    public JobScheduler(final CoordinatorRegistryCenter regCenter, final ElasticJob elasticJob, final JobConfiguration jobConfig, final TracingConfiguration tracingConfig,
                        final ElasticJobListener... elasticJobListeners) {
        this.regCenter = regCenter;
        this.elasticJob = elasticJob;
        elasticJobType = null;
        this.elasticJobListeners = Arrays.asList(elasticJobListeners);
        setUpFacade = new SetUpFacade(regCenter, jobConfig.getJobName(), this.elasticJobListeners);
        schedulerFacade = new SchedulerFacade(regCenter, jobConfig.getJobName());
        jobFacade = new LiteJobFacade(regCenter, jobConfig.getJobName(), this.elasticJobListeners, tracingConfig);
        jobExecutor = null == elasticJob ? new ElasticJobExecutor(elasticJobType, jobConfig, jobFacade) : new ElasticJobExecutor(elasticJob, jobConfig, jobFacade);
        String jobClassName = JobClassNameProviderFactory.getProvider().getJobClassName(elasticJob);
        this.jobConfig = setUpFacade.setUpJobConfiguration(jobClassName, jobConfig);
        setGuaranteeServiceForElasticJobListeners(regCenter, this.elasticJobListeners);
        jobScheduleController = createJobScheduleController();
    }

生成SetUpFacade、SchedulerFacade、LiteJobFacade，这三个Facade都是对regCenter的封装，可以向zookeeper进行增删改查，先不细说。

public SetUpFacade(final CoordinatorRegistryCenter regCenter, final String jobName, final List elasticJobListeners) {
        configService = new ConfigurationService(regCenter, jobName);
        leaderService = new LeaderService(regCenter, jobName);
        serverService = new ServerService(regCenter, jobName);
        instanceService = new InstanceService(regCenter, jobName);
        shardingService = new ShardingService(regCenter, jobName);
        reconcileService = new ReconcileService(regCenter, jobName);
        listenerManager = new ListenerManager(regCenter, jobName, elasticJobListeners);
    }

public SchedulerFacade(final CoordinatorRegistryCenter regCenter, final String jobName) {
        this.jobName = jobName;
        leaderService = new LeaderService(regCenter, jobName);
        shardingService = new ShardingService(regCenter, jobName);
        executionService = new ExecutionService(regCenter, jobName);
        reconcileService = new ReconcileService(regCenter, jobName);
    }

  public LiteJobFacade(final CoordinatorRegistryCenter regCenter, final String jobName, final List elasticJobListeners, final TracingConfiguration tracingConfig) {
        configService = new ConfigurationService(regCenter, jobName);
        shardingService = new ShardingService(regCenter, jobName);
        executionContextService = new ExecutionContextService(regCenter, jobName);
        executionService = new ExecutionService(regCenter, jobName);
        failoverService = new FailoverService(regCenter, jobName);
        this.elasticJobListeners = elasticJobListeners;
        this.jobEventBus = null == tracingConfig ? new JobEventBus() : new JobEventBus(tracingConfig);
    }

生成ElasticJobExecutor，对elasticJob、jobConfig、jobFacade进行赋值，通过JobItemExecutorFactory.getExecutor获取到jobItemExecutor，JobExecutorServiceHandlerFactory.getHandler(jobConfig.getJobExecutorServiceHandlerType()).createExecutorService获取到executorService，JobErrorHandlerFactory.getHandler获取到jobErrorHandler，对itemErrorMessages进行赋值。

   public ElasticJobExecutor(final ElasticJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade) {
        this(elasticJob, jobConfig, jobFacade, JobItemExecutorFactory.getExecutor(elasticJob.getClass()));
    }

    private ElasticJobExecutor(final ElasticJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final JobItemExecutor jobItemExecutor) {
        this.elasticJob = elasticJob;
        this.jobConfig = jobConfig;
        this.jobFacade = jobFacade;
        this.jobItemExecutor = jobItemExecutor;
        executorService = JobExecutorServiceHandlerFactory.getHandler(jobConfig.getJobExecutorServiceHandlerType()).createExecutorService(jobConfig.getJobName());
        jobErrorHandler = JobErrorHandlerFactory.getHandler(jobConfig.getJobErrorHandlerType());
        itemErrorMessages = new ConcurrentHashMap<>(jobConfig.getShardingTotalCount(), 1);
    }

setUpFacade.setUpJobConfiguration会判断是否config路径还没有数据并且需要覆盖配置，如果是就将config写入zookeeper的/jobName/config的路径中，并且写入jobClassName到/jobName的路径中。否则调用load从本地缓存或者zookeeper的config路径读取配置。

    public JobConfiguration setUpJobConfiguration(final String jobClassName, final JobConfiguration jobConfig) {
        return configService.setUpJobConfiguration(jobClassName, jobConfig);
    }

    public JobConfiguration setUpJobConfiguration(final String jobClassName, final JobConfiguration jobConfig) {
        checkConflictJob(jobClassName, jobConfig);
        if (!jobNodeStorage.isJobNodeExisted(ConfigurationNode.ROOT) || jobConfig.isOverwrite()) {
            jobNodeStorage.replaceJobNode(ConfigurationNode.ROOT, YamlEngine.marshal(JobConfigurationPOJO.fromJobConfiguration(jobConfig)));
            jobNodeStorage.replaceJobRootNode(jobClassName);
            return jobConfig;
        }
        return load(false);
    }

    public JobConfiguration load(final boolean fromCache) {
        String result;
        if (fromCache) {
            result = jobNodeStorage.getJobNodeData(ConfigurationNode.ROOT);
            if (null == result) {
                result = jobNodeStorage.getJobNodeDataDirectly(ConfigurationNode.ROOT);
            }
        } else {
            result = jobNodeStorage.getJobNodeDataDirectly(ConfigurationNode.ROOT);
        }
        return YamlEngine.unmarshal(result, JobConfigurationPOJO.class).toJobConfiguration();
    }

setGuaranteeServiceForElasticJobListeners将生成GuaranteeService设置到listener中，不再细说。

    private void setGuaranteeServiceForElasticJobListeners(final CoordinatorRegistryCenter regCenter, final List elasticJobListeners) {
        GuaranteeService guaranteeService = new GuaranteeService(regCenter, jobConfig.getJobName());
        for (ElasticJobListener each : elasticJobListeners) {
            if (each instanceof AbstractDistributeOnceElasticJobListener) {
                ((AbstractDistributeOnceElasticJobListener) each).setGuaranteeService(guaranteeService);
            }
        }
    }

createJobScheduleController是重头戏，首先会创建调用createScheduler、createJobDetail、 getJobConfig().getJobName()获取入参生成JobScheduleController，然后调用 JobRegistry.getInstance().registerJob向本地的map注册JobScheduleController，然后调用registerStartUpInfo注册启动信息。

    private JobScheduleController createJobScheduleController() {
        JobScheduleController result = new JobScheduleController(createScheduler(), createJobDetail(), getJobConfig().getJobName());
        JobRegistry.getInstance().registerJob(getJobConfig().getJobName(), result);
        registerStartUpInfo();
        return result;
    }

先来看JobScheduleController的生成，入参是quartz的Scheduler、JobDetail、triggerIdentity。
Scheduler通过StdSchedulerFactory并且注入一些quartz的配置参数，然后调用其getScheduler获取，最后注册listener到Scheduler，来处理错过调度到的任务。
JobDetail通过注入jobExecutor来生成，使得任务执行时会调用jobExecutor的execute方法。
triggerIdentity即是jobName。

 private Scheduler createScheduler() {
        Scheduler result;
        try {
            StdSchedulerFactory factory = new StdSchedulerFactory();
            factory.initialize(getQuartzProps());
            result = factory.getScheduler();
            result.getListenerManager().addTriggerListener(schedulerFacade.newJobTriggerListener());
        } catch (final SchedulerException ex) {
            throw new JobSystemException(ex);
        }
        return result;
    }
    
    private Properties getQuartzProps() {
        Properties result = new Properties();
        result.put("org.quartz.threadPool.class", SimpleThreadPool.class.getName());
        result.put("org.quartz.threadPool.threadCount", "1");
        result.put("org.quartz.scheduler.instanceName", getJobConfig().getJobName());
        result.put("org.quartz.jobStore.misfireThreshold", "1");
        result.put("org.quartz.plugin.shutdownhook.class", JobShutdownHookPlugin.class.getName());
        result.put("org.quartz.plugin.shutdownhook.cleanShutdown", Boolean.TRUE.toString());
        return result;
    }
    
    private JobDetail createJobDetail() {
        JobDetail result = JobBuilder.newJob(LiteJob.class).withIdentity(getJobConfig().getJobName()).build();
        result.getJobDataMap().put(JOB_EXECUTOR_DATA_MAP_KEY, jobExecutor);
        return result;
    }

接下来是registerStartUpInfo，分别会调用JobRegistry的registerRegistryCenter、addJobInstance、setCurrentShardingTotalCount，最后调用setUpFacade.registerStartUpInfo。

    private void registerStartUpInfo() {
        JobRegistry.getInstance().registerRegistryCenter(jobConfig.getJobName(), regCenter);
        JobRegistry.getInstance().addJobInstance(jobConfig.getJobName(), new JobInstance());
        JobRegistry.getInstance().setCurrentShardingTotalCount(jobConfig.getJobName(), jobConfig.getShardingTotalCount());
        setUpFacade.registerStartUpInfo(!jobConfig.isDisabled());
    }

JobRegistry的registerRegistryCenter、addJobInstance、setCurrentShardingTotalCount三个是将regCenter、jobInstance、currentShardingTotalCount进行缓存，并且初始化对/jobName路径下数据的缓存。

    public void registerRegistryCenter(final String jobName, final CoordinatorRegistryCenter regCenter) {
        regCenterMap.put(jobName, regCenter);
        regCenter.addCacheData("/" + jobName);
    }

    public void addJobInstance(final String jobName, final JobInstance jobInstance) {
        jobInstanceMap.put(jobName, jobInstance);
    }

    public void setCurrentShardingTotalCount(final String jobName, final int currentShardingTotalCount) {
        currentShardingTotalCountMap.put(jobName, currentShardingTotalCount);
    }

setUpFacade.registerStartUpInfo是最终的初始化方法，里面的方法很重要，对每一个都分析一下。

    public void registerStartUpInfo(final boolean enabled) {
        listenerManager.startAllListeners();
        leaderService.electLeader();
        serverService.persistOnline(enabled);
        instanceService.persistOnline();
        shardingService.setReshardingFlag();
        if (!reconcileService.isRunning()) {
            reconcileService.startAsync();
        }
    }

listenerManager.startAllListeners会启动所有对zookeeper路径数据变化的listener。

 public void startAllListeners() {
    electionListenerManager.start();
    shardingListenerManager.start();
    failoverListenerManager.start();
    monitorExecutionListenerManager.start();
    shutdownListenerManager.start();
    triggerListenerManager.start();
    rescheduleListenerManager.start();
    guaranteeListenerManager.start();
    jobNodeStorage.addConnectionStateListener(regCenterConnectionStateListener);
    }

electionListenerManager监听以下事件：
1.当leader节点被删除或者leader节点不存在时，触发leaderService.electLeader选举。
2.如果本身节点被置为不可用并且本身节点是leader，则移除本身节点的leader节点，以此来触发leaderService.electLeader选举。

    class LeaderElectionJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && (isActiveElection(path, data) || isPassiveElection(path, eventType))) {
                leaderService.electLeader();
            }
        }
        
        private boolean isActiveElection(final String path, final String data) {
            return !leaderService.hasLeader() && isLocalServerEnabled(path, data);
        }
        
        private boolean isPassiveElection(final String path, final Type eventType) {
            JobInstance jobInstance = JobRegistry.getInstance().getJobInstance(jobName);
            return !Objects.isNull(jobInstance) && isLeaderCrashed(path, eventType) && serverService.isAvailableServer(jobInstance.getIp());
        }
        
        private boolean isLeaderCrashed(final String path, final Type eventType) {
            return leaderNode.isLeaderInstancePath(path) && Type.NODE_DELETED == eventType;
        }
        
        private boolean isLocalServerEnabled(final String path, final String data) {
            return serverNode.isLocalServerPath(path) && !ServerStatus.DISABLED.name().equals(data);
        }
    }

    class LeaderAbdicationJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (leaderService.isLeader() && isLocalServerDisabled(path, data)) {
                leaderService.removeLeader();
            }
        }
        
        private boolean isLocalServerDisabled(final String path, final String data) {
            return serverNode.isLocalServerPath(path) && ServerStatus.DISABLED.name().equals(data);
        }
    }

shardingListenerManager监听以下事件：
1.配置节点中的shardingTotalCount发生改变，调用shardingService.setReshardingFlag，强制任务执行时重新分配分片。
2.server或者instance节点发生改变，调用shardingService.setReshardingFlag，强制任务执行时重新分配分片。

    class ShardingTotalCountChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && 0 != JobRegistry.getInstance().getCurrentShardingTotalCount(jobName)) {
                int newShardingTotalCount = YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().getShardingTotalCount();
                if (newShardingTotalCount != JobRegistry.getInstance().getCurrentShardingTotalCount(jobName)) {
                    shardingService.setReshardingFlag();
                    JobRegistry.getInstance().setCurrentShardingTotalCount(jobName, newShardingTotalCount);
                }
            }
        }
    }
    
    class ListenServersChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && (isInstanceChange(eventType, path) || isServerChange(path))) {
                shardingService.setReshardingFlag();
            }
        }
        
        private boolean isInstanceChange(final Type eventType, final String path) {
            return instanceNode.isInstancePath(path) && Type.NODE_CHANGED != eventType;
        }
        
        private boolean isServerChange(final String path) {
            return serverNode.isServerPath(path);
        }
    }

failoverListenerManager监听以下事件：
1.instance节点发生下线，将其拥有的失效转移任务再次触发失效转移到其他节点执行。
2.配置节点中的isFailover发生改变，若不需要失效转移，则直接清除现有的失效转移任务。

class JobCrashedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && isFailoverEnabled() && Type.NODE_DELETED == eventType && instanceNode.isInstancePath(path)) {
                String jobInstanceId = path.substring(instanceNode.getInstanceFullPath().length() + 1);
                if (jobInstanceId.equals(JobRegistry.getInstance().getJobInstance(jobName).getJobInstanceId())) {
                    return;
                }
                List failoverItems = failoverService.getFailoverItems(jobInstanceId);
                if (!failoverItems.isEmpty()) {
                    for (int each : failoverItems) {
                        failoverService.setCrashedFailoverFlag(each);
                        failoverService.failoverIfNecessary();
                    }
                } else {
                    for (int each : shardingService.getShardingItems(jobInstanceId)) {
                        failoverService.setCrashedFailoverFlag(each);
                        failoverService.failoverIfNecessary();
                    }
                }
            }
        }
    }
    
    class FailoverSettingsChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && Type.NODE_CHANGED == eventType && !YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().isFailover()) {
                failoverService.removeFailoverInfo();
            }
        }
    }

monitorExecutionListenerManager监听以下事件：
1.配置节点中的isMonitorExecution发生改变，若不需要提醒执行信息，则直接清除现有的显示执行的节点。

    class MonitorExecutionSettingsChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && Type.NODE_CHANGED == eventType && !YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().isMonitorExecution()) {
                executionService.clearAllRunningInfo();
            }
        }
    }

shutdownListenerManager监听以下事件：
1.本身的instance节点被删除，需要调用schedulerFacade.shutdownInstance关闭掉本身节点的定时任务。

    class InstanceShutdownStatusJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && !JobRegistry.getInstance().getJobScheduleController(jobName).isPaused()
                    && isRemoveInstance(path, eventType) && !isReconnectedRegistryCenter()) {
                schedulerFacade.shutdownInstance();
            }
        }
        
        private boolean isRemoveInstance(final String path, final Type eventType) {
            return instanceNode.isLocalInstancePath(path) && Type.NODE_DELETED == eventType;
        }
        
        private boolean isReconnectedRegistryCenter() {
            return instanceService.isLocalJobInstanceExisted();
        }
    }

triggerListenerManager监听以下事件：
1.出现指定本身节点的trigger节点，将清除trigger节点，然后调用triggerJob立刻执行一次任务。

    class JobTriggerStatusJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!InstanceOperation.TRIGGER.name().equals(data) || !instanceNode.isLocalInstancePath(path) || Type.NODE_CHANGED != eventType) {
                return;
            }
            instanceService.clearTriggerFlag();
            if (!JobRegistry.getInstance().isShutdown(jobName) && !JobRegistry.getInstance().isJobRunning(jobName)) {
                // TODO At present, it cannot be triggered when the job is running, and it will be changed to a stacked trigger in the future.
                JobRegistry.getInstance().getJobScheduleController(jobName).triggerJob();
            }
        }
    }

rescheduleListenerManager监听以下事件：
1.配置节点中的cron发生改变，则调用rescheduleJob重新调度定时任务。

class CronSettingAndJobEventChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && Type.NODE_CHANGED == eventType && !JobRegistry.getInstance().isShutdown(jobName)) {
                JobRegistry.getInstance().getJobScheduleController(jobName).rescheduleJob(YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().getCron());
            }
        }
    }

guaranteeListenerManager监听以下事件：
1.start节点发生改变，将调用listener的notifyWaitingTaskStart通知任务启动。
2.complete发生改变，将调用listener的notifyWaitingTaskComplete通知任务完成。

   class StartedNodeRemovedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (Type.NODE_DELETED == eventType && guaranteeNode.isStartedRootNode(path)) {
                for (ElasticJobListener each : elasticJobListeners) {
                    if (each instanceof AbstractDistributeOnceElasticJobListener) {
                        ((AbstractDistributeOnceElasticJobListener) each).notifyWaitingTaskStart();
                    }
                }
            }
        }
    }
    
    class CompletedNodeRemovedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (Type.NODE_DELETED == eventType && guaranteeNode.isCompletedRootNode(path)) {
                for (ElasticJobListener each : elasticJobListeners) {
                    if (each instanceof AbstractDistributeOnceElasticJobListener) {
                        ((AbstractDistributeOnceElasticJobListener) each).notifyWaitingTaskComplete();
                    }
                }
            }
        }
    }

regCenterConnectionStateListener监听的是对zookeeper的连接状态，若连接出现挂起或者丢失状态，则暂停任务，如果重新连接上，则重新写入server、instance本身节点到zookeeper，清除本身节点的运行节点，然后重新调度定时任务。

  @Override
    public void stateChanged(final CuratorFramework client, final ConnectionState newState) {
        if (JobRegistry.getInstance().isShutdown(jobName)) {
            return;
        }
        JobScheduleController jobScheduleController = JobRegistry.getInstance().getJobScheduleController(jobName);
        if (ConnectionState.SUSPENDED == newState || ConnectionState.LOST == newState) {
            jobScheduleController.pauseJob();
        } else if (ConnectionState.RECONNECTED == newState) {
            serverService.persistOnline(serverService.isEnableServer(JobRegistry.getInstance().getJobInstance(jobName).getIp()));
            instanceService.persistOnline();
            executionService.clearRunningInfo(shardingService.getLocalShardingItems());
            jobScheduleController.resumeJob();
        }
    }

完成所有listener的初始化后，将调用leaderService.electLeader开始选举，将使用zookeeper分布式锁的机制，所有节点都往同一路径下创建顺序节点，只有获取到最小序号的节点会执行LeaderElectionExecutionCallback的execute方法，将本身节点的信息写入leader节点，宣布选举成功。因此后续其他节点再进入LeaderElectionExecutionCallback的execute方法时，发现leader节点拥有数据，自己只能成为follower结束选举流程。

  public void executeInLeader(final String latchNode, final LeaderExecutionCallback callback) {
        try (LeaderLatch latch = new LeaderLatch(getClient(), jobNodePath.getFullPath(latchNode))) {
            latch.start();
            latch.await();
            callback.execute();
        //CHECKSTYLE:OFF
        } catch (final Exception ex) {
        //CHECKSTYLE:ON
            handleException(ex);
        }
    }

    public void electLeader() {
        log.debug("Elect a new leader now.");
        jobNodeStorage.executeInLeader(LeaderNode.LATCH, new LeaderElectionExecutionCallback());
        log.debug("Leader election completed.");
    }

   @RequiredArgsConstructor
    class LeaderElectionExecutionCallback implements LeaderExecutionCallback {
        
        @Override
        public void execute() {
            if (!hasLeader()) {
                jobNodeStorage.fillEphemeralJobNode(LeaderNode.INSTANCE, JobRegistry.getInstance().getJobInstance(jobName).getJobInstanceId());
            }
        }
    }

由上文讲到，listener基本上都是围绕server、instance节点来进行处理，接下来serverService.persistOnline和instanceService.persistOnline就是创建本身节点的server、instance节点。

    public void persistOnline(final boolean enabled) {
        if (!JobRegistry.getInstance().isShutdown(jobName)) {
            jobNodeStorage.fillJobNode(serverNode.getServerNode(JobRegistry.getInstance().getJobInstance(jobName).getIp()), enabled ? ServerStatus.ENABLED.name() : ServerStatus.DISABLED.name());
        }
    }

  public void persistOnline() {
        jobNodeStorage.fillEphemeralJobNode(instanceNode.getLocalInstanceNode(), "");
    }

因为是初始化，还是需要调用shardingService.setReshardingFlag，强制定时任务执行前进行分片。

   public void setReshardingFlag() {
        jobNodeStorage.createJobNodeIfNeeded(ShardingNode.NECESSARY);
    }

最后是reconcileService.startAsync，会定时检测leader状态触发重新选举和触发重新分片，避免完全依赖listener处理核心逻辑，使得系统拥有一个自检测修复的功能。

    @Override
    protected void runOneIteration() {
        int reconcileIntervalMinutes = configService.load(true).getReconcileIntervalMinutes();
        if (reconcileIntervalMinutes > 0 && (System.currentTimeMillis() - lastReconcileTime >= reconcileIntervalMinutes * 60 * 1000)) {
            lastReconcileTime = System.currentTimeMillis();
            if (leaderService.isLeaderUntilBlock() && !shardingService.isNeedSharding() && shardingService.hasShardingInfoInOfflineServers()) {
                log.warn("Elastic Job: job status node has inconsistent value,start reconciling...");
                shardingService.setReshardingFlag();
            }
        }
    }
    
    @Override
    protected Scheduler scheduler() {
        return Scheduler.newFixedDelaySchedule(0, 1, TimeUnit.MINUTES);
    }

job的执行

来到job的执行流程解析，在定时任务执行时，会调用到ElasticJobExecutor的execute方法，下面会一步步分析。

    public void execute() {
        try {
            jobFacade.checkJobExecutionEnvironment();
        } catch (final JobExecutionEnvironmentException cause) {
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
        ShardingContexts shardingContexts = jobFacade.getShardingContexts();
        jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_STAGING, String.format("Job '%s' execute begin.", jobConfig.getJobName()));
        if (jobFacade.misfireIfRunning(shardingContexts.getShardingItemParameters().keySet())) {
            jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_FINISHED, String.format(
                    "Previous job '%s' - shardingItems '%s' is still running, misfired job will start after previous job completed.", jobConfig.getJobName(),
                    shardingContexts.getShardingItemParameters().keySet()));
            return;
        }
        try {
            jobFacade.beforeJobExecuted(shardingContexts);
            //CHECKSTYLE:OFF
        } catch (final Throwable cause) {
            //CHECKSTYLE:ON
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
        execute(shardingContexts, ExecutionSource.NORMAL_TRIGGER);
        while (jobFacade.isExecuteMisfired(shardingContexts.getShardingItemParameters().keySet())) {
            jobFacade.clearMisfire(shardingContexts.getShardingItemParameters().keySet());
            execute(shardingContexts, ExecutionSource.MISFIRE);
        }
        jobFacade.failoverIfNecessary();
        try {
            jobFacade.afterJobExecuted(shardingContexts);
            //CHECKSTYLE:OFF
        } catch (final Throwable cause) {
            //CHECKSTYLE:ON
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
    }

jobFacade.checkJobExecutionEnvironment最终会调用到ConfigurationService的checkMaxTimeDiffSecondsTolerable方法，原理是通过在zookeeper写入一个节点，然后获取其写入时间，然后与本地时间对比获取时间差，若时间差大于最大容忍的时间差则抛出错误，不执行任务。

   public void checkMaxTimeDiffSecondsTolerable() throws JobExecutionEnvironmentException {
        int maxTimeDiffSeconds = load(true).getMaxTimeDiffSeconds();
        if (-1 == maxTimeDiffSeconds) {
            return;
        }
        long timeDiff = Math.abs(timeService.getCurrentMillis() - jobNodeStorage.getRegistryCenterTime());
        if (timeDiff > maxTimeDiffSeconds * 1000L) {
            throw new JobExecutionEnvironmentException(
                    "Time different between job server and register center exceed '%s' seconds, max time different is '%s' seconds.", timeDiff / 1000, maxTimeDiffSeconds);
        }
    }

jobFacade.getShardingContexts是获取ShardingContexts的方法，主要是获取到具体的分片items，然后将jobConfig和分片items结合生成ShardingContexts返回。如果是支持failover则返回failover的分片，否则需要调用shardingService.shardingIfNecessary检测是否需要重新分片，然后再获取到分到本节点的分片返回。

@Override
    public ShardingContexts getShardingContexts() {
        boolean isFailover = configService.load(true).isFailover();
        if (isFailover) {
            List failoverShardingItems = failoverService.getLocalFailoverItems();
            if (!failoverShardingItems.isEmpty()) {
                return executionContextService.getJobShardingContext(failoverShardingItems);
            }
        }
        shardingService.shardingIfNecessary();
        List shardingItems = shardingService.getLocalShardingItems();
        if (isFailover) {
            shardingItems.removeAll(failoverService.getLocalTakeOffItems());
        }
        shardingItems.removeAll(executionService.getDisabledItems(shardingItems));
        return executionContextService.getJobShardingContext(shardingItems);
    }

    public ShardingContexts getJobShardingContext(final List shardingItems) {
        JobConfiguration jobConfig = configService.load(false);
        removeRunningIfMonitorExecution(jobConfig.isMonitorExecution(), shardingItems);
        if (shardingItems.isEmpty()) {
            return new ShardingContexts(buildTaskId(jobConfig, shardingItems), jobConfig.getJobName(), jobConfig.getShardingTotalCount(), 
                    jobConfig.getJobParameter(), Collections.emptyMap());
        }
        Map shardingItemParameterMap = new ShardingItemParameters(jobConfig.getShardingItemParameters()).getMap();
        return new ShardingContexts(buildTaskId(jobConfig, shardingItems), jobConfig.getJobName(), jobConfig.getShardingTotalCount(), 
                jobConfig.getJobParameter(), getAssignedShardingItemParameterMap(shardingItems, shardingItemParameterMap));
    }

shardingService.shardingIfNecessary是重新分片的方法，上文已经说到，如果需要分片，则会在zookeeper加上shard目录加上necessary节点。如果检测到需要重新分片，follower会等待重新分片完成，leader则执行重新分片逻辑，需要先等到正在执行的分片item完成，然后标记重新分片为进行中，调用resetShardingInfo将shard节点调整为正确数量（扩缩容），然后调用jobShardingStrategy的sharding方法，获取到分片结果，最终调用jobNodeStorage.executeInTransaction将分片结果写入到zookeeper。

    public void shardingIfNecessary() {
        List availableJobInstances = instanceService.getAvailableJobInstances();
        if (!isNeedSharding() || availableJobInstances.isEmpty()) {
            return;
        }
        if (!leaderService.isLeaderUntilBlock()) {
            blockUntilShardingCompleted();
            return;
        }
        waitingOtherShardingItemCompleted();
        JobConfiguration jobConfig = configService.load(false);
        int shardingTotalCount = jobConfig.getShardingTotalCount();
        log.debug("Job '{}' sharding begin.", jobName);
        jobNodeStorage.fillEphemeralJobNode(ShardingNode.PROCESSING, "");
        resetShardingInfo(shardingTotalCount);
        JobShardingStrategy jobShardingStrategy = JobShardingStrategyFactory.getStrategy(jobConfig.getJobShardingStrategyType());
        jobNodeStorage.executeInTransaction(new PersistShardingInfoTransactionExecutionCallback(jobShardingStrategy.sharding(availableJobInstances, jobName, shardingTotalCount)));
        log.debug("Job '{}' sharding complete.", jobName);
    }

继续回到主流程，拿到ShardingContexts后就调用execute方法执行，忽略一些前后钩子方法的执行，其实就是根据分片号执行任务，如果是只有1个分片，则直接在原线程执行。否则将丢进线程池，然后使用CountDownLatch等待所有任务执行完成返回。

    private void execute(final ShardingContexts shardingContexts, final ExecutionSource executionSource) {
        if (shardingContexts.getShardingItemParameters().isEmpty()) {
            jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_FINISHED, String.format("Sharding item for job '%s' is empty.", jobConfig.getJobName()));
            return;
        }
        jobFacade.registerJobBegin(shardingContexts);
        String taskId = shardingContexts.getTaskId();
        jobFacade.postJobStatusTraceEvent(taskId, State.TASK_RUNNING, "");
        try {
            process(shardingContexts, executionSource);
        } finally {
            // TODO Consider increasing the status of job failure, and how to handle the overall loop of job failure
            jobFacade.registerJobCompleted(shardingContexts);
            if (itemErrorMessages.isEmpty()) {
                jobFacade.postJobStatusTraceEvent(taskId, State.TASK_FINISHED, "");
            } else {
                jobFacade.postJobStatusTraceEvent(taskId, State.TASK_ERROR, itemErrorMessages.toString());
            }
        }
    }

private void process(final ShardingContexts shardingContexts, final ExecutionSource executionSource) {
        Collection items = shardingContexts.getShardingItemParameters().keySet();
        if (1 == items.size()) {
            int item = shardingContexts.getShardingItemParameters().keySet().iterator().next();
            JobExecutionEvent jobExecutionEvent = new JobExecutionEvent(IpUtils.getHostName(), IpUtils.getIp(), shardingContexts.getTaskId(), jobConfig.getJobName(), executionSource, item);
            process(shardingContexts, item, jobExecutionEvent);
            return;
        }
        CountDownLatch latch = new CountDownLatch(items.size());
        for (int each : items) {
            JobExecutionEvent jobExecutionEvent = new JobExecutionEvent(IpUtils.getHostName(), IpUtils.getIp(), shardingContexts.getTaskId(), jobConfig.getJobName(), executionSource, each);
            if (executorService.isShutdown()) {
                return;
            }
            executorService.submit(() -> {
                try {
                    process(shardingContexts, each, jobExecutionEvent);
                } finally {
                    latch.countDown();
                }
            });
        }
        try {
            latch.await();
        } catch (final InterruptedException ex) {
            Thread.currentThread().interrupt();
        }
    }

   private void process(final ShardingContexts shardingContexts, final int item, final JobExecutionEvent startEvent) {
        jobFacade.postJobExecutionEvent(startEvent);
        log.trace("Job '{}' executing, item is: '{}'.", jobConfig.getJobName(), item);
        JobExecutionEvent completeEvent;
        try {
            jobItemExecutor.process(elasticJob, jobConfig, jobFacade, shardingContexts.createShardingContext(item));
            completeEvent = startEvent.executionSuccess();
            log.trace("Job '{}' executed, item is: '{}'.", jobConfig.getJobName(), item);
            jobFacade.postJobExecutionEvent(completeEvent);
            // CHECKSTYLE:OFF
        } catch (final Throwable cause) {
            // CHECKSTYLE:ON
            completeEvent = startEvent.executionFailure(ExceptionUtils.transform(cause));
            jobFacade.postJobExecutionEvent(completeEvent);
            itemErrorMessages.put(item, ExceptionUtils.transform(cause));
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
    }

下面来分析一下elasticjob三种job形态。
SimpleJobExecutor直接调用用户定义的elasticJob的execute执行即可。

    @Override
    public void process(final SimpleJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        elasticJob.execute(shardingContext);
    }

ScriptJobExecutor将分片参数转化成命令行，调用底层的命令行执行方法即可。

    @Override
    public void process(final ElasticJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        CommandLine commandLine = CommandLine.parse(getScriptCommandLine(jobConfig.getProps()));
        commandLine.addArgument(GsonFactory.getGson().toJson(shardingContext), false);
        try {
            new DefaultExecutor().execute(commandLine);
        } catch (final IOException ex) {
            throw new JobSystemException("Execute script failure.", ex);
        }
    }
    
    private String getScriptCommandLine(final Properties props) {
        String result = props.getProperty(ScriptJobProperties.SCRIPT_KEY);
        if (Strings.isNullOrEmpty(result)) {
            throw new JobConfigurationException("Cannot find script command line, job is not executed.");
        }
        return result;
    }

DataflowJobExecutor会根据配置选择对应的流式处理模式，如果是oneOffExecute，则调用一次fetchData拉取数据，再调用一次processData处理数据就结束。如果是streamingExecute，则会不断进行拉取处理的循环，直到拉取的数据为空。

 @Override
    public void process(final DataflowJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        if (Boolean.parseBoolean(jobConfig.getProps().getOrDefault(DataflowJobProperties.STREAM_PROCESS_KEY, false).toString())) {
            streamingExecute(elasticJob, jobConfig, jobFacade, shardingContext);
        } else {
            oneOffExecute(elasticJob, shardingContext);
        }
    }
    
    private void streamingExecute(final DataflowJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        List data = fetchData(elasticJob, shardingContext);
        while (null != data && !data.isEmpty()) {
            processData(elasticJob, shardingContext, data);
            if (!isEligibleForJobRunning(jobConfig, jobFacade)) {
                break;
            }
            data = fetchData(elasticJob, shardingContext);
        }
    }
    
    private boolean isEligibleForJobRunning(final JobConfiguration jobConfig, final JobFacade jobFacade) {
        return !jobFacade.isNeedSharding() && Boolean.parseBoolean(jobConfig.getProps().getOrDefault(DataflowJobProperties.STREAM_PROCESS_KEY, false).toString());
    }
    
    private void oneOffExecute(final DataflowJob elasticJob, final ShardingContext shardingContext) {
        List data = fetchData(elasticJob, shardingContext);
        if (null != data && !data.isEmpty()) {
            processData(elasticJob, shardingContext, data);
        }
    }
    
    @SuppressWarnings("unchecked")
    private List fetchData(final DataflowJob elasticJob, final ShardingContext shardingContext) {
        return elasticJob.fetchData(shardingContext);
    }
    
    @SuppressWarnings("unchecked")
    private void processData(final DataflowJob elasticJob, final ShardingContext shardingContext, final List data) {
        elasticJob.processData(shardingContext, data);
    }
    


继续主流程的错过调度的分片item处理，上文分析到本地的quartz是注册了错过调度listener，如果检测到错过调度，则向zookeeper注册错过调度节点。此时则是取出错过调度节点，然后执行。


       execute(shardingContexts, ExecutionSource.NORMAL_TRIGGER);
        while (jobFacade.isExecuteMisfired(shardingContexts.getShardingItemParameters().keySet())) {
            jobFacade.clearMisfire(shardingContexts.getShardingItemParameters().keySet());
            execute(shardingContexts, ExecutionSource.MISFIRE);
        }



最后是jobFacade.failoverIfNecessary，也就是再一次取出failover的节点进行执行。


  @Override
    public void failoverIfNecessary() {
        if (configService.load(true).isFailover()) {
            failoverService.failoverIfNecessary();
        }
    }

   public void failoverIfNecessary() {
        if (needFailover()) {
            jobNodeStorage.executeInLeader(FailoverNode.LATCH, new FailoverLeaderExecutionCallback());
        }
    }

    private boolean needFailover() {
        return jobNodeStorage.isJobNodeExisted(FailoverNode.ITEMS_ROOT) && !jobNodeStorage.getJobNodeChildrenKeys(FailoverNode.ITEMS_ROOT).isEmpty()
                && !JobRegistry.getInstance().isJobRunning(jobName);
    }

       @Override
        public void execute() {
            if (JobRegistry.getInstance().isShutdown(jobName) || !needFailover()) {
                return;
            }
            int crashedItem = Integer.parseInt(jobNodeStorage.getJobNodeChildrenKeys(FailoverNode.ITEMS_ROOT).get(0));
            log.debug("Failover job '{}' begin, crashed item '{}'", jobName, crashedItem);
            jobNodeStorage.fillEphemeralJobNode(FailoverNode.getExecutionFailoverNode(crashedItem), JobRegistry.getInstance().getJobInstance(jobName).getJobInstanceId());
            jobNodeStorage.removeJobNodeIfExisted(FailoverNode.getItemsNode(crashedItem));
            // TODO Instead of using triggerJob, use executor for unified scheduling
            JobScheduleController jobScheduleController = JobRegistry.getInstance().getJobScheduleController(jobName);
            if (null != jobScheduleController) {
                jobScheduleController.triggerJob();
            }
        }

























你可能感兴趣的:(elasticjob-lite源码解析)






    

  • Android 12.0 App全屏时通过系统属性控制上划下拉是否显示虚拟导航栏和状态栏
VaporRuby
android

    遇到问题厂测App触摸屏测试，需要全屏显示，禁止出现状态栏和导航栏，以免影响测试。参考资料https://zhuanlan.zhihu.com/p/440810585Android12系统源码_SystemUI（九）WindowInsetsController源码解析-CSDN博客解决方案1、framework修改点+++b/frameworks/base/services/core/java/c
    

    • 

  • Spring之Bean生命周期源码解析上
阿立聊代码
springspringjava后端

    Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的Bean的生成过程1.生成BeanDefinitionSpring启动的时候会进行扫描，会先调用org.springfr
    

    • 

  • MyBatis 源码解析：XMLConfigBuilder 解析过程
捕风捉你
MyBatis源码解读mybatisjava

    前言在MyBatis框架中，XMLConfigBuilder是一个关键类，负责解析mybatis-config.xml配置文件。理解这个类的工作原理有助于掌握MyBatis的配置管理和框架初始化过程。本篇文章将通过自定义实现一个简化版的XML配置解析器，并深入解析MyBatis中XMLConfigBuilder的实现细节。自定义实现：简化版XML配置解析器目标与功能我们将实现一个简化版的XML配置
    

    • 

  • 【Android】APK应用安装过程源码解析
Tech Ranger
笔记

    Android系统在启动的过程中，会启动一个应用程序管理服务PackageManagerService，这个服务负责扫描系统中特定的目录，找到里面的应用程序文件，即以Apk为后缀的文件，然后对这些文件进解析，得到应用程序的相关信息，完成应用程序的安装过程，本文将详细分析这个过程。一、启动安装1、InstallStart在开发过程中有时候需要进行APP更新，或者下载其他APP到本地让后使用以下代码进
    

    • 

  • frameworks 之getEvent指令
哥咫匙传说
linux车载系统android

    frameworks之getEvent指令指令解析源码追溯源码解析1.解析参数2.初始化ufds数组3.添加到poll并做对应处理通过getEvent可以识别按键基本命令和里面的关键信息涉及到的类如下system/core/toolbox/toolbox.csystem/core/toolbox/tools.hsystem/core/toolbox/getevent.c指令解析通过getEvent
    

    • 

  • Spring Cloud LoadBalancer 源码解析
码农爱java
【SpringCloudGateway】springcloud微服务负载均衡LoadBalancer源码

    前言LoadBalancer（负载均衡器）：一种网络设备或软件机制，用于分发传入的网络流量负载到多个后端目标服务器上，依次来提高系统的可用性和性能，SpringCloud2020版本以后，移除了对Netflix的依赖，也就移除了负载均衡器Ribbon，SpringCloud官方推荐使用Loadbalancer替换Ribbon，并成为了SpringCloud负载均衡器的唯一实现。LoadBalanc
    

    • 

  • java源码浅析之dubbo
DaHuangXiao
随笔java

    前言最近在看RPC框架，选择先看dubbo，再看netty，最后手写一个RPC的学习路线，结合雷神关于dubbo的讲解，对源码流程进行一个简单的记录原理所谓RPC就是远程服务调用的意思，那么dubbo怎么完成远程调用的呢？原理图如下[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9fEwo2Az-1623312993257)(java源码解析之dubbo.assets
    

    • 

  • ThreadLocal源码解析
七月拾光

    使用示例publicclassThreadLocalDemo{privatestaticThreadLocalthreadLocal=newThreadLocal{threadLocal.set(1);System.out.println(Thread.currentThread().getName()+","+threadLocal.get());},"thread1").start();new
    

    • 

  • Java集合框架：了解TreeMap
索茄啦你
java

    TreeMap基于红黑树实现的有序映射目录TreeMap继承关系TreeMap源码解析TreeMap总结TreeMap继承关系TreeMap继承了AbstractMap抽象类，拥有map的相关操作方法TreeMap实现了Serializable接口，支持序列化，可通过序列化传输TreeMap实现了Cloneable接口，覆盖了clone()方法，能被克隆TreeMap实现了NavigableMap
    

    • 

  • Java 集合框架：TreeMap 的介绍、使用、原理与源码解析
栗筝i
栗筝i的Java技术栈#Java基础栗筝i的Java技术栈Java基础Java集合TreeMapr-tree

    大家好，我是栗筝i，这篇文章是我的“栗筝i的Java技术栈”专栏的第021篇文章，在“栗筝i的Java技术栈”这个专栏中我会持续为大家更新Java技术相关全套技术栈内容。专栏的主要目标是已经有一定Java开发经验，并希望进一步完善自己对整个Java技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同
    

    • 

  • 推荐开源项目：ElasticJob-UI —— 强大的弹性任务管理神器
任澄翊

    推荐开源项目：ElasticJob-UI——强大的弹性任务管理神器项目介绍ElasticJob-UI是ApacheShardingSphere生态系统中的一个重要组件，它为ElasticJob提供了一款功能强大的可视化管理控制台。这个平台涵盖了动态配置和作业管控等一系列关键功能，帮助开发者轻松管理和监控分布式任务。ElasticJob-UI包含了针对ElasticJob-Lite和ElasticJ
    

    • 

  • YOLOv5 | 源码解析 | 计算损失loss原理——独家原创注释
kay_545
YOLOv8改进有效涨点Yolov5改进YOLOpython开发语言

    ⭐欢迎大家订阅我的专栏一起学习⭐订阅专栏，更新及时查看不迷路YOLOv5涨点专栏：http://t.csdnimg.cn/D9kR0YOLOv8涨点专栏：http://t.csdnimg.cn/5hNr8YOLOv7专栏：http://t.csdnimg.cn/hJsf1魔改网络、复现论文、优化创新各位订阅YOLOv8专栏读者，非常抱歉，这篇文章加错专栏了，但是因为是订阅的，所以不能删除或者移动这
    

    • 

  • SeaweedFS部署
仙女陈
linux

    SeaweedFS介绍SeaweedFS是一个分布式文件系统应用场景：主要用于存储处理小文件、大文件分块成小文件上传Githup地址：https://github.com/chrislusf/seaweedfs官方文档：https://github.com/chrislusf/seaweedfs/wikiseaweedfs源码解析：https://www.bbsmax.com/A/6pdDYXQK
    

    • 

  • 【axios】从源码解析axios拦截器是如何工作的
web安全学习资源库
前端javascriptvue.js

    本文所用axios版本号为：1.3.2。axios拦截器的配置方式axios中有两种拦截器：axios.interceptors.request.use(onFulfilled,onRejected,options)：配置请求拦截器。*onFulfilled方法在发送请求前执行，接收config对象，返回一个新的config对象，可在此方法内修改config对象。*onRejected方法在onF
    

    • 

  • 快速排序详解！c语言
自律的阿龙
数据结构c语言数据结构算法c语言排序算法

    目录快速排序是什么？快速排序的三种方法！快速排序的优化1.hore法（初代目）hore法的源码源码解析2.挖坑法（常用）！！！！挖坑法源码3.前后指针法（常用）前后指针代码4.非递归法快速排序全过程图快速排序是什么？快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法快速排序顾名思义，快速的排序，事实也如此，他的应用面广泛同时确实很快，因为他的时间复杂度是o（nlogn），相比前面的
    

    • 

  • 将Spring Cloud项目改造为Spring-cloud-kubernetes项目
公众号-芋道源码
中间件javalinux数据库springboot

    点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天10:33更新文章，每天掉亿点点头发...源码精品专栏原创|Java2021超神之路，很肝~中文详细注释的开源项目RPC框架Dubbo源码解析网络应用框架Netty源码解析消息中间件RocketMQ源码解析数据库中间件Sharding-JDBC和MyCAT源码解析作业调度中间件Elastic-Job源码解析分布式事务
    

    • 

  • ConcurrentHashMap的死循环问题
JWASX
源码分析哈希算法java散列表

    文章目录前言1.情景复现2.源码解析3.代码调试4.原因5.解决前言对于ConcurrentHashMap来说，能保证多线程下的安全问题，但是在JDK1.8中还是会出现一个bug，就是computeIfAbsent，下面就来详细说说死循环的原因1.情景复现首先就是bug的复现，首先了解下computeIfAbsent这个方法有什么用，其实方法第二个参数lambda表达式的意思就是如果找不到对应的k
    

    • 

  • Flink1.14源码解析Reactive-mode自动扩缩容
Better~Me
公开专栏大数据Flink内核源码解读flinkReactive-mode自动扩缩

    已付费购买专栏的朋友，请在申请查看权限时，备注你的CSDN名称才能通过查看权限，谢谢配合，谢谢理解。如未购买，请购买专栏，再申请。文章部分截图如下：更多详情请见以下链接：【腾讯文档】Flink源码中Reactive-Mode自动扩缩容关于扩容的处理
    

    • 

  • Redisson 如何实现分布式锁
不怕天黑_0819

    针对项目中使用的分布式锁进行简单的示例配置以及源码解析，并列举源码中使用到的一些基础知识点，但是没有对redisson中使用到的netty知识进行解析。本篇主要是对以下几个方面进行了探索Maven配置RedissonLock简单示例源码中使用到的Redis命令源码中使用到的lua脚本语义源码分析Maven配置org.redissonredisson2.2.12com.fasterxml.jacks
    

    • 

  • 若依前后端分离如何写移动端接口_前后端分离架构概述
weixin_39637661
若依前后端分离如何写移动端接口

    1、背景2、未分离时代（各种耦合）3、半分离时代4、分离时代5、总结参考《Java2019超神之路》《Dubbo实现原理与源码解析——精品合集》《Spring实现原理与源码解析——精品合集》《MyBatis实现原理与源码解析——精品合集》《SpringMVC实现原理与源码解析——精品合集》《SpringBoot实现原理与源码解析——精品合集》《数据库实体设计合集》《Java面试题——精品合集》《J
    

    • 

  • 呵呵，一个 bug 你改了两天？难吗？
Java基基

    点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创|Java2020超神之路，很肝~中文详细注释的开源项目RPC框架Dubbo源码解析网络应用框架Netty源码解析消息中间件RocketMQ源码解析数据库中间件Sharding-JDBC和MyCAT源码解析作业调度中间件Elastic-Job源码解析分布式事务中间件TCC-Transaction源码解析Eurek
    

    • 

  • 【Spring源码分析】解析配置类-ConfigurationClassPostProcessor源码分析
假正经的小柴
Java源码分析spring数据库前端

    阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
    

    • 

  • Slf4j 源码解析二-添加 slf4j-simple 日志实现框架
当当一丢丢

    主题本篇是Slf4j源码解析的第二篇，上篇介绍了无日志实现框架的执行流程本篇解析添加slf4j-simple日志实现框架的脉络已经知道：org/sfl4j/impl/StaticLoggerBinder.class是连接日志实现框架和Slf4jfacade的桥梁先浏览下slf4j-simple.jar的目录结构关键是探求如何与Slf4j-api.jarfacade关联的，实现框架项目的复杂简单no
    

    • 

  • Java集合篇之深入解析LinkedList
液态不合群
java开发语言

    写在开头作为ArrayList的同门师兄弟，LinkedList的师门地位逊色不少，除了在做算法题的时候我们会用到它之外，在实际的开发工作中我们极少使用它，就连它的创造者都说：“Iwroteit，andIneveruseit”，想想颇有点好笑，但这并不影响我们去学习它，个人认为它底层的链表逻辑对于我们代码思想的培养还是挺有帮助的。源码解析看过build哥文章的同学应该都知道，俺喜欢通过源码去学习和
    

    • 

  • Glide 源码解析 之 关键类简介
詹徐照

    Glide关键类介绍Glide单例，负责全局配置/***Asingletontopresentasimplestaticinterfaceforbuildingrequestswith*{@linkRequestBuilder}andmaintainingan{@linkEngine},{@linkBitmapPool},*{@linkcom.bumptech.glide.load.engine.
    

    • 

  • 类加载机制（2）类加载器源码解析
飞奔的口罩

    目录一、类加载器1、BootstrapClassLoader启动类加载器2、ExtensionClassLoader扩展类加载器3、ApplicationClassLoader应用类加载器4、CustomClassLoader自定义类加载器5、线程上下文类加载器二、java虚拟机入口应用：sun.misc.Launcher1、sun.misc.Launcher主入口2、内部类ExtClassLoa
    

    • 

  • 小游戏和GUI编程(7) | SimpleNN 界面源码解析
baiyu33
SFMLGUICNNMNISTLeNet手写数字识别

    小游戏和GUI编程(7)|SimpleNN界面源码解析0.简介SimpleNN是AdamYuan在高中一年级时用1天时间写出来的简易CNN,使用SFML做UI,用于交互式输入手写数字，这个数字被训练好的CNN网络执行推理得到识别结果,它的运行效果如下：这一篇我们来分析UI界面的代码,规划如下:完成本地构建(预计5分钟)确定和粗读UI代码(预计30分钟)拆解UI部件和自行重新实现(预计2小时)实际用
    

    • 

  • Spring AOP源码解析(二)
anyoptional

    前言  上一篇中我们扒拉了一下spring-aop的底裤，详细解读了spring-aop中的各种抽象概念，本篇开始我们一起研究研究spring-aop的织入过程（基于5.2.6.RELEASE）。建议各位同学本地打开一份源码对照食用，效果更佳。  前方高能！！！本篇重度依赖于上一篇解读的抽象概念，不熟悉的同学请速速撤离，以免误伤。  正式开始之前，各位同学还请思考一下，在拥有了关于AOP的全局视角
    

    • 

  • Netty Review - ServerBootstrap源码解析
小小工匠
【Netty】ServerBootstrapNetty

    文章目录概述源码分析小结概述ServerBootstrapbootstrap=newServerBootstrap();bootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG,1024).childHandler(newChannelIn
    

    • 

  • 我给 Netty 提交了一个 bug
公众号：码海
内核unixepollhashtableuefi

    本系列Netty源码解析文章基于4.1.56.Final版本写在前面.....本文是笔者肉眼盯Bug系列的第三弹，前两弹分别是:抓到Netty一个Bug，顺带来透彻地聊一下Netty是如何高效接收网络连接的，在这篇文章中盯出了一个在Netty接收网络连接时，影响吞吐量的一个Bug。抓到Netty一个隐藏很深的内存泄露Bug|详解Recycler对象池的精妙设计与实现，在这篇文章中盯出了一个Nett
    

    • 

  • PHP，安卓，UI，java，linux视频教程合集
cocos2d-x小菜
javaUIlinuxPHPandroid

    ╔-----------------------------------╗┆                           
    

    • 

  • zookeeper admin 笔记
braveCS
zookeeper

     
Required Software
1) JDK>=1.6
2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines
3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘
 
数据和日志目录
1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
    

    • 

  • Spring配置多个连接池
easterfly
spring

    项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？
Spring中有关于dataSource的配置：
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  &nb
    

    • 

  • Mysql
171815164
mysql

    例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。
GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI
TH GRANT OPTION;
如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
    

    • 

  • CommonDAO（公共/基础DAO）
g21121
DAO

            好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。
        DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
    

    • 

  • 直言有讳
永夜-极光
感悟随笔

     
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313
 
精华:
“直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
    

    • 

  • 安装CentOS 7 和Win 7后，Win7 引导丢失
随便小屋
centos

    一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。
一、首先具有root 的权限。
     即进入Terminal后输入命令su，然后输入密码即可
二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改
v
    

    • 

  • Oracle备份与恢复案例
aijuans
oracle

    Oracle备份与恢复案例
一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
    

    • 

  • JavaEE开源快速开发平台G4Studio v5.0发布
無為子

     
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。
 
访问G4Studio网站
http://www.g4it.org  
2013-04-06 发布G4Studio_V5.0版本
功能新增
(1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
    

    • 

  • Oracle显示根据高考分数模拟录取
百合不是茶
PL/SQL编程oracle例子模拟高考录取学习交流

    题目要求:
1,创建student表和result表
2,pl/sql对学生的成绩数据进行处理
3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选
 
 
1,创建student表,和result表
学生信息表;
create table student(
student_id number primary key,--学生id
    

    • 

  • 优秀的领导与差劲的领导
bijian1013
领导管理团队

    责任
优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。
差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。
努力工作
优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
    

    • 

  • js函数在浏览器下的兼容
Bill_chen
jquery浏览器IEDWRext

      做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同：
  IE6：node.nextSibling,对于FF是不能识别的；
  FF：node.nextElementSibling,对于IE是不能识别的；
兼容解决方式：var Div = node.nextSibl
    

    • 

  • 【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC)
bit1129
垃圾回收

    吞吐量与用户线程暂停时间
 
衡量垃圾回收算法优劣的指标有两个：
吞吐量越高，则算法越好
暂停时间越短，则算法越好
首先说明吞吐量和暂停时间的含义。
 
垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
    

    • 

  • J2EE监听器和过滤器基础
白糖_
J2EE

     Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。
监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。
 
ServletContex监听器
ServletContex又叫application
    

    • 

  • 博弈AngularJS讲义(16) - 提供者
boyitech
jsAngularJSapiAngularProvider

      Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。
  那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
    

    • 

  • java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
bylijinnan
java

    
public class CommonSubSequence {
/**
* 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
* 写一个版本算法复杂度O(N^2)和一个O(N) 。
*
* O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。
* O(
    

    • 

  • sqlserver 2000 无法验证产品密钥
Chen.H
sqlwindowsSQL ServerMicrosoft

    在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。 这样做, 收到以下错误信息CD KEY的 SQ
    

    • 

  • [新概念武器]气象战争
comsci

    
       气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织....
       原因如下:
       地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
    

    • 

  • oracle 中 rollup、cube、grouping 使用详解
daizj
oraclegroupingrollupcube

    oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示 转自namesliu
-- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景 
 
--- ROLLUP ， 为了理解分组的成员数量，我增加了 分组的计数  COUNT(SAL) 
 
    

    • 

  • 技术资料汇总分享
Dead_knight
技术资料汇总 分享

    本人汇总的技术资料，分享出来，希望对大家有用。
http://pan.baidu.com/s/1jGr56uE
资料主要包含：
Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...)
Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...)
Ser
    

    • 

  • 初一下学期难记忆单词背诵第一课
dcj3sjt126com
englishword

    could 能够
minute 分钟
Tuesday 星期二
February 二月
eighteenth 第十八
listen 听
careful 小心的，仔细的
short 短的
heavy 重的
empty 空的
certainly 当然
carry 携带；搬运
tape 磁带
basket 蓝子
bottle 瓶
juice 汁，果汁
head 头；头部

    

    • 

  • 截取视图的图片, 然后分享出去
dcj3sjt126com
OSObjective-C

    OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast.
I implemented a category method on UIView to get the vi
    

    • 

  • MySql重置密码
fanxiaolong
MySql重置密码

    方法一:
 在my.ini的[mysqld]字段加入：
skip-grant-tables
重启mysql服务，这时的mysql不需要密码即可登录数据库
 然后进入mysql
mysql>use mysql;
 mysql>更新 user set password=password('新密码') WHERE User='root';
mysq
    

    • 

  • Ehcache（03）——Ehcache中储存缓存的方式
234390216
ehcacheMemoryStoreDiskStore存储驱除策略

    Ehcache中储存缓存的方式
 
目录
1     堆内存（MemoryStore）
1.1     指定可用内存
1.2     驱除策略
1.3     元素过期
2   &nbs
    

    • 

  • spring mvc中的@propertysource
jackyrong
spring mvc

      在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了：
@PropertySource  在spring 3.1中开始引入
比如有配置文件
config.properties
mongodb.url=1.2.3.4
mongodb.db=hello
则代码中
 
@PropertySource(&
    

    • 

  • 重学单例模式
lanqiu17
单例Singleton模式

    最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。
第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。
单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式
静态内部类方式:
package test.pattern.singleton.statics;
publ
    

    • 

  • .NET开源核心运行时，且行且珍惜
netcome
java.net开源

    背景
2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
    

    • 

  • 使用oscahe缓存技术减少与数据库的频繁交互
Everyday都不同
Web高并发oscahe缓存

    此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。
 
缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
    

    • 

  • Spring+Mybatis 手动控制事务
toknowme
mybatis

    @Override
   public boolean testDelete(String jobCode) throws Exception {
      boolean flag = false;
 &nbs
    

    • 

  • 菜鸟级的android程序员面试时候需要掌握的知识点
xp9802
android

    熟悉Android开发架构和API调用
掌握APP适应不同型号手机屏幕开发技巧
熟悉Android下的数据存储 
熟练Android Debug Bridge Tool
熟练Eclipse/ADT及相关工具 
熟悉Android框架原理及Activity生命周期
熟练进行Android UI布局
熟练使用SQLite数据库；
熟悉Android下网络通信机制，S
    

    •