聊聊PowerJob的任务调度

最新推荐文章于 2024-06-26 22:44:40 发布
最新推荐文章于 2024-06-26 22:44:40 发布
阅读量1.1k 收藏 19
点赞数 21
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hello_ejb3/article/details/136088172
版权
本文详细分析了PowerJob中的CoreScheduleTaskManager类，介绍了如何通过LoopRunnable启动多个线程进行任务调度，包括定时调度CRON、DAILY_TIME_INTERVAL任务，CRONWorkflow任务，频繁任务调度，数据清理，以及实例状态检查。
摘要由CSDN通过智能技术生成

序

本文主要研究一下PowerJob的任务调度

CoreScheduleTaskManager

tech/powerjob/server/core/scheduler/CoreScheduleTaskManager.java

@Service
@Slf4j
@RequiredArgsConstructor
public class CoreScheduleTaskManager implements InitializingBean, DisposableBean {


    private final PowerScheduleService powerScheduleService;

    private final InstanceStatusCheckService instanceStatusCheckService;

    private final List<Thread> coreThreadContainer = new ArrayList<>();


    @SuppressWarnings("AlibabaAvoidManuallyCreateThread")
    @Override
    public void afterPropertiesSet() {
        // 定时调度
        coreThreadContainer.add(new Thread(new LoopRunnable("ScheduleCronJob", PowerScheduleService.SCHEDULE_RATE, () -> powerScheduleService.scheduleNormalJob(TimeExpressionType.CRON)), "Thread-ScheduleCronJob"));
        coreThreadContainer.add(new Thread(new LoopRunnable("ScheduleDailyTimeIntervalJob", PowerScheduleService.SCHEDULE_RATE, () -> powerScheduleService.scheduleNormalJob(TimeExpressionType.DAILY_TIME_INTERVAL)), "Thread-ScheduleDailyTimeIntervalJob"));
        coreThreadContainer.add(new Thread(new LoopRunnable("ScheduleCronWorkflow", PowerScheduleService.SCHEDULE_RATE, powerScheduleService::scheduleCronWorkflow), "Thread-ScheduleCronWorkflow"));
        coreThreadContainer.add(new Thread(new LoopRunnable("ScheduleFrequentJob", PowerScheduleService.SCHEDULE_RATE, powerScheduleService::scheduleFrequentJob), "Thread-ScheduleFrequentJob"));
        // 数据清理
        coreThreadContainer.add(new Thread(new LoopRunnable("CleanWorkerData", PowerScheduleService.SCHEDULE_RATE, powerScheduleService::cleanData), "Thread-CleanWorkerData"));
        // 状态检查
        coreThreadContainer.add(new Thread(new LoopRunnable("CheckRunningInstance", InstanceStatusCheckService.CHECK_INTERVAL, instanceStatusCheckService::checkRunningInstance), "Thread-CheckRunningInstance"));
        coreThreadContainer.add(new Thread(new LoopRunnable("CheckWaitingDispatchInstance", InstanceStatusCheckService.CHECK_INTERVAL, instanceStatusCheckService::checkWaitingDispatchInstance), "Thread-CheckWaitingDispatchInstance"));
        coreThreadContainer.add(new Thread(new LoopRunnable("CheckWaitingWorkerReceiveInstance", InstanceStatusCheckService.CHECK_INTERVAL, instanceStatusCheckService::checkWaitingWorkerReceiveInstance), "Thread-CheckWaitingWorkerReceiveInstance"));
        coreThreadContainer.add(new Thread(new LoopRunnable("CheckWorkflowInstance", InstanceStatusCheckService.CHECK_INTERVAL, instanceStatusCheckService::checkWorkflowInstance), "Thread-CheckWorkflowInstance"));

        coreThreadContainer.forEach(Thread::start);
    }

    //......
}

