Java Timer使用讲解

Java Timer 是 Java SE 提供的一个定时器工具，可以用于定时运行任务、周期性地运行任务等。本文将详细介绍 Timer 的使用方法和注意事项。

Timer 的基本使用方法

Timer 类提供了三个构造方法，分别为：

Timer()

Timer(boolean isDaemon)

Timer(String name)

其中，第一个构造方法创建一个非守护线程的 Timer 对象；第二个构造方法创建一个指定为守护线程的 Timer 对象；第三个构造方法接受一个字符串参数用于指定 Timer 对象的名称。

接下来的代码演示了 Timer 最基本的使用方法：

Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        System.out.println("Timer task executed.");
    }
}, 1000);

在上面的代码中，我们创建了一个 Timer 对象，并使用 schedule 方法来运行一个定时任务，该任务用于在 1000 毫秒后打印一条信息。

Timer 的周期性任务

Timer 类还提供了另外两个 schedule 方法，用于执行周期性的任务：

schedule(TimerTask task, long delay, long period)

scheduleAtFixedRate(TimerTask task, long delay, long period)

上面两个方法的参数含义基本相同，其中，task 表示需要执行的任务，delay 表示延迟多长时间后开始执行，period 表示执行任务的时间间隔。其中，schedule 方法每次执行任务的时间间隔是基于前一次任务的结束时间计算出的，而 scheduleAtFixedRate 方法则会使用相同的时间间隔来执行任务，不受上一次任务执行时间的影响。

下面的代码演示了如何使用 schedule 方法来执行一个周期性任务：

Timer timer = new Timer();
timer.schedule(new TimerTask() {
    private int count;

    @Override
    public void run() {
        System.out.printf("Timer task executed %d times.\n", ++count);
    }
}, 1000, 2000);

在上面的代码中，我们创建了一个 Timer 对象，并使用 schedule 方法来运行一个周期性的任务，该任务用于在 1000 毫秒后开始执行，每隔 2000 毫秒执行一次，并打印一条信息。

Timer 注意事项

需要注意的是，Timer 类在执行任务时只会使用一个守护线程来执行所有任务。这意味着，如果某个任务的执行时间过长，会影响到其他任务的正常执行。因此，在执行任务时应该尽量保证任务的执行时间不要过长，或将任务分割成多个较短的子任务进行执行。

此外，在 Java 5 及以上版本中，ScheduledThreadPoolExecutor 类提供了更加强大的定时任务支持，可以更加灵活地控制任务的执行时间和线程数量。因此，在编写较为复杂的定时任务时，建议使用 ScheduledThreadPoolExecutor 类代替 Timer 类。

示例

接下来，我们给出一个示例，该示例演示了如何使用 Timer 类来实现一个简单的倒计时功能。该功能用于在指定的时间内对用户进行提醒，并在倒计时结束后执行一个任务：

import java.awt.Toolkit;
import java.util.Timer;
import java.util.TimerTask;

public class CountDown {
    public static void main(String[] args) {
        long delay = 1000;
        long period = 1000;
        int seconds = Integer.parseInt(args[0]);

        final Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            private int countDown = seconds;

            @Override
            public void run() {
                Toolkit.getDefaultToolkit().beep();
                System.out.printf("Count down: %d seconds left.\n", countDown);
                if (--countDown == 0) {
                    timer.cancel();
                    System.out.println("Time's up!");
                    // execute a task after time is up
                    timer.schedule(new TimerTask() {
                        @Override
                        public void run() {
                            System.out.println("Task executed after time is up.");
                        }
                    }, 1000);
                }
            }
        }, delay, period);
    }
}

该示例程序接受一个整数参数，表示需要倒计时的时间长度（以秒为单位）。该程序会在倒计时开始后每秒钟进行一次提醒，并在倒计时结束后执行一个简单的任务。

示例

下面给出一个示例，该示例演示了如何使用 ScheduledThreadPoolExecutor 实现一个更为复杂的周期性任务。该任务用于在 1 秒之后开始执行，每隔 1 秒打印一条信息。此外，任务分别在单独的 10 个线程中执行，从而避免任务之间的互相干扰：

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

public class Scheduler {
    public static void main(String[] args) {
        int threads = 10;

        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(threads);
        scheduler.scheduleAtFixedRate(new Runnable() {
            private int count;

            @Override
            public void run() {
                System.out.printf("Task executed %d times in thread %s.\n", ++count, Thread.currentThread().getName());
            }
        }, 1, 1, TimeUnit.SECONDS);
    }
}

在上面的示例代码中，我们创建了一个 ScheduledExecutorService 对象，并将其配置为具有 10 条线程的线程池。接着，我们使用 scheduleAtFixedRate 方法来运行一个周期性的任务，该任务用于在 1 秒后开始执行，每隔 1 秒执行一次，并在独立的线程中执行。每次任务执行时，都会打印一条信息，该信息中包含当前任务的执行次数和所在的线程名称。