Timer 源码解读 (2) TaskQueue 最小堆实现的优先队列

Timer中的定义：

private final TaskQueue queue = new TaskQueue();

定义了一个队列：

class TaskQueue {
    /**
     * Priority queue represented as a balanced binary heap: the two children
     * of queue
 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];

Taskqueue是对一个队列的封装，这个队列实现的一个数据结构 a balanced binary heap 平衡二叉堆 并且根据TimerTask中的nextExecutionTime进行排序，最小值在堆顶

添加元素并排序：

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

获得最小元素并排序：

void removeMin() {
        queue[1] = queue[size];
        queue[size--] = null;  // Drop extra reference to prevent memory leak
        fixDown(1);
    }

整体重排序：

void heapify() {
        for (int i = size/2; i >= 1; i--)
            fixDown(i);
    }

fixUp和fixDown是堆排序方法：当插入元素，移除元素的时候都需要重新排序，以使得最小元素在堆顶

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

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