CoreScheduleTaskManager在afterPropertiesSet的时候会启动一系列的线程，它们都是LoopRunnable类型的，分别调度powerScheduleService.scheduleNormalJob(TimeExpressionType.CRON)、powerScheduleService.scheduleNormalJob(TimeExpressionType.DAILY_TIME_INTERVAL)、powerScheduleService::scheduleCronWorkflow、powerScheduleService::scheduleFrequentJob、powerScheduleService::cleanData、instanceStatusCheckService::checkRunningInstance、instanceStatusCheckService::checkWaitingDispatchInstance、instanceStatusCheckService::checkWaitingWorkerReceiveInstance、instanceStatusCheckService::checkWorkflowInstance

LoopRunnable

    @RequiredArgsConstructor
    private static class LoopRunnable implements Runnable {

        private final String taskName;

        private final Long runningInterval;

        private final Runnable innerRunnable;

        @SuppressWarnings("BusyWait")
        @Override
        public void run() {
            log.info("start task : {}.", taskName);
            while (true) {
                try {
                    innerRunnable.run();
                    Thread.sleep(runningInterval);
                } catch (InterruptedException e) {
                    log.warn("[{}] task has been interrupted!", taskName, e);
                    break;
                } catch (Exception e) {
                    log.error("[{}] task failed!", taskName, e);
                }
            }
        }
    }

LoopRunnable的构造器接收taskName、runningInterval、innerRunnable三个参数，其run方法通过while true循环内部执行innerRunnable.run()，执行完sleep指定的runningInterval，若捕获到InterruptedException则break跳出循环，若其他异常则打印error日志

PowerScheduleService

PowerScheduleService主要提供了scheduleNormalJob、scheduleCronWorkflow、scheduleFrequentJob、cleanData方法

scheduleNormalJob

tech/powerjob/server/core/scheduler/PowerScheduleService.java

    public void scheduleNormalJob(TimeExpressionType timeExpressionType) {
        long start = System.currentTimeMillis();
        // 调度 CRON 表达式 JOB
        try {
            final List<Long> allAppIds = appInfoRepository.listAppIdByCurrentServer(transportService.defaultProtocol().getAddress());
            if (CollectionUtils.isEmpty(allAppIds)) {
                log.info("[NormalScheduler] current server has no app's job to schedule.");
                return;
            }
            scheduleNormalJob0(timeExpressionType, allAppIds);
        } catch (Exception e) {
            log.error("[NormalScheduler] schedule cron job failed.", e);
        }
        long cost = System.currentTimeMillis() - start;
        log.info("[NormalScheduler] {} job schedule use {} ms.", timeExpressionType, cost);
        if (cost > SCHEDULE_RATE) {
            log.warn("[NormalScheduler] The database query is using too much time({}ms), please check if the database load is too high!", cost);
        }
    }

scheduleNormalJob方法主要是查询当前server负责的appId列表，然后内部委托改为scheduleNormalJob0

