Timer & TimerTask 深入分析

在java中，有一个常用的定时机制，Timer&TimerTask。你可以方便地：

1）在某个时刻做某件事情， public void schedule(TimerTask task, Date when)；

2）在一段延迟后做某件事情，public void schedule(TimerTask task, long delay)；

在这两种方式中，都可以指定做这件事情的频率，用以下两个方法：public void schedule(TimerTask task, long delay, long period)；public void schedule(TimerTask task, Date when, long period)；

废话少说，还是看个例子吧：

import java.io.IOException;
import java.util.Timer;

public class TimerTest {
        public static void main(String[] args) {
        Timer timer = new Timer();

        timer.schedule(new MyTask(), 1000, 2000);  //在1秒后执行此任务,每次间隔2秒,如果传递一个Data参数,就是在某个固定的时间执行这个任务.       
        while(true) {             
              try {
                  int ch = System.in.read();
                  if(ch-'c'==0) {
                      timer.cancel();  //结束任务
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
        }
}

static class MyTask extends java.util.TimerTask {   // 这是你的任务线程
     @Override
     public void run() {
         // accomplish your task here
     }
}

可以说，Timer 提供了一个异步任务的启动机制。说到异步，呵呵，肯定就有多线程啦。这里涉及到了2个或者说是3个线程:

1）当前线程，也就是TimerTest 中 Main 方法跑的那个线程，这个不需要多说，都懂的。

2）任务线程，也就是MyTask 线程。这个也不复杂，看看TimerTask的实现就知道了：

public abstract class TimerTask implements Runnable {

    ***

    ***

    public abstract void run();

}

问题是这个任务是单独开了一个线程吗？不急，后面有解答。

3）Timer 线程; 

Timer 本身还单独开了一个线程吗？是的！看看Timer 的代码就明白了。策略模式。Timer 将具体的功能实现委托给静态内部类TimerImpl。Timer 类中有一个 静态内部类 TimerImpl，而它又继承了Thread，让我们接着来分析下这个TimerImple 子线程的生命周期：

创建：当Timer 实例构造的时候，子线程被启动；那么它什么时候结束的呢？实际上就是看看TimerImpl.run() 方法中的while(true) 循环是怎么退出的。

a） 当Timer.cancel() 被调用时，cancelled 标志被置为true，循环退出，线程结束；

b）当某个task的run() 方法异常退出时，cancelled 也会被置为 true，循环退出，线程结束。

                try {
                    task.run();
                    taskCompletedNormally = true;
                } finally {
                    if (!taskCompletedNormally) {
                        synchronized (this) {
                            cancelled = true;
                        }
                    }
                }

以上代码还揭示了一个容易被忽视的真相，看看task.run(); 你是不是明白了什么，原来 TimerTask 虽然实现了Runnable 接口，但TimerTask并没有被start，而是被直接运行run() 方法。所以，TimerTask并没有单独开一个线程，而是就跑在TimerImpl 子线程中的。基于这样的事实，你不能在你的TimeTask的run() 方法中做过于耗时的操作，否则可能影响到其他task的按时执行。

呵呵，也许你会奇怪了，Runnable 不就是为多线程机制准备的吗？嗯，Runnable 主要是为多线程机制准备的，但不尽然，看看它的定义和注释吧：

/**
 * Represents a command that can be executed. Often used to run code in a
 * different {@link Thread}.
 */
public interface Runnable {

    /**
     * Starts executing the active part of the class' code. This method is
     * called when a thread is started that has been created with a class which
     * implements {@code Runnable}.
     */
    public void run();
}

看见最上面的那行注释了吧，通常(often)运行在另外一个线程中，但并非总是（always）。所以，这个run未必总是跑在另外一个线程中的。其实，Runnable的这种看似另类的用法，也是比较常用的。

c）当TimerTask 队列为空，且TimerImple.finished 标志被置为true。而这个标志什么时候被置为true的呢，这个问题很有意思。看看Timer的另外一个静态内部类：

    private static final class FinalizerHelper {
        private final TimerImpl impl;

        FinalizerHelper(TimerImpl impl) {
            this.impl = impl;
        }

        @Override protected void finalize() throws Throwable {
            try {
                synchronized (impl) {
                    impl.finished = true;
                    impl.notify();
                }
            } finally {
                super.finalize();
            }
        }
    }

当 FinalizerHelper 的实例，也就是Timer的一个私有成员变量(finalizer)被GC时，FinalizerHelper.finalize() 方法被JVM调用到，TimerImple.finished 标志被置为true。可以看到，Timer.finalizer 并没有被引用到，所以它应该是最早被GC掉的，这确保了它能完成一个光荣使命 ~~~~~~~ 帮助杀死TimerImpl 线程。

 

Timer 对Task 的管理

在TimerImple 对 Task 的具体管理操作又委托给了它自己的一个内部类 TimerHeap。在TimerHeap 内部定义了一个可动态扩展的TimerTask数组，这个数组实现了一个任务队列，越早执行的任务，排在越前面。