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

最新推荐文章于 2024-01-22 13:09:39 发布

原创最新推荐文章于 2024-01-22 13:09:39 发布 · 3.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #api

Java 同时被 2 个专栏收录

34 篇文章

订阅专栏

算法

1 篇文章

订阅专栏

本文深入解析了Java中Timer类的任务调度机制，详细介绍了其内部使用的平衡二叉堆数据结构及其实现原理。通过具体代码展示了如何添加任务并维持堆的有序状态，以及如何移除堆顶元素并重新调整堆结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Timer中的定义：

private final TaskQueue queue = new TaskQueue();

定义了一个队列：

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

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