Java如何实现分阶段间隔定时执行method/function 解决thread高资源占用问题

替代之前裸手写Thread循环的高耗资源实现，推荐使用JDK原生的ScheduledThreadPoolExecutor完成统一调度——这类调度器基于线程池复用、操作系统级挂起唤醒机制，空闲状态下几乎不占用CPU算力，完全不会出现拖慢服务器运行的问题。

时间规则对齐 #

以任务启动时刻为时间零点，严格匹配需求的分阶段边界：

• 总运行时长上限：5小时（300分钟），到点自动停止调度
• 第一阶段：0~10分钟区间，每2分钟调用一次目标方法
• 第二阶段：10~30分钟区间，每5分钟调用一次目标方法
• 第三阶段：30分钟~总时长上限区间，每10分钟调用一次目标方法

核心实现思路 #

不采用三个独立固定周期的调度任务（这类方案容易因为任务执行耗时产生时间累积偏差，打乱阶段切换节点），而是在每次目标方法执行完成后，根据当前实际运行的总时长，动态计算下一次任务的执行延迟，同时判断是否到达总运行上限，到点直接终止调度。

对比你之前自行实现的Thread循环方案：这类方案会让单个线程持续保持存活，在sleep等待期间也会固定占用约1MB的线程栈内存，且没有统一的资源管控，高并发场景下很容易拖慢服务器。本方案的调度器在空闲等待时处于操作系统层的挂起状态，不消耗CPU指令计算，仅在任务触发点被内核唤醒执行，资源占用极低。

可直接运行的示例代码 #

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class StagedTaskScheduler {
    // 替换为你实际需要定时执行的业务方法
    private void targetBusinessMethod() {
        System.out.println("触发目标业务方法执行，当前时间戳：" + System.currentTimeMillis());
    }

    public void startStagedSchedule() {
        // 初始化单线程调度器，整个任务生命周期仅占用1个线程资源
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        long taskStartTimestamp = System.currentTimeMillis();
        // 定义总运行上限：5小时，转换为毫秒单位方便计算
        final long MAX_TOTAL_RUN_TIME = TimeUnit.HOURS.toMillis(5);

        Runnable taskExecutor = new Runnable() {
            @Override
            public void run() {
                try {
                    // 执行实际业务逻辑
                    targetBusinessMethod();
                } finally {
                    // 计算从启动到当前已经经过的时长
                    long elapsedTime = System.currentTimeMillis() - taskStartTimestamp;
                    // 到达总运行上限，直接关闭调度器释放所有资源
                    if (elapsedTime >= MAX_TOTAL_RUN_TIME) {
                        scheduler.shutdown();
                        return;
                    }
                    // 根据当前所处阶段计算下一次任务的延迟时间
                    long nextDelay = getDelayByStage(elapsedTime);
                    // 提交下一次执行任务
                    scheduler.schedule(this, nextDelay, TimeUnit.MILLISECONDS);
                }
            }
        };

        // 首次任务立即触发执行
        scheduler.schedule(taskExecutor, 0, TimeUnit.MILLISECONDS);
    }

    /**
     * 根据已运行时长匹配对应阶段的执行间隔
     */
    private long getDelayByStage(long elapsedTime) {
        // 0-10分钟阶段：间隔2分钟
        if (elapsedTime < TimeUnit.MINUTES.toMillis(10)) {
            return TimeUnit.MINUTES.toMillis(2);
        }
        // 10-30分钟阶段：间隔5分钟
        if (elapsedTime < TimeUnit.MINUTES.toMillis(30)) {
            return TimeUnit.MINUTES.toMillis(5);
        }
        // 30分钟到5小时阶段：间隔10分钟
        return TimeUnit.MINUTES.toMillis(10);
    }

    // 测试入口
    public static void main(String[] args) {
        new StagedTaskScheduler().startStagedSchedule();
    }
}

方案优化点 #

• 资源占用可控：整个调度仅占1个线程，空闲时处于挂起状态，不会主动抢占CPU资源，任务全部执行完成后调度器自动关闭，释放所有线程资源
• 时间偏差小：每次执行完都基于实际运行时间计算下次延迟，不会因为单次任务的执行耗时打乱阶段切换的时间节点
• 无额外依赖：纯JDK原生API实现，不需要引入第三方定时框架，不会增加项目的构建体积

内容的提问来源于stack exchange，提问作者Aman Mate