Timer定时器

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);

java.util.TimerThread继承Thread类，内部维护一个TaskQueue变量，然后run方法中无限循环从TaskQueue中取出第一个节点任务执行

当开始队列为空的时候，调用queue.wait();进入等待队列，当第一个节点任务加入后调用queue.notify();唤醒等待线程后，进入无限循环中。

TaskQueue中维护一个private TimerTask[] queue = new TimerTask[128];数组，需要扩容时，则扩大2倍，

if (size + 1 == queue.length)
            queue = Arrays.copyOf(queue, 2*queue.length);

TaskQueue其实是一个平衡二叉堆（小根堆），根据下次最先执行的时间来排序，所以最先执行的任务总是在堆的根上。在每次添加节点和删除节点时

通过方法fixUp和fixDown来调整堆：

/**
     * 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;
        }
    }

新增节点时调用fixUp方法，不断与父节点比较大小，如果小于父节点则交换位置继续比较

删除节点时调用fixDown方法，不断与子节点比较大小，如果比最小的子节点大，则交换位置，接着继续比较

其等待到任务执行时间主要是通过wait(long timeout)方法等待超时来实现的：

queue.wait(executionTime - currentTime);