定时器的使用

前言

正文

1.方法 schedule(TimerTask task, Date time) 的测试

（1）执行任务的时间晚于当前时间(在未来执行)的效果

（2）线程TimerThread不销毁的原因

（3）使用 public void cancel() 方法实现 TimerThread 线程销毁

（4）执行任务的时间早于当前时间(立刻运行）的效果

（5）在定时器中执行多个 TimerTask 任务

（6）延时执行 TimerTask 的测试

2.方法 schedule(TimerTask task, long delay, long period)

（1）执行任务的时间晚于当前时间(在未来执行)的效果

（2）执行任务的时间早于当前时间（立即执行）的效果

（3）延迟执行 TimerTask 的测试

（4）TimerTask 类中的 cancel() 方法

（5）类 Timer 中的 cancel() 方法

（6）间隔执行任务的算法

（7）Timer 类中的 cancel() 方法的注意事项

3.方法 schedule(TimerTask task,long delay) 的测试

4.方法 schedule(TimerTask task,long delay,long period) 的测试。

5.方法 public void scheduleAtFixedRate(TimerTask task, Date firstTime,long period)的测试

（1）测试 schedule 方法任务不延时(Date 类型)

（2）测试 schedule 方法任务不延时(Long 类型)

（3）测试 schedule 方法任务延时(Date 类型)

（4）测试 schedule 方法任务被延时(Long 类型)

（5）测试 scheduleAtFixedRate 方法任务不延时(Date 类型)

（6）测试 scheduleAtFixedRate 方法任务不延时(Long 类型)

（7）测试 scheduleAtFixedRate 方法任务延时(Date 类型)

（8）测试 scheduleAtFixedRate 方法任务延时(Long 类型)

（9）验证 schedule 方法不具有追赶特性

（10）验证 scheduleAtFixedRate 方法具有追赶性

前言

定时/计划功能在移动开发领域使用较多，比如Android技术，定时功能在Java种主要通过Timer类实现，因为它在内部还是使用多线程的方式进行处理，所以和线程技术还是有非常大的关联。

正文

在 JDK 库中 Timer 类主要负责计划任务的功能，也就是在指定的时间开始执行某一个任务，Timer类的方法列表如图：

Timer类的主要作用就是设置计划任务，封装任务的类却是 TimerTask，该类的结构图：

实现了Runnable接口。

因为TaskTimer是一个抽象类，所以执行任务的代码要放入Timer-Task的子类中。

1.方法 schedule(TimerTask task, Date time) 的测试

该方法的作用是在指定日期的执行一次某一任务。

（1）执行任务的时间晚于当前时间(在未来执行)的效果

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

public class schedule {
    static class MyTask extends TimerTask{
        @Override
        public void run() {
            System.out.println("任务执行了，时间为："+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为："+nowTime);
        long scheduleTime = (nowTime+10000L);
        System.out.println("计划时间为："+scheduleTime);
        MyTask task = new MyTask();
        Timer timer = new Timer();
        Thread.sleep(1000);
        timer.schedule(task,new Date(scheduleTime));
        Thread.sleep(Integer.MAX_VALUE);
    }


}

运行后的效果如图：

10s 之后任务成功执行。任务虽然执行完了，但线程还未销毁，呈红色状态，说明内部还有非守护线程正在执行，从 jvisualvm.exe工具中也得到了证实，程序运行 10s之后，名为 Timer-0 的线程还在运行，效果如图：

下面将介绍这种情况。

（2）线程TimerThread不销毁的原因

进程不销毁的原因是在创建 Timer 类时启动了一个新的非守护进程，JDK 源代码如下：

    /**
     * Creates a new timer.  The associated thread does <i>not</i>
     * {@linkplain Thread#setDaemon run as a daemon}.
     */
    public Timer() {
        this("Timer-" + serialNumber());
    }

此构造方法调用的是如下构造方法。

private final TimerThread thread = new TimerThread(queue);
   public Timer(String name) {
        thread.setName(name);
        thread.start();
    }

查看构造方法可知，创建一个Timer类时，在内部就启动了 1 个新的线程，用新启动的这个线程去执行计划任务，TimerThread是线程类，源代码如下：

/**
 * This "helper class" implements the timer's task execution thread, which
 * waits for tasks on the timer queue, executions them when they fire,
 * reschedules repeating tasks, and removes cancelled tasks and spent
 * non-repeating tasks from the queue.
 */
class TimerThread extends Thread {

那么这个新启动的线程并不是守护线程了，而且一直在运行。一直在运行的原因是新线程内部有一个死循环，TimeThread.java 类中的 mainLoop() 方法代码如下。

private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                synchronized(queue) {
                    // Wait for queue to become non-empty
                    while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
                    if (queue.isEmpty())
                        break; // Queue is empty and will forever remain; die

                    // Queue nonempty; look at first evt and do the right thing
                    long currentTime, executionTime;
                    task = queue.getMin();
                    synchronized(task.lock) {
                        if (task.state == TimerTask.CANCELLED) {
                            queue.removeMin();
                            continue;  // No action required, poll queue again
                        }
                        currentTime = System.currentTimeMillis();
                        executionTime = task.nextExecutionTime;
                        if (taskFired = (executionTime<=currentTime)) {
                            if (task.period == 0) { // Non-repeating, remove
                                queue.removeMin();
                                task.state = TimerTask.EXECUTED;
                            } else { // Repeating task, reschedule
                                queue.rescheduleMin(
                                  task.period<0 ? currentTime   - task.period
                                                : executionTime + task.period);
                            }
                        }
                    }
                    if (!taskFired) // Task hasn't yet fired; wait
                        queue.wait(executionTime - currentTime);
                }
                if (taskFired)  // Task fired; run it, holding no locks
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }

private void mainLoop()方法内部使用 while(true) 死循环一直执行计划任务，并不退出 while(true)死循环，依据源代码的执行流程，除非是满足 if (queue.isEmpty()) 条件，才执行 break 退出 while(true)死循环，退出逻辑的核心源代码如下：

 while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
               if (queue.isEmpty())
                        break;

上面的源代码逻辑如下：

（1）使用 while 循环对 queue.isEmpty() && newTasksMayBeScheduled 条件进行判断。

（2）当 && 两端都为 true 时，执行 wait() 方法使当前线程被暂停运行，等待被唤醒。

（3）唤醒的时机是执行了 public void schedule(TimeTask task,Date time)方法，说明要执行新的任务了。

（4）唤醒后 while 继续判断 queue.isEmpty() && newTaskMayBeScheduled 条件，如果有新的任务被安排，则 queue.isEmpty() 结果为 false，&&最终结果为是 false，会继续执行下面的 if 语句。

（5）if(queue.isEmpty()) 中的 queue.isEmpty() 结果为 true，说明队列为空，那么执行 break 语句退出 while(true) 死循环。

（6）执行 public void cancel() 方法会使布尔变量 newTaskMayBeScheduled 的值由 true 变成 false。

（7）如果不执行 public void cancel()，变量 newTaskMayBeScheduled 的值就不会是 false，一直呈死循环的状态，进程不销毁就是这个原因，public void cancel() 方法源代码如下。


    public void cancel() {
        synchronized(queue) {
            thread.newTasksMayBeScheduled = false;
            queue.clear();
            queue.notify();  // In case queue was already empty.
        }
    }

上面 7 步就是进程不消毁的原因，以及退出死循环 while(true) 的逻辑。

（3）使用 public void cancel() 方法实现 TimerThread 线程销毁

Timer 类中 public void cancel() 方法的作用是终止此计时器，丢弃当前所有已安排的任务。这不会干扰当前正在执行的任务(如果存在)。一旦终止了计时器，那么它的执行线程也会终止，并且无法根据它安排更多的任务。注意，在此计算器调用的计时器任务的 run() 方法内调用此方法，就可以确保正在执行的任务是此计算器的最后一个任务。虽然可以重复调用此方法，但是第二次和后续调用无效。

根据上面的源代码分析可知，当队列中为空，并且 newTaskMayBeScheduled 值是 false 时，退出 while(true) 死循环，导致 TimerThread 线程结束运行并销毁。

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

public class Test {
    static class MyTask extends TimerTask {
        @Override
        public void run() {
            System.out.println("任务执行了，时间为："+System.currentTimeMillis());
        }
    }
    public static void main(String[] args) throws InterruptedException {
        long nowTime = System.currentTimeMillis();
        System.out.println(" 当前时间为：" + nowTime);
        long scheduleTime = (nowTime + 15000L);
        System.out.println(" 计划时间为："+scheduleTime);
        MyTask task = new MyTask();
        Timer timer = new Timer();
        timer.schedule(task,new Date(scheduleTime));
        Thread.sleep(18000);
        timer.cancel();
        Thread.sleep(Integer.MAX_VALUE);
    }
}

程序运行18秒之后，从 jvisualvm.exe工具中可以看到名称为 Timer-0 的线程 TimerThread被销毁（在已完成的线程中）了，效果如图：

虽然 TimerThread 线程销毁了，但进程还是呈红色状态，这时因为main 线程一直在执行 Thread.sleep(Integer.MAX_VALUE) 代码，控制台输出如下：

（4）执行任务的时间早于当前时间(立刻运行）的效果

如果执行任务的时间早于当前时间，则立即执行任务。

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

public class Test {
    static class MyTask extends TimerTask {
        @Override
        public void run() {
            System.out.println("任务执行了，时间为："+System.currentTimeMillis());
        }
    }
    public static void main(String[] args) throws InterruptedException {
        long nowTime = System.currentTimeMillis();
        System.out.println(" 当前时间为：" + nowTime);
        long scheduleTime = (nowTime - 5000);
        System.out.println(" 计划时间为："+scheduleTime);
        MyTask task = new MyTask();
        Timer timer = new Timer();
        timer.schedule(task,new Date(scheduleTime));
    }
}

效果如图：

（5）在定时器中执行多个 TimerTask 任务

可以在定时器中执行多个 TimerTask 任务。

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

public class Test {
    static class MyTask extends TimerTask {
        @Override
        public void run() {
            System.out.println("任务执行了，时间为："+System.currentTimeMillis());
        }
    }
    public static void main(String[] args) throws InterruptedException {
        long nowTime = System.currentTimeMillis();
        System.out.println(" 当前时间为：" + nowTime);
        long scheduleTime1 = (nowTime + 5000);
        long scheduleTime2 = (nowTime + 8000);
        System.out.println(" 计划时间1为："+scheduleTime1);
        System.out.println(" 计划时间2为："+scheduleTime2);
        MyTask task1 = new MyTask();
        MyTask task2 = new MyTask();
        Timer timer = new Timer();
        timer.schedule(task1,new Date(scheduleTime1));
        timer.schedule(task2,new Date(scheduleTime2));
    }
}

程序运行结果如图：

（6）延时执行 TimerTask 的测试

因为TimerTask是以一个队列得到方式一个一个被顺序执行的，所以执行的时间有可能和预期的时间不一致。因为前面的任务有可能消耗的时间较长，所以后面的任务运行的时间也被延后，请看下面的示例：

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

public class taskLater {
    static class MyTaskA extends TimerTask {
        @Override
        public void run() {
            try {
                System.out.println("A begin timer=" + System.currentTimeMillis());
                Thread.sleep(20000);
                System.out.println("A   end Timer=" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class MyTaskB extends TimerTask{

        @Override
        public void run() {
            System.out.println("B begin timer="+System.currentTimeMillis());
            System.out.println("B   end timer="+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为："+nowTime);
        long scheduleTime1 = nowTime;
        long scheduleTime2 = nowTime+5000;
        System.out.println("计划时间1为："+scheduleTime1);
        System.out.println("计划时间2为："+scheduleTime2);
        MyTaskA taskA = new MyTaskA();
        MyTaskB taskB = new MyTaskB();
        Timer timer = new Timer();
        timer.schedule(taskA,new Date(scheduleTime1));
        timer.schedule(taskB,new Date(scheduleTime2));
    }
}

程序运行结果如图：

在代码中，long scheduleTime2 = now + 5000 原计划是执行任务1 和任务 2 的运行间隔时间为 5 秒，由于 task1 执行任务需要 20 秒，因此 task1 的结束时间就是 task2 的开始时间，task2 不再以 5 秒作为参考，而是以 20 秒作为参考，究其原理是创建了 1 个Timer 类导致创建了 1 个TimerThread 线程，1 个TimerThread 线程管理 1 个队列，在队列中得按顺序运行任务。

2.方法 schedule(TimerTask task, long delay, long period)

该方法的作用是在指定的日期之后按指定的间隔周期无限循环地执行某一任务。

（1）执行任务的时间晚于当前时间(在未来执行)的效果


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

public class timerTest2_period {
    static class MyTask extends TimerTask{
        @Override
        public void run() {
            System.out.println("任务执行了，时间为："+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为："+nowTime);
        long scheduleTime = (nowTime+10000);
        System.out.println("计划时间为："+scheduleTime);
        MyTask task = new MyTask();
        Timer timer = new Timer();
        timer.schedule(task,new Date(scheduleTime),4000L);
    }

}

程序运行结果如图：

从运行结果来看，每隔 4 秒运行一次 TimerTask 任务，并且是无限期重复执行任务。

（2）执行任务的时间早于当前时间（立即执行）的效果

如果计划时间早于当前时间，则立即执行任务。

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

public class Test2 {
    static class MyTask extends TimerTask {
        @Override
        public void run() {
            System.out.println("任务执行了，时间为："+System.currentTimeMillis());
        }
    }
    public static void main(String[] args) throws InterruptedException {
        long nowTime = System.currentTimeMillis();
        System.out.println(" 当前时间为：" + nowTime);
        long scheduleTime = (nowTime - 5000);
        System.out.println(" 计划时间为："+scheduleTime);
        MyTask task = new MyTask();
        Timer timer = new Timer();
        timer.schedule(task,new Date(scheduleTime),4000L);
    }
}

程序运行结果如图：

控制台打印的结果是程序运行后立即执行任务，并且每隔 4 秒打印一次。

（3）延迟执行 TimerTask 的测试

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

public class timerTest2_periodLater {
    static class MyTaskA extends TimerTask{

        @Override
        public void run() {
            try{
                System.out.println("A begin timer="+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("A           end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为：  "+nowTime);
        System.out.println("    计划时间为：  "+nowTime);
        MyTaskA taskA = new MyTaskA();
        Timer timer = new Timer();
        timer.schedule(taskA,new Date(nowTime),3000);
    }
}

使用代码 timer.schedule(taskA,new Date(nowTime),3000);是让每个任务执行的间隔时间为 3 秒，而运行结果却是 5 秒，这是因为在任务中执行了 Thread.sleep(5000) ，程序运行结果如图所示：

（4）TimerTask 类中的 cancel() 方法

TimerTask 类中的 cancel() 方法的作用是将自身从任务队列中清楚，该方法的源代码如下。

    public boolean cancel() {
        synchronized(lock) {
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
        }
    }

从方法得到代码可以分析出，执行 TimerTask 类中的 cancel() 方法时是将当前 TimerTask 任务得到状态改为 CANCELLED。

测试代码如下：

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

public class TimerTaskCancelMethod {
    static class MyTaskA extends TimerTask{

        @Override
        public void run() {
            System.out.println("A run timer="+System.currentTimeMillis());
            this.cancel();
            System.out.println("A 任务自己移除自己");
        }
    }
    static class MyTaskB extends TimerTask{

        @Override
        public void run() {
            System.out.println("B run timer="+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为："+nowTime);
        System.out.println("计划时间为："+nowTime);
        MyTaskA task1 = new MyTaskA();
        MyTaskB task2 = new MyTaskB();
        Timer timer = new Timer();
        timer.schedule(task1,new Date(nowTime),4000L);
        timer.schedule(task2,new Date(nowTime),4000L);
     }
}

运行结果如下：

TimerTask 类的 cancel() 方法是将自身从任务队列中移除，其他任务不受影响。

（5）类 Timer 中的 cancel() 方法

和 TimerTask 类中的 cancel() 方法清除自身不同，Timer 类中 cancel() 方法的作用是将任务队列中全部的任务清空，源代码如下。

 public void cancel() {
        synchronized(queue) {
            thread.newTasksMayBeScheduled = false;
            queue.clear();
            queue.notify();  // In case queue was already empty.
        }
    }

创建新的测试用例：

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

public class TimerCancelMethod {
    static class MyTaskA extends TimerTask {

        @Override
        public void run() {
            System.out.println("A run timer="+System.currentTimeMillis());
        }
    }
    static class MyTaskB extends TimerTask{

        @Override
        public void run() {
            System.out.println("B run timer="+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为："+nowTime);
        System.out.println("计划时间为："+nowTime);
        MyTaskA task1 = new MyTaskA();
        MyTaskB task2 = new MyTaskB();
        Timer timer = new Timer();
        timer.schedule(task1,new Date(nowTime),2000L);
        timer.schedule(task2,new Date(nowTime),2000L);
        Thread.sleep(10000);
        timer.cancel();         //全部任务都取消
    }
}

程序运行 10 秒后，进程销毁，控制台输出结果如图：

全部任务都被清楚，并且进程被销毁，按钮由红色变成灰色。

（6）间隔执行任务的算法

当队列中有三个任务 A B C 时，这三个任务执行顺序的算法是每次将最后一个任务放入队列头，再执行队列头中任务的 run() 方法，算法效果如下：

1）起始顺序为 A B C。

2）C A B，将 C 放入 AB 之前。

3) B C A，将 B 放入 C A之前。

创建新的任务代码如下：

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

public class NewAlgorithm {
    static class MyTaskA extends TimerTask {

        @Override
        public void run() {
            System.out.println("A run timer="+System.currentTimeMillis());
        }
    }
    static class MyTaskB extends TimerTask{

        @Override
        public void run() {
            System.out.println("B run timer="+System.currentTimeMillis());
        }
    }
    static class MyTaskC extends TimerTask{

        @Override
        public void run() {
            System.out.println("C run timer="+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为："+nowTime);
        System.out.println("计划时间为："+nowTime);
        MyTaskA taskA = new MyTaskA();
        MyTaskB taskB = new MyTaskB();
        MyTaskC taskC = new MyTaskC();
        Timer timer = new Timer();
        timer.schedule(taskA,new Date(nowTime),2000L);
        timer.schedule(taskB,new Date(nowTime),2000L);
        timer.schedule(taskC,new Date(nowTime),2000L);
    }
}

运行结果如图：

（7）Timer 类中的 cancel() 方法的注意事项

Timer() 类中的 cancel() 方法有时不一定会停止计划任务，而是正常执行。

创建新的项目：

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

public class TimerCancelError {
    static class MyTaskA extends TimerTask {
        private int i;

        public MyTaskA(int i) {
            super();
            this.i = i;
        }

        @Override
        public void run() {
            System.out.println(" 第" + i + "次没有被cancel取消");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        long nowTime = System.currentTimeMillis();
        System.out.println("当前时间为："+nowTime);
        System.out.println("计划时间为："+nowTime);
        while(true){
            i++;
            Timer timer = new Timer();
            MyTaskA taskA = new MyTaskA(i);
            timer.schedule(taskA,new Date(nowTime));
            timer.cancel();
        }
    }
}

程序运行后代码截图：

因为 Timer 类中的 cancel() 方法有时并没有争抢到队列锁，所以让TimerTask 任务正常执行。

3.方法 schedule(TimerTask task,long delay) 的测试

该方法的作用是以执行 schedule(TimerTask task,long delay) 方法当前的时间为参考时间，在此时间基础上延迟指定的毫秒数后执行一次 TImerTask 任务。

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

public class timerTest3 {
    static class MyTask extends TimerTask{

        @Override
        public void run() {
            System.out.println("运行了！时间为"+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        Timer timer = new Timer();
        System.out.println("当前时间为："+System.currentTimeMillis());
        timer.schedule(task,7000L);
    }
}

程序运行结果如图：

任务被延迟 7 秒执行了。

4.方法 schedule(TimerTask task,long delay,long period) 的测试。

该方法的作用是以执行 schedule(TimerTask task,long delay,long period) 方法当前的时间为参考时间，在此时间的基础上延迟指定的毫秒数，再以某一间隔时间无限次数地执行某一任务。

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

public class timerTest3 {
    static class MyTask extends TimerTask{

        @Override
        public void run() {
            System.out.println("运行了！时间为"+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        Timer timer = new Timer();
        System.out.println("当前时间为："+System.currentTimeMillis());
        timer.schedule(task,3000L,5000);
    }
}

程序运行结果如图：

凡是使用方法中带有 period 参数的，都是无限循环执行 TimerTask 中的任务。

5.方法 public void scheduleAtFixedRate(TimerTask task, Date firstTime,long period)的测试

schedule 方法和 scheduleAtFixedRate 方法的主要区别在于有没有追赶特性。

（1）测试 schedule 方法任务不延时(Date 类型)

创建项目，测试代码如下：

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

public class timerTest5 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        long nowTime = System.currentTimeMillis();
        Timer timer = new Timer();
        timer.schedule(task,new Date(nowTime),3000);
    }
}

运行结果如图：

控制台打印结果证明，在不延时的情况下，如果执行任务的时间没有被延时，则下一次执行任务的开始时间是上一次任务的开始时间加上 period 时间。

所谓的 “不延时” 是指执行任务的时间小于 period 间隔时间。

（2）测试 schedule 方法任务不延时(Long 类型)

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

public class Test2 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        System.out.println(" 当前时间："+System.currentTimeMillis());
        Timer timer = new Timer();
        timer.schedule(task,3000L,4000L);
    }
}

运行结果如图：

控制台打印的结果证明，在不延时的情况下，如果执行任务的时间没有被延时，则第一次执行任务的时间是任务快开始时间加上延时时间，接下来执行任务的时间是上一次任务的开始时间加上 period 时间。

（3）测试 schedule 方法任务延时(Date 类型)

创建测试用例：

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

public class timerTest5 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        long nowTime = System.currentTimeMillis();
        Timer timer = new Timer();
        timer.schedule(task,new Date(nowTime),2000);
    }
}

运行结果如图：

从控制台打印结果来看，在延时的情况下，如果执行任务的时间被延时，那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。

（4）测试 schedule 方法任务被延时(Long 类型)

测试用例如下：

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

public class Test2 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        System.out.println(" 当前时间："+System.currentTimeMillis());
        Timer timer = new Timer();
        timer.schedule(task,3000L,2000L);
    }
}

运行结果如图：

从控制台打印结果来看，在延时的情况下，如果执行任务的时间被延时，那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。

（5）测试 scheduleAtFixedRate 方法任务不延时(Date 类型)

创建新的测试用例，本次测试使用 scheduleAtFixedRate 作为测试。

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

public class timerTest5 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        long nowTime = System.currentTimeMillis();
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(task,new Date(nowTime),3000);
    }
}

控制台打印的结果证明，在不延时的情况下，如果执行任务的时间没有被延时，则下一次执行任务的时间是上一次任务的开始时间加上 period 时间。

（6）测试 scheduleAtFixedRate 方法任务不延时(Long 类型)

创建测试用例：

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

public class Test2 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        System.out.println(" 当前时间："+System.currentTimeMillis());
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(task,3000L,4000L);
    }
}

运行结果如图：

控制台打印的结果证明，在不延时的情况下，如果执行任务的时间没有被延时，则下一次执行任务的时间是上一次任务的开始时间加上 period 时间。

（7）测试 scheduleAtFixedRate 方法任务延时(Date 类型)

创建测试用例：


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

public class timerTest5 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        long nowTime = System.currentTimeMillis();
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(task,new Date(nowTime),2000);
    }
}

运行结果如图：

从控制台打印结果来看，在延时的情况下，如果执行任务的时间被延时，那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。

（8）测试 scheduleAtFixedRate 方法任务延时(Long 类型)

创建测试用例：

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

public class Test2 {
    static class MyTask extends TimerTask {

        @Override
        public void run() {
            try {
                System.out.println("begin timer="+System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("    end timer="+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        System.out.println(" 当前时间："+System.currentTimeMillis());
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(task,3000L,2000L);
    }
}

运行结果如图：

从控制台打印结果来看，在延时的情况下，如果执行任务的时间被延时，那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。

从上面 8 个运行结果来看，schedule 方法和 scheduleAtFixedRate 方法在运行效果上并没有非常明显的区别，那它们之间到底有什么区别呢，那就是追赶特性。

（9）验证 schedule 方法不具有追赶特性

创建测试用例：

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

public class Test9 {
    static class MyTask extends TimerTask{

        @Override
        public void run() {
            System.out.println("begin timer="+System.currentTimeMillis());
            System.out.println("    end timer="+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        long nowTime = System.currentTimeMillis();
        System.out.println("现在执行时间："+nowTime);
        long runTime = nowTime - 20000;
        System.out.println("计划执行时间："+runTime);
        Timer timer = new Timer();
        timer.schedule(task,new Date(runTime),2000);
    }
}

运行结果如图：

从运行结果上来看，“1700620549103” 到 ”1700620529103“ 的时间所对应的任务被取消掉，不执行了，这就是任务不追赶。

（10）验证 scheduleAtFixedRate 方法具有追赶性

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

public class Test9 {
    static class MyTask extends TimerTask{

        @Override
        public void run() {
            System.out.println("begin timer="+System.currentTimeMillis());
            System.out.println("    end timer="+System.currentTimeMillis());
        }
    }

    public static void main(String[] args) {
        MyTask task = new MyTask();
        long nowTime = System.currentTimeMillis();
        System.out.println("现在执行时间："+nowTime);
        long runTime = nowTime - 20000;
        System.out.println("计划执行时间："+runTime);
        Timer timer = new Timer();
        timer.scheduleAtFixedRate(task,new Date(runTime),2000);
    }
}

运行结果如图：

11次（开始1次加上{20000/2000}能运行的10次总共11次）打印任务时间 “1700621411899” 都是曾经流逝时间的任务追赶，也就是将曾经没有执行的任务追加进行执行，将 20 秒之内执行任务的次数打印完，再每间隔 2 秒执行一次任务。

将两个时间段内的时间所对应的任务被 “弥补” 地执行，也就是在指定时间段内的运行次数必须要运行完整，这就是任务追赶特性。