scheduleNormalJob0

    private void scheduleNormalJob0(TimeExpressionType timeExpressionType, List<Long> appIds) {

        long nowTime = System.currentTimeMillis();
        long timeThreshold = nowTime + 2 * SCHEDULE_RATE;
        Lists.partition(appIds, MAX_APP_NUM).forEach(partAppIds -> {

            try {

                // 查询条件：任务开启 + 使用CRON表达调度时间 + 指定appId + 即将需要调度执行
                List<JobInfoDO> jobInfos = jobInfoRepository.findByAppIdInAndStatusAndTimeExpressionTypeAndNextTriggerTimeLessThanEqual(partAppIds, SwitchableStatus.ENABLE.getV(), timeExpressionType.getV(), timeThreshold);

                if (CollectionUtils.isEmpty(jobInfos)) {
                    return;
                }

                // 1. 批量写日志表
                Map<Long, Long> jobId2InstanceId = Maps.newHashMap();
                log.info("[NormalScheduler] These {} jobs will be scheduled: {}.", timeExpressionType.name(), jobInfos);

                jobInfos.forEach(jobInfo -> {
                    Long instanceId = instanceService.create(jobInfo.getId(), jobInfo.getAppId(), jobInfo.getJobParams(), null, null, jobInfo.getNextTriggerTime()).getInstanceId();
                    jobId2InstanceId.put(jobInfo.getId(), instanceId);
                });
                instanceInfoRepository.flush();

                // 2. 推入时间轮中等待调度执行
                jobInfos.forEach(jobInfoDO -> {

                    Long instanceId = jobId2InstanceId.get(jobInfoDO.getId());

                    long targetTriggerTime = jobInfoDO.getNextTriggerTime();
                    long delay = 0;
                    if (targetTriggerTime < nowTime) {
                        log.warn("[Job-{}] schedule delay, expect: {}, current: {}", jobInfoDO.getId(), targetTriggerTime, System.currentTimeMillis());
                    } else {
                        delay = targetTriggerTime - nowTime;
                    }

                    InstanceTimeWheelService.schedule(instanceId, delay, () -> dispatchService.dispatch(jobInfoDO, instanceId, Optional.empty(), Optional.empty()));
                });

                // 3. 计算下一次调度时间（忽略5S内的重复执行，即CRON模式下最小的连续执行间隔为 SCHEDULE_RATE ms）
                jobInfos.forEach(jobInfoDO -> {
                    try {
                        refreshJob(timeExpressionType, jobInfoDO);
                    } catch (Exception e) {
                        log.error("[Job-{}] refresh job failed.", jobInfoDO.getId(), e);
                    }
                });
                jobInfoRepository.flush();


            } catch (Exception e) {
                log.error("[NormalScheduler] schedule {} job failed.", timeExpressionType.name(), e);
            }
        });
    }

scheduleNormalJob0主要是调度CRON、DAILY_TIME_INTERVAL类型的任务，它通过jobInfoRepository查找指定appId、状态启用、指定TimeExpressionType，以及NextTriggerTime小于等于nowTime + 2 * SCHEDULE_RATE的任务，然后挨个执行instanceService.create创建任务实例，然后放入到InstanceTimeWheelService.schedule进行调度，最后计算和更新一下每个job的nextTriggerTime

scheduleCronWorkflow

    public void scheduleCronWorkflow() {
        long start = System.currentTimeMillis();
        // 调度 CRON 表达式 WORKFLOW
        try {
            final List<Long> allAppIds = appInfoRepository.listAppIdByCurrentServer(transportService.defaultProtocol().getAddress());
            if (CollectionUtils.isEmpty(allAppIds)) {
                log.info("[CronWorkflowSchedule] current server has no app's workflow to schedule.");
                return;
            }
            scheduleWorkflowCore(allAppIds);
        } catch (Exception e) {
            log.error("[CronWorkflowSchedule] schedule cron workflow failed.", e);
        }
        long cost = System.currentTimeMillis() - start;
        log.info("[CronWorkflowSchedule] cron workflow schedule use {} ms.", cost);
        if (cost > SCHEDULE_RATE) {
            log.warn("[CronWorkflowSchedule] The database query is using too much time({}ms), please check if the database load is too high!", cost);
        }
    }

scheduleCronWorkflow主要是调度CRON 表达式 WORKFLOW，内部委托给scheduleWorkflowCore

scheduleFrequentJob

    public void scheduleFrequentJob() {
        long start = System.currentTimeMillis();
        // 调度 FIX_RATE/FIX_DELAY 表达式 JOB
        try {
            final List<Long> allAppIds = appInfoRepository.listAppIdByCurrentServer(transportService.defaultProtocol().getAddress());
            if (CollectionUtils.isEmpty(allAppIds)) {
                log.info("[FrequentJobSchedule] current server has no app's job to schedule.");
                return;
            }
            scheduleFrequentJobCore(allAppIds);
        } catch (Exception e) {
            log.error("[FrequentJobSchedule] schedule frequent job failed.", e);
        }
        long cost = System.currentTimeMillis() - start;
        log.info("[FrequentJobSchedule] frequent job schedule use {} ms.", cost);
        if (cost > SCHEDULE_RATE) {
            log.warn("[FrequentJobSchedule] The database query is using too much time({}ms), please check if the database load is too high!", cost);
        }
    }

