Java如何设置Timer生命周期 实现指定时长后自动终止

不需要额外新增上层管控定时器，完全可以基于JDK原生调度API实现定时器实例自管理生命周期，从根源上避免多层管控带来的结构混乱、代码臃肿问题。

你原有代码里存在几个致命问题，不解决就算加了管控层也无法稳定运行：

• TimerConstructor类里把配置对象timerVO定义为static静态变量，多实例运行时所有定时器会共享同一个配置，直接出现参数串扰
• 用while(true)死循环轮询判断到期时间，会持续占用CPU空转，资源浪费极其严重
• 混用了老旧的Timer和ScheduledExecutorService两套调度API，代码里大量成员变量未定义，本身无法通过编译
• 值对象字段缺失，代码中用到的aliveTime属性没有对应定义，还出现了把整型值写成字符常量'24'的类型错误
• 生命周期判断逻辑用时分秒完全匹配的写法，只要轮询时刚好跳过整秒就会永远无法触发终止，稳定性极差

实现思路 #

核心逻辑是把生命周期管控能力下沉到每个定时器实例自身，不依赖任何上层管控组件：

• 每个定时器实例独立持有自己的配置、调度线程池、任务句柄，所有变量都是实例级，彻底避免多实例互相影响
• 利用ScheduledExecutorService原生的延迟调度能力，对于有固定生命周期的定时器，在启动业务任务的同时提交一个延迟执行的终止任务，延迟时长等于配置的生命周期，到点自动取消业务任务、关闭线程池，不需要任何轮询判断
• 永久运行的定时器不提交终止任务即可，两类定时器逻辑完全兼容，不需要额外分支处理

修正后可直接运行的代码 #

1. 定时器配置类（替换原有不规范的值对象） #

public class TimerConfig {
    // 定时器唯一编号
    private Integer index;
    // 生命周期（单位：小时），赋值为null时代表永久运行
    private Integer lifespanHours;
    // 业务任务执行间隔（单位：秒）
    private Integer taskIntervalSec;

    public Integer getIndex() {
        return index;
    }

    public void setIndex(Integer index) {
        this.index = index;
    }

    public Integer getLifespanHours() {
        return lifespanHours;
    }

    public void setLifespanHours(Integer lifespanHours) {
        this.lifespanHours = lifespanHours;
    }

    public Integer getTaskIntervalSec() {
        return taskIntervalSec;
    }

    public void setTaskIntervalSec(Integer taskIntervalSec) {
        this.taskIntervalSec = taskIntervalSec;
    }
}

2. 自管理定时器类（替换原有TimerConstructor） #

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class SelfManagedTimer {
    // 所有成员变量均为实例级，禁止定义static配置，避免多实例串扰
    private final TimerConfig config;
    private ScheduledExecutorService executor;
    private ScheduledFuture<?> businessTaskFuture;

    public SelfManagedTimer(TimerConfig config) {
        this.config = config;
    }

    public void start() {
        executor = Executors.newSingleThreadScheduledExecutor();
        System.out.printf("定时器%d启动，启动时间：%s%n", config.getIndex(), LocalDateTime.now());

        // 提交固定频率执行的业务任务
        businessTaskFuture = executor.scheduleAtFixedRate(() -> {
            System.out.printf("定时器%d执行业务逻辑，当前时间：%s%n",
                    config.getIndex(), LocalDateTime.now());
        }, 0, config.getTaskIntervalSec(), TimeUnit.SECONDS);

        // 配置了生命周期则提交延迟终止任务，到点自动销毁
        if (config.getLifespanHours() != null) {
            long terminateDelay = TimeUnit.HOURS.toMillis(config.getLifespanHours());
            executor.schedule(this::stop, terminateDelay, TimeUnit.MILLISECONDS);
        }
    }

    public void stop() {
        if (businessTaskFuture != null && !businessTaskFuture.isCancelled()) {
            businessTaskFuture.cancel(true);
        }
        if (executor != null && !executor.isShutdown()) {
            executor.shutdown();
            System.out.printf("定时器%d已终止，终止时间：%s%n", config.getIndex(), LocalDateTime.now());
        }
    }
}

3. 启动入口 #

public enum TimerTrigger {
    INSTANCE;

    public void runTimer(){
        for (int i = 0; i < 3; i++) {
            TimerConfig config = new TimerConfig();
            config.setIndex(i);
            config.setTaskIntervalSec(10);
            // 前2个定时器设置24小时生命周期，第3个永久运行
            config.setLifespanHours(i < 2 ? 24 : null);
            new SelfManagedTimer(config).start();
        }
    }
}

public class App 
{
    public static void main( String[] args )
    {
        System.out.println("服务启动");
        TimerTrigger.INSTANCE.runTimer();
    }
}

方案优势 #

• 无额外管控层：不需要在上层新增统一管控定时器，每个实例自治，代码结构扁平清晰，不会出现逻辑臃肿问题
• 性能损耗为0：完全依赖线程池原生调度能力，没有死循环轮询的CPU空转消耗
• 隔离性强：所有实例独立持有资源，不会出现配置串扰、任务互相影响的问题
• 扩展灵活：后续需要增加手动终止、重启、运行状态查询等能力，直接在SelfManagedTimer类中新增方法即可，不需要修改全局逻辑
• 稳定性高：不存在时间匹配遗漏导致的终止失效问题，调度精度由JDK线程池保证。

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