深入剖析：Java 定时器 Timer 源码及实战避坑指南

在日常的 Java 开发中，我们经常会遇到需要周期性执行任务的需求，比如定时清理缓存、定时发送邮件等。java.util.Timer 和 java.util.TimerTask 就是 Java 提供的最基础的定时任务解决方案。然而，简单易用的背后也隐藏着一些潜在的陷阱，稍不注意就可能导致程序出现问题。本文将深入 Java学习 的过程中，通过源码分析和实战案例，带你彻底掌握 Timer 的使用，并避免常见的坑。

Timer 的基本使用

首先，我们来看一下 Timer 的基本使用方法。下面是一个简单的示例，每隔 1 秒打印一次当前时间：

import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;

public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer(); // 创建一个 Timer 实例
        TimerTask task = new TimerTask() { // 创建一个 TimerTask 实例
            @Override
            public void run() {
                System.out.println("Current time: " + new Date());
            }
        };
        timer.schedule(task, 0, 1000); // 延迟 0 毫秒后开始执行，每隔 1000 毫秒执行一次
    }
}

这段代码非常简单，但背后却涉及到不少细节。接下来，我们将深入 Timer 的源码，了解其工作原理。

Timer 源码剖析

Timer 的核心在于它使用了一个后台线程来执行定时任务。当我们创建一个 Timer 实例时，实际上会创建一个名为 TimerThread 的线程。这个线程会维护一个任务队列，并按照任务的执行时间进行排序。

Timer 类内部有一个 TaskQueue 用于存放 TimerTask，这是一个基于最小堆实现的优先级队列。当调用 timer.schedule() 方法时，TimerTask 会被添加到这个队列中。TimerThread 会不断地从队列中取出到期的任务并执行。

让我们来看一下 Timer.schedule() 方法的源码片段：

public void schedule(TimerTask task, long delay) {
    if (delay < 0)
        throw new IllegalArgumentException("Negative delay.");
    sched(task, System.currentTimeMillis()+delay, 0);
}

private void sched(TimerTask task, long time, long period) {
    if (time < 0)
        throw new IllegalArgumentException("Illegal execution time.");

    synchronized(queue) {
        if (!thread.newTasksMayBeScheduled)
            throw new IllegalStateException("Timer already cancelled.");

        synchronized(task) {
            if (task.state != TimerTask.VIRGIN)
                throw new IllegalStateException("Task already scheduled or cancelled");
            task.nextExecutionTime = time;
            task.period = period;
            task.state = TimerTask.SCHEDULED;
        }

        queue.add(task);
        if (queue.getMin() == task)
            queue.notify();
    }
}

从源码中我们可以看到，schedule() 方法主要做了以下几件事：

1. 参数校验：检查 delay 是否为负数，time 是否小于 0。
2. 线程安全：通过 synchronized 关键字保证了多线程环境下的安全性。
3. 任务状态更新：将 TimerTask 的状态设置为 SCHEDULED。
4. 添加到队列：将 TimerTask 添加到 TaskQueue 中。
5. 唤醒线程：如果新添加的任务是队列中最早需要执行的任务，则唤醒 TimerThread。

TimerThread 线程的主要工作就是不断地从 TaskQueue 中取出到期的任务并执行。如果队列为空，则线程会进入等待状态，直到有新的任务添加到队列中。

Timer 的坑与避坑指南

虽然 Timer 使用起来非常方便，但也存在一些潜在的问题，需要我们注意：

1. 单线程执行：Timer 使用单线程来执行所有任务。如果某个任务执行时间过长，会阻塞后续任务的执行。这在对实时性要求较高的场景下是不可接受的。解决方案： 使用线程池来执行任务，例如 ScheduledThreadPoolExecutor，它可以并发地执行多个任务。

   

2. 异常处理：如果 TimerTask 在执行过程中抛出异常，TimerThread 不会捕获这些异常，而是直接退出。这意味着后续的任务将不会被执行。解决方案： 在 TimerTask 的 run() 方法中使用 try-catch 块捕获异常，防止 TimerThread 退出。

3. 时钟漂移：由于系统时钟可能发生调整，导致 Timer 的执行时间不准确。解决方案： 对于对时间精度要求非常高的场景，可以考虑使用第三方库，例如 Quartz。

4. 取消任务：使用 timer.cancel() 方法可以取消所有未执行的任务，但如果任务已经在执行中，则无法取消。解决方案： 在 TimerTask 中增加一个标志位，用于控制任务的执行。

   

实战案例：定时清理缓存

假设我们需要定时清理缓存，可以使用 Timer 来实现。以下是一个简单的示例：

import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
import java.util.Map;
import java.util.HashMap;

public class CacheCleaner {
    private static final Map<String, Object> cache = new HashMap<>();

    public static void main(String[] args) {
        // 初始化缓存
        cache.put("key1", "value1");
        cache.put("key2", "value2");
        cache.put("key3", "value3");

        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Cache cleaning started at: " + new Date());
                cache.clear(); // 清理缓存
                System.out.println("Cache cleaned at: " + new Date());
            }
        }, 0, 60 * 60 * 1000); // 每隔 1 小时清理一次缓存
    }
}

在这个例子中，我们创建了一个简单的缓存 cache，并使用 Timer 每隔 1 小时清理一次缓存。需要注意的是，如果缓存非常大，清理缓存的时间可能会比较长，从而阻塞后续的任务执行。在这种情况下，应该考虑使用线程池来异步清理缓存。

总结

Timer 是 Java 提供的最基础的定时任务解决方案，使用起来非常简单方便。但是，在实际应用中，我们需要注意 Timer 的一些潜在问题，例如单线程执行、异常处理、时钟漂移等。对于对实时性要求较高、任务执行时间较长的场景，应该考虑使用线程池或第三方库来代替 Timer。深入理解 Java学习 的相关技术，并根据具体的业务场景选择合适的解决方案，才能保证程序的稳定性和可靠性。