scheduleFrequentJob主要是调度FIX_RATE/FIX_DELAY 表达式 JOB，内部委托给了scheduleFrequentJobCore

scheduleFrequentJobCore

    private void scheduleFrequentJobCore(List<Long> appIds) {

        Lists.partition(appIds, MAX_APP_NUM).forEach(partAppIds -> {
            try {
                // 查询所有的秒级任务（只包含ID）
                List<Long> jobIds = jobInfoRepository.findByAppIdInAndStatusAndTimeExpressionTypeIn(partAppIds, SwitchableStatus.ENABLE.getV(), TimeExpressionType.FREQUENT_TYPES);
                if (CollectionUtils.isEmpty(jobIds)) {
                    return;
                }
                // 查询日志记录表中是否存在相关的任务
                List<Long> runningJobIdList = instanceInfoRepository.findByJobIdInAndStatusIn(jobIds, InstanceStatus.GENERALIZED_RUNNING_STATUS);
                Set<Long> runningJobIdSet = Sets.newHashSet(runningJobIdList);

                List<Long> notRunningJobIds = Lists.newLinkedList();
                jobIds.forEach(jobId -> {
                    if (!runningJobIdSet.contains(jobId)) {
                        notRunningJobIds.add(jobId);
                    }
                });

                if (CollectionUtils.isEmpty(notRunningJobIds)) {
                    return;
                }

                notRunningJobIds.forEach(jobId -> {
                    Optional<JobInfoDO> jobInfoOpt = jobInfoRepository.findById(jobId);
                    jobInfoOpt.ifPresent(jobInfoDO -> {
                        LifeCycle lifeCycle = LifeCycle.parse(jobInfoDO.getLifecycle());
                        // 生命周期已经结束
                        if (lifeCycle.getEnd() != null && lifeCycle.getEnd() < System.currentTimeMillis()) {
                            jobInfoDO.setStatus(SwitchableStatus.DISABLE.getV());
                            jobInfoDO.setGmtModified(new Date());
                            jobInfoRepository.saveAndFlush(jobInfoDO);
                            log.info("[FrequentScheduler] disable frequent job,id:{}.", jobInfoDO.getId());
                        } else if (lifeCycle.getStart() == null || lifeCycle.getStart() < System.currentTimeMillis() + SCHEDULE_RATE * 2) {
                            log.info("[FrequentScheduler] schedule frequent job,id:{}.", jobInfoDO.getId());
                            jobService.runJob(jobInfoDO.getAppId(), jobId, null, Optional.ofNullable(lifeCycle.getStart()).orElse(0L) - System.currentTimeMillis());
                        }
                    });
                });
            } catch (Exception e) {
                log.error("[FrequentScheduler] schedule frequent job failed.", e);
            }
        });
    }

scheduleFrequentJobCore主要是调度秒级任务，它先找出秒级任务的id，然后过滤掉正在运行的任务，剩下的未运行的任务挨个判断是否需要调度，需要则执行jobService.runJob

cleanData

    public void cleanData() {
        try {
            final List<Long> allAppIds = appInfoRepository.listAppIdByCurrentServer(transportService.defaultProtocol().getAddress());
            if (allAppIds.isEmpty()) {
                return;
            }
            WorkerClusterManagerService.clean(allAppIds);
        } catch (Exception e) {
            log.error("[CleanData] clean data failed.", e);
        }
    }

cleanData主要是通过WorkerClusterManagerService.clean来维护当前server负责的appId缓存

InstanceStatusCheckService

