自定义周期定时任务实现逻辑

概述

        我之前写过《SpringBoot集成xxl-job》，xxl-job就是一个定时任务调用插件，可以在平台上灵活配置任务调用周期。但有时产品需求需要在自己的平台上配置任务定时执行周期，根据此周期来实现业务。比如，设置每周发送任务到张三，这儿不管是任务还是张三，都是可以让甲方人员自行修改的，此时就需要自己来实现定时调用逻辑了。

        下面我分享一下我的实现逻辑。

需求

        实现每周（可配置）发送一条短信给张三。

分析

        首先每周这个时间维度可配置，那么就需要有一个定时执行时间，我们可以用定时器CronExpression表达式来保存配置，如0 0 0 1 0 1 表示每周一。发送短信是需要实时器执行的任务，张三是配置里的人员。还需要记录下上次执行时间和下次执行时间，这样就有三个参数

cron	定时执行周期，如0 0 0 1 0 1
trigger_last_time	上一次执行时间，毫秒级时间戳，如1716426633000
trigger_next_time	下一次执行时间，毫秒级时间戳，如1716426633000

实现思路

        每隔10秒扫描配置，查询是否存在当前时间大于trigger_next_time（下一次执行时间）的数据，若存在，则执行发送短信任务，并将执行时间设置到trigger_last_time中，并根据cron计算下次执行时间，设置到trigger_next_time中；若不存在，则继续下一次检查。如下图

实现代码

        主要业务代码如下，提供一个实现框架，部分业务程序需要自己实现

public class JobScheduleHelper {
    private static Logger logger = LoggerFactory.getLogger(JobScheduleHelper.class);

    public static JobScheduleHelper instance = new JobScheduleHelper();

    public static JobScheduleHelper getInstance() {
        return instance;
    }

    private Thread scheduleThread;
    private volatile boolean scheduleThreadToStop = false;
    public static final long PRE_READ_MS = 10000;    // pre read

    //程序启动时调用
    public void start(){
        scheduleThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.MILLISECONDS.sleep(10000 - System.currentTimeMillis()%1000 );
                } catch (InterruptedException e) {
                    if (!scheduleThreadToStop) {
                        logger.error(e.getMessage(), e);
                    }
                }
                while (!scheduleThreadToStop){
                    long start = System.currentTimeMillis();

                    try {
                        long nowTime = System.currentTimeMillis();
                        
                        //TODO 获取下次执行时间配置，此处可用业务方法替换
                        List<StSchedConf> list = null;

                        if (!CollectionUtils.isEmpty(list)){
                            for (StSchedConf conf:list){
                                //判断当前时间是否超过下次执行时间
                                if(nowTime>conf.getTriggerNextTime()){
                                    //TODO 调用发送短信方法
                                    

                                    //生成下次执行时间
                                    Date nextValidTime = generateNextValidTime(conf.getCron(), date);
                                    //TODO更新上次和下次调用时间
    
                                }
                            }

                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }

                    long cost = System.currentTimeMillis()-start;
                    if (cost < 1000) {  // scan-overtime, not wait
                        try {
                            // 休息10s
                            TimeUnit.MILLISECONDS.sleep((PRE_READ_MS) - System.currentTimeMillis()%1000);
                        } catch (InterruptedException e) {
                            if (!scheduleThreadToStop) {
                                logger.error(e.getMessage(), e);
                            }
                        }
                    }
                }
            }
        });
        scheduleThread.setDaemon(true);
        scheduleThread.setName("job, JobScheduleHelper#scheduleThread");
        scheduleThread.start();
    }


    //生成下次执行时间
    public static Date generateNextValidTime(String conf, Date fromTime) throws Exception {
        Date nextValidTime = new CronExpression(conf).getNextValidTimeAfter(fromTime);
        return nextValidTime;
    }
    
    //程序结束时调用
    public void toStop(){

        // 1、stop schedule
        scheduleThreadToStop = true;
        try {
            TimeUnit.SECONDS.sleep(1);  // wait
        } catch (InterruptedException e) {
            logger.error(e.getMessage(), e);
        }
        if (scheduleThread.getState() != Thread.State.TERMINATED){
            // interrupt and wait
            scheduleThread.interrupt();
            try {
                scheduleThread.join();
            } catch (InterruptedException e) {
                logger.error(e.getMessage(), e);
            }
        }
        logger.info(">>>>>>>>>>> job, JobScheduleHelper stop");
    }

}

        以上程序在执行后，每10s会调用一次while中程序体，程序体中检测当前时间是否超过配置时间，超过则执行发送信息，以此方式可实现自定义周期定时任务。

附

获取下次执行时间代码，提取码: much