JDK Timer实现详解

概述

定时器是工程开发中比较常用的工具，本文研究JDK中Timer定时器的实现原理。在JDK中，Timer主要由TimerTask，TimerThread，TaskQueue组成。

TimerTask

TimerTask主要用来定义定时时间到来时，需要干什么事情，TimerTask继承自Runnable，所以具体的任务定义在run接口中。Task的状态有如下几种：

    /**
     * This task has not yet been scheduled.
     */
    static final int VIRGIN = 0;

    /**
     * This task is scheduled for execution.  If it is a non-repeating task,
     * it has not yet been executed.
     */
    static final int SCHEDULED   = 1;

    /**
     * This non-repeating task has already executed (or is currently
     * executing) and has not been cancelled.
     */
    static final int EXECUTED    = 2;

    /**
     * This task has been cancelled (with a call to TimerTask.cancel).
     */
    static final int CANCELLED   = 3;

VIRGIN表示Task刚刚被创建，SCHEDULED表示Task已经被加入TaskQueue中，等待调度，EXECUTED表示Task已经被执行，CANCELLED表示Task已经被取消。

TaskQueue

顾名思义，TaskQueue就是用来保存TimerTask的队列，当有新的Task add进来时，会保存到改队列中。需要注意的是，TaskQueue的内部实现使用的是最小堆，堆顶的Task是最近即将到时间的Task，所以在调度任务时，每次只需要取出堆顶元素，判断时间是否已到即可，效率非常高。下面是TaskQueue的核心代码，其实就是最小堆的实现代码：

    /**
     * Adds a new task to the priority queue.
     */
    void add(TimerTask task) {
        // Grow backing store if necessary
        if (size + 1 == queue.length)
            queue = Arrays.copyOf(queue, 2*queue.length);

        queue[++size] = task;
        fixUp(size);
    }
    /**
     * Establishes the heap invariant (described above) assuming the heap
     * satisfies the invariant except possibly for the leaf-node indexed by k
     * (which may have a nextExecutionTime less than its parent's).
     *
     * This method functions by "promoting" queue[k] up the hierarchy
     * (by swapping it with its parent) repeatedly until queue[k]'s
     * nextExecutionTime is greater than or equal to that of its parent.
     */
    private void fixUp(int k) {
        while (k > 1) {
            int j = k >> 1;
            if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
                break;
            TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
            k = j;
        }
    }

    /**
     * Establishes the heap invariant (described above) in the subtree
     * rooted at k, which is assumed to satisfy the heap invariant except
     * possibly for node k itself (which may have a nextExecutionTime greater
     * than its children's).
     *
     * This method functions by "demoting" queue[k] down the hierarchy
     * (by swapping it with its smaller child) repeatedly until queue[k]'s
     * nextExecutionTime is less than or equal to those of its children.
     */
    private void fixDown(int k) {
        int j;
        while ((j = k << 1) <= size && j > 0) {
            if (j < size &&
                queue[j].nextExecutionTime > queue[j+1].nextExecutionTime)
                j++; // j indexes smallest kid
            if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
                break;
            TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
            k = j;
        }
    }

    /**
     * Establishes the heap invariant (described above) in the entire tree,
     * assuming nothing about the order of the elements prior to the call.
     */
    void heapify() {
        for (int i = size/2; i >= 1; i--)
            fixDown(i);
    }

TimerThread

同样地，顾名思义，TimerThread就是用来调度TaskQueue中的任务的线程。TimerThread的核心逻辑如下：

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) {
            }
        }
    }

总结一下：TimerThread会起一个while循环，每一次循环判断当前TaskQueue队列是否为空，如果队列为空，并且可能会有新的Task会被调度，则等待新的Task到来，如果wait被唤醒之后队列还是为空，则表示此次wait是被Timer的cancel动作唤醒的，Timer的cancel动作如下：

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

将newTasksMayBeScheduled设置为false的同时，调用queue的notify方法，唤醒正在等待queue的线程。需要注意的是，唤醒queue的方式还有另外一种，稍后介绍。

否则，如果queue不为空，则从queue中取出当前最近即将到时间的Task，然后判断Task的执行时间是否已经到了，如果还没到，则计算目标调度时间和当前时间的差值delta，继续wait delta毫秒，wait时间到之后会结束本次循环，在下一次循环中，如果没有新的更早的task加入，则当前的task将会被执行。

核心部分

从上面的介绍可知，TimerThread的调度核心是起一个while循环，不断检查是否有task需要执行，其中两次调用了queue.wait()方法。那在哪些情况下queue.notify()方法会被调用呢？

1. 当向Timer中增加新的Task，并且该Task是所有Task中应该被最先执行的Task时：

     private void sched(TimerTask task, long time, long period) {
       if (time < 0)
           throw new IllegalArgumentException("Illegal execution time.");
   
       // Constrain value of period sufficiently to prevent numeric
       // overflow while still being effectively infinitely large.
       if (Math.abs(period) > (Long.MAX_VALUE >> 1))
           period >>= 1;
   
       synchronized(queue) {
           if (!thread.newTasksMayBeScheduled)
               throw new IllegalStateException("Timer already cancelled.");
   
           synchronized(task.lock) {
               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();
       }
   }

   为什么需要queue.getMin() == task时才调用notify方法呢？因为只有新加入的task是所有Task中要被最早执行的task时，才会需要打断TimeThread的等待状态。举个例子，当前队列中有两个task，分别是A（3分钟后到时间）、B（5分钟后到时间），此时TimerThread正在等待A的时间到来，所以会调用queue.wait(3min)，这个时候，队列中新增一个任务C（1分钟后到时），如果不打断queue.wait(3min)，那当wait(3min)自然结束时，C任务已经过期了… 但是如果新加入的C任务是需要在4分钟后执行，那就没必要打断wait(3min)的状态，因为就算wait(3min)自然结束时，C也还没到时间.

2. 调用Timer的cancel接口时

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

   该方法会把队列清空，并且把newTasksMayBeScheduled标志设置为false，这个时候如果不调用queue.notify()，在queue本来就已经empty的情况下，TimerThread的mainloop就会陷入死等待：

    /**
    * The main timer loop.  (See class comment.)
    */
   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();

3. 是否上面两种情况调用notify就已经足够了？当queue为空，并且没人调用add或cancel方法时，TimerThread永远都不会stop，所以机智的JDK还加上了一种比较保险的方法：

       /**
    * This object causes the timer's task execution thread to exit
    * gracefully when there are no live references to the Timer object and no
    * tasks in the timer queue.  It is used in preference to a finalizer on
    * Timer as such a finalizer would be susceptible to a subclass's
    * finalizer forgetting to call it.
    */
   private final Object threadReaper = new Object() {
       protected void finalize() throws Throwable {
           synchronized(queue) {
               thread.newTasksMayBeScheduled = false;
               queue.notify(); // In case queue is empty.
           }
       }
   };

   用到了Object对象的finalize方法，大家都知道finalize方法是对象被GC的时候调用的。上述做法的思路是:当一个Timer已经没有任何对象引用时，自然不会有新的Task加入到队列中，Timer对象自然也就会被垃圾回收，此时TimerThread也就应该stop了，所以在垃圾回收的时候还应该把newTasksMayBeScheduled设置为false，并且唤起正在wait的TimerThread线程。所以说，如果你创建的Timer不再需要了，最好是调用cancel接口手动取消，否则的话TimerThread就需要等到垃圾回收的时候才会stop。