InstanceStatusCheckService提供了checkRunningInstance、checkWaitingDispatchInstance、checkWaitingWorkerReceiveInstance、checkWorkflowInstance方法

小结

PowerJob的CoreScheduleTaskManager在afterPropertiesSet的时候会启动一系列的线程，它们都是LoopRunnable类型的，其中scheduleNormalJob主要是调度CRON、DAILY_TIME_INTERVAL类型的任务，scheduleCronWorkflow主要是调度CRON 表达式 WORKFLOW任务，scheduleFrequentJob主要是调度FIX_RATE/FIX_DELAY 表达式 JOB。

hello_ejb3
关注
PowerJob容器的使用（创建一个外置动态加载的任务）
qq3892997的博客
08-24 475
powerJob容器的使用
架构师修炼系列【分布式任务调度框架Power-Job】
一块大洋
04-23 3825
PowerJob可以被认为是第三代任务调度框架，它是新一代分布式任务调度与计算框架，支持CRON、API、固定频率、固定延迟等调度策略，提供工作流来编排任务解决依赖关系，能让您轻松完成作业的调度与繁杂任务的分布式计算，在任务调度的基础上，还额外提供了分布式计算和工作流功能
PowerJob 任务调度框架 v3.3.3
12-08
为您提供PowerJob 任务调度框架下载，PowerJob是全新一代分布式调度与计算框架，支持CRON、API、固定频率、固定延迟等调度策略，提供工作流来编排任务解决依赖关系，使用简单，功能强大，文档齐全，能让您轻松完成作业的调度与繁杂任务的分布式计算。PowerJob特点：使用简单：提供前端Web界面，允许开发者可视化地完成调度任务的管理（增、删、改、查）、任务运行状态监控和运行日志查看等功能。定时策略完善：支持CRON表达式、固定频率
Java任务调度之PowerJob分布式任务调度
netuser1937的博客
06-25 1641
1、pom.xml引用依赖 <dependency> <groupId>tech.powerjob</groupId> <artifactId>powerjob-worker-spring-boot-starter</artifactId> <version>4.0.1</version> </dependenc
分布式定时任务框架 PowerJob
咖啡有点苦的博客
06-15 3204
PowerJob（原OhMyScheduler）是全新一代分布式任务调度与计算框架，其主要功能特性如下使用简单：提供前端Web界面，允许开发者可视化地完成调度任务的管理（增、删、改、查）、任务运行状态监控和运行日志查看等功能。定时策略完善：支持 CRON 表达式、固定频率、固定延迟和API四种定时调度策略。执行模式丰富：支持单机、广播、Map、MapReduce 四种执行模式，其中 Map/MapReduce 处理器能使开发者寥寥数行代码便获得集群分布式计算的能力。工作流支持。
Powerjob之时间同步引起的无法正常调度问题既欧拉系统配置NTP服务
提子同学是我
05-09 624
两台系统都一直好端端地跑了半年了，突然有一天，应用的任务没有正常被调度，凌晨两点的时候调度任务还是正常的，六点的时候调度任务就开始没被执行了。在powerjob的调度服务器上，可以看得到我的应用是掉线了的状态，显示的是灰色的。我也就简单随意的对比了两遍的时间，相差不多就得了吧~（之前也看到有相差了近一分钟的，所以看到了数值差异不大，就主观任务差的不多了），后续也就没再往这个方向思考和研究。部署了两台服务器，一台是是powerjob的调度服务器，一台是我写的应用带有powerjob客户端。
SpringBoot整合PowerJob--使用/教程/实例
Java后端技术栈
04-11 4882
说明本文用示例介绍Power Job的用法。PowerJob是一个定时任务中间件（框架），优点很多，PowerJob官网的对比图中可以看到PowerJob比Quartz、XXL-JOB等更加优秀。SpringBoot--定时任务--选型/对比/框架_IT利刃出鞘的博客-CSDN博客官方PowerJobPowerJob 简介 · 语雀快速开始（本地IDE版） · 语雀相关网址PowerJob 简介 · 语雀。
PowerJob java任务调度框架 v3.3.0
11-03
为您提供PowerJob java任务调度框架下载，PowerJob是全新一代分布式调度与计算框架，支持CRON、API、固定频率、固定延迟等调度策略，提供工作流来编排任务解决依赖关系，使用简单，功能强大，文档齐全，能让您轻松...
PowerJob 任务调度框架 v3.3.2
12-08
为您提供PowerJob 任务调度框架下载，PowerJob是全新一代分布式调度与计算框架，支持CRON、API、固定频率、固定延迟等调度策略，提供工作流来编排任务解决依赖关系，使用简单，功能强大，文档齐全，能让您轻松完成...
PowerJob 任务调度框架 v3.4.1
01-12
为您提供PowerJob 任务调度框架下载，PowerJob是全新一代分布式调度与计算框架，支持CRON、API、固定频率、固定延迟等调度策略，提供工作流来编排任务解决依赖关系，使用简单，功能强大，文档齐全，能让您轻松完成...
PowerJob 任务调度框架 v3.4.0
12-08
为您提供PowerJob 任务调度框架下载，PowerJob是全新一代分布式调度与计算框架，支持CRON、API、固定频率、固定延迟等调度策略，提供工作流来编排任务解决依赖关系，使用简单，功能强大，文档齐全，能让您轻松完成...
powerjob的上手操作
最新发布
风雨无阻学习之路
06-26 1965
PowerJob是全新一代分布式任务调度与计算框架
项目终于用上了 PowerJob，真香！
码猿技术专栏
12-09 858
大家好，我是不才陈某~最近在调研分布式任务如何选型，最终选择了比较年轻的PowerJob，下面会简单介绍下这个框架的使用以及它的运行流程。 一、选择PowerJob的原因 1.1：同类产品对比官方文档给出的同类产品对比图：表1https://www.yuque.com/powerjob/guidence/ztn4i51.2：特点定制方面：代码较简单，易于理解和改造，比如我们就集成了自己的服务发现平...
Power-job OpenAPI使用方法
天码星空
11-08 1853
官网文档: https://www.yuque.com/powerjob/guidence/olgyf0。
较真儿学源码系列-PowerJob启动流程源码分析
天瑕的博客
09-26 1366
其中介绍了PowerJob的功能特点，以及与其他调度框架的对比，这里就不再赘述了。以上是PowerJob的架构图，取自官网。可以看出，PowerJob是典型的客户端/服务端交互的架构（但是在PowerJob中却没有一般分布式中间件会有的注册中心）。本文就从启动流程出发，来一起探究下PowerJob在启动阶段中都做了些什么动作。
Java 分布式任务调度平台：PowerJob 快速开始+配置详解
HelloGitHub 的博客
07-15 9280
本文适合有 Java 基础知识的人群作者：HelloGitHub-Salieri引言HelloGitHub 推出的《讲解开源项目》[1]系列。项目地址：https://github.co...
Java | 一分钟掌握定时任务 | 9 - PowerJob分布式定时任务
ddppfamily
05-26 3501
我们选择一套框架或者技术的时候，一定要知道它的特点和功能，不能为了(学习)技术而(选择)技术，那是对产品的不负责任。有定时执行需求的业务场景：如每天凌晨全量同步数据、生成业务报表、未支付订单超时取消等。有需要​​全部机器一同执行​​的业务场景：如使用广播执行模式清理集群日志。有需要​​分布式处理​​的业务场景：比如需要更新一大批数据，单机执行耗时非常长，可以使用Map/MapReduce 处理器完成任务的分发，调动整个集群加速计算。有需要​​延迟执行​​某些任务的业务场景：比如订单过期处理等。
powerjob定时任务报错问题
helam的专栏
05-13 710
powerjob
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值