使用Timer延迟调用方法时，如何取消已预定的前置任务？

这个需求其实很常见，核心就是要每次触发时取消之前未执行的任务，重新调度新的。我给你两种实现方式，一种是用你提到的Timer，另一种是更推荐的ScheduledExecutorService（因为Timer有不少局限性，比如单个线程执行任务、任务抛异常会导致整个Timer停止等）：

首先你需要在类中维护两个成员变量：一个Timer实例，一个TimerTask的引用，用来跟踪当前待执行的任务。每次调用方法时，先取消之前的任务和Timer，再重新创建并调度新任务：

public class DelayedTaskExample {
    private Timer delayedTimer;
    private TimerTask currentTask;

    public void scheduleDelayedAction() {
        // 取消之前的任务和Timer（如果存在）
        if (currentTask != null) {
            currentTask.cancel();
            currentTask = null;
        }
        if (delayedTimer != null) {
            delayedTimer.cancel();
            delayedTimer = null;
        }

        // 创建新的Timer和任务
        delayedTimer = new Timer();
        currentTask = new TimerTask() {
            @Override
            public void run() {
                // 这里写你要延迟执行的方法逻辑
                yourTargetMethod();
                // 执行完成后清理资源
                delayedTimer.cancel();
                currentTask = null;
            }
        };

        // 调度任务延迟5秒执行
        delayedTimer.schedule(currentTask, 5000);
    }

    // 你需要延迟调用的目标方法
    private void yourTargetMethod() {
        System.out.println("延迟5秒的方法终于执行啦！");
    }
}

关键说明 #

• 每次调用scheduleDelayedAction()时，都会先终止之前未执行的任务，确保只有最后一次触发的任务会被执行。
• 如果你的方法会被多线程调用，记得给scheduleDelayedAction()加上synchronized修饰符，避免竞态条件。

Java 5+引入的ScheduledExecutorService是Timer的更优替代方案，它支持线程池，任务异常不会影响其他任务，可靠性更高：

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

public class DelayedTaskExample {
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    private ScheduledFuture<?> currentFuture;

    public void scheduleDelayedAction() {
        // 取消之前未执行的任务
        if (currentFuture != null && !currentFuture.isDone()) {
            currentFuture.cancel(false); // false表示不中断正在执行的任务（这里任务还没开始，所以没问题）
        }

        // 调度新任务，延迟5秒执行
        currentFuture = scheduler.schedule(() -> {
            yourTargetMethod();
            currentFuture = null; // 执行完成后清理引用
        }, 5, TimeUnit.SECONDS);
    }

    private void yourTargetMethod() {
        System.out.println("延迟5秒的方法终于执行啦！");
    }

    // 程序退出时记得关闭调度器，避免线程泄漏
    public void shutdownScheduler() {
        scheduler.shutdown();
    }
}

关键说明 #

• ScheduledFuture用来跟踪调度的任务，调用cancel()就能终止未执行的任务。
• 单线程的调度器足够满足这个需求，如果你有多个任务需要执行，也可以调整线程池大小。
• 程序结束时一定要调用shutdownScheduler()关闭调度器，防止线程一直占用资源。

• 不管用哪种方式，都要确保任务逻辑本身是线程安全的，尤其是如果目标方法会被多个线程执行的话。
• 如果你的延迟任务可能频繁触发，ScheduledExecutorService的性能和稳定性会比Timer好很多。

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