【源码】Timer和TimerTask源码剖析

Timer是java.util包中的一个工具类，提供了定时器的功能。我们可以构造一个Timer对象，然后调用其schedule方法在某个特定的时间或者若干延时之后去执行一个特定的任务，甚至你可以让其以特定频率一直执行某个任务，这个任务用TimerTask描述，我们将需要的操作写在TimerTask类的run方法中即可。

本着“知其然，知其所以然”的心态，我决定研究下这个类的源码。

打开Timer类的源码我发现了这样两个成员变量：

 /**     * The timer task queue.  This data structure is shared with the timer     * thread.  The timer produces tasks, via its various schedule calls,     * and the timer thread consumes, executing timer tasks as appropriate,     * and removing them from the queue when they're obsolete.     */    private final TaskQueue queue = new TaskQueue();//任务队列    /**     * The timer thread.     */    private final TimerThread thread = new TimerThread(queue);//执行线程

TaskQueue是一个优先级队列，存放了我们将要执行的TimerTask对象，TimerTask对象是通过Timer类的一系列schedule方法加入队列的，TimerThread负责不断取出TaskQueue中的任务，然后执行之，也就是说，所有的任务都是是在子线程中执行的。TaskQueue队列是以其下次执行时间的先后排序的，TimerThread每次取出的都是需要最先执行的TimerTask。（跟android中的Handler机制很类似~）

优先级队列跟普通队列的最大区别就是，优先级队列每次出队的都是优先级最高的元素，并不是按先进先出的方式。这里优先级队列的实现使用的是堆结构（当然，你也可以使用普通链表，但是每次出队得花O(n)的时间遍历链表找到优先级最大的元素,不划算），插入及更新操作都能维持在O(logn)：

class TaskQueue {    /**     * Priority queue represented as a balanced binary heap: the two children     * of queue[n] are queue[2*n] and queue[2*n+1].  The priority queue is     * ordered on the nextExecutionTime field: The TimerTask with the lowest     * nextExecutionTime is in queue[1] (assuming the queue is nonempty).  For     * each node n in the heap, and each descendant of n, d,     * n.nextExecutionTime <= d.nextExecutionTime.     */    private TimerTask[] queue = new TimerTask[128];//使用数组存储堆元素,最大值128    /**     * The number of tasks in the priority queue.  (The tasks are stored in     * queue[1] up to queue[size]).     */    private int size = 0;//任务数    /**     * Returns the number of tasks currently on the queue.     */    int size() {        return size;    }    /**     * Adds a new task to the priority queue.     */    void add(TimerTask task) {//将TimerTask任务添加到此队列中        // Grow backing store if necessary        if (size + 1 == queue.length)            queue = Arrays.copyOf(queue, 2*queue.length);        queue[++size] = task;        fixUp(size);//调整堆结构---->所谓的上滤    }    /**     * Return the "head task" of the priority queue.  (The head task is an     * task with the lowest nextExecutionTime.)     */    TimerTask getMin() {//优先级最高的元素始终在第一个位置        return queue[1];    }    /**     * Return the ith task in the priority queue, where i ranges from 1 (the     * head task, which is returned by getMin) to the number of tasks on the     * queue, inclusive.     */    TimerTask get(int i) {        return queue[i];    }    /**     * Remove the head task from the priority queue.     */    void removeMin() {        queue[1] = queue[size];        queue[size--] = null;  // Drop extra reference to prevent memory leak        fixDown(1);//调整堆结构----->所谓的下滤    }    /**     * Removes the ith element from queue without regard for maintaining     * the heap invariant.  Recall that queue is one-based, so     * 1 <= i <= size.     */    void quickRemove(int i) {        assert i <= size;        queue[i] = queue[size];        queue[size--] = null;  // Drop extra ref to prevent memory leak    }    /**     * Sets the nextExecutionTime associated with the head task to the     * specified value, and adjusts priority queue accordingly.     */    void rescheduleMin(long newTime) {        queue[1].nextExecutionTime = newTime;        fixDown(1);    }    /**     * Returns true if the priority queue contains no elements.     */    boolean isEmpty() {        return size==0;    }    /**     * Removes all elements from the priority queue.     */    void clear() {        // Null out task references to prevent memory leak        for (int i=1; i<=size; i++)            queue[i] = null;        size = 0;    }    /**     * 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);    }}

TaskQueue内部是一个TimerTask数组，数组元素从1开始，这个数组就是所谓的堆，还是个小顶堆，堆顶元素

始终为第一个元素，每次添加TimerTask都会调用fixup上滤操作，维持堆的特性，每次删除堆顶元素后需要调用fixdown下滤操作，维持堆的特性。heapify是一个建堆函数（类似堆排序中的建堆操作），从第一个非叶子结点开始。

了解TaskQueue后，再看TimerThread类：

class TimerThread extends Thread {    /**     * This flag is set to false by the reaper to inform us that there     * are no more live references to our Timer object.  Once this flag     * is true and there are no more tasks in our queue, there is no     * work left for us to do, so we terminate gracefully.  Note that     * this field is protected by queue's monitor!     */    boolean newTasksMayBeScheduled = true;    /**     * Our Timer's queue.  We store this reference in preference to     * a reference to the Timer so the reference graph remains acyclic.     * Otherwise, the Timer would never be garbage-collected and this     * thread would never go away.     */    private TaskQueue queue;//持有任务队列的引用    TimerThread(TaskQueue queue) {        this.queue = queue;    }    public void run() {        try {            mainLoop();//执行一个死循环，不断从队列中取出任务并执行，没有任务时会阻塞        } finally {            // Someone killed this Thread, behave as if Timer cancelled            synchronized(queue) {                newTasksMayBeScheduled = false;                queue.clear();  // Eliminate obsolete references            }        }    }    /**     * 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();//等待                    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会在run方法中调用mainloop方法，这是一个死循环，不断从任务队列中取出任务，执行之，如果没有任务可执行，将会wait，等待队列非空，而Timer类的schedule方法会调用notify唤醒该线程，执行任务。

private void sched(TimerTask task, long time, long period) {//所有的schedule方法都会调用此方法        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();//唤醒任务执行线程        }    }

那么TimerThread何时被启动的呢？猜猜也能知道，肯定是Timer被创建时执行的：

public Timer(String name) {        thread.setName(name);        thread.start();//启动线程    }

当我们主线程执行完毕后，Timer线程可能仍然处于阻塞或者其他状态，有时这不是我们希望看到的，Timer类有这样一个构造器，可以让任务执行线程以守护线程的方式运行，这样当主线程执行完毕后，守护线程也会停止。

 public Timer(boolean isDaemon) {        this("Timer-" + serialNumber(), isDaemon);    }

以上就是Timer类的源码分析过程，最后贴上一张图，帮助理解：