Timer 和 TimerTask 定时任务

 

TimerTask 类

public abstract class TimerTask implements Runnable {
    /**
     * 控制访问timertask内部的锁
     */
    final Object lock = new Object();

    /**
     * 初始状态为0，就是还没有被计划执行
     */
    int state = VIRGIN;

    /**
     * 最初始化的状态
     */
    static final int VIRGIN = 0;

    /**
     * 已经被计划执行了
     */
    static final int SCHEDULED   = 1;

    /**
     * 正在被执行，反正没有被返回
     */
    static final int EXECUTED    = 2;

    /**
     * 已经被返回了，
     */
    static final int CANCELLED   = 3;

    /**
     * 下次将要被执行的时间
     */
    long nextExecutionTime;

    /**
     * 间隔多久执行任务
     */
    long period = 0;

    /**
     * 构造函数
     */
    protected TimerTask() {
    }

    /**
     * 会被子类实现，run的内容就是任务的内容
     */
    public abstract void run();

    /**
     * 执行返回，如果正在被执行，那么会等执行完毕，再返回
     */
    public boolean cancel() {
        synchronized(lock) {
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
        }
    }

    /**
     * 返回下一次要被执行的时间
     */
    public long scheduledExecutionTime() {
        synchronized(lock) {
            return (period < 0 ? nextExecutionTime + period
                               : nextExecutionTime - period);
        }
    }
}

TaskQueue类源码

class TaskQueue {
    /**
     * 优先级任务对列，队列初始化的长度为128，这个队列是一个最小堆
     * 最小堆就是父节点总是小于等于子节点，这里的大小是任务执行的时刻，任务执行的时刻
     * 最小的，放在根节点，就是按照先后顺序
     */
    private TimerTask[] queue = new TimerTask[128];

    /**
     * 优先级对列中的任务数
     */
    private int size = 0;

    /**
     * 返回size的值
     */
    int size() {
        return size;
    }

    /**
     * 向对列添加一个任务
     */
    void add(TimerTask task) {
        // 如果队列中任务数要满的时候，就扩展队列的长度为2倍
        if (size + 1 == queue.length)
            queue = Arrays.copyOf(queue, 2*queue.length);

        queue[++size] = task; //将任务添加到队列中
        fixUp(size); //在队列末尾插入一个任务后，要重新调整最小堆，以保证最小堆的大小顺序
    }

    /**
     * 返回最小堆中的根节点，最小的执行时间的任务
     */
    TimerTask getMin() {
        return queue[1];
    }

    /**
     * 根据下标i，返回任务
     */
    TimerTask get(int i) {
        return queue[i];
    }

    /**
     * 删除最小的任务（根节点），然后将队列末尾的那个值放在根节点处，再调整堆的顺序
     */
    void removeMin() {
        queue[1] = queue[size];
        queue[size--] = null; 
        fixDown(1);
    }

    /**
     * 直接删除第i个节点，然后将队列末尾的那个节点占据i节点位置，不调整堆的顺序
     */
    void quickRemove(int i) {
        assert i <= size;

        queue[i] = queue[size];
        queue[size--] = null;  
    }

    /**
     * 设置根节点的执行时间，然后重新调整堆的顺序
     */
    void rescheduleMin(long newTime) {
        queue[1].nextExecutionTime = newTime;
        fixDown(1);
    }

    /**
     * 判断任务数是否为0
     */
    boolean isEmpty() {
        return size==0;
    }

    /**
     * 将这个队列清空
     */
    void clear() {
        for (int i=1; i<=size; i++)
            queue[i] = null;

        size = 0;
    }

    /**
     * 将K节点从底向上调整堆的顺序
     */
    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;
        }
    }

    /**
     * 从k节点从上向下调整堆顺序
     */
    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;
        }
    }

    /**
     * 调整一个堆的顺序
     */
    void heapify() {
        for (int i = size/2; i >= 1; i--)
            fixDown(i);
    }
}

 最大堆 ，父节点的值总是大于等于子节点的值。

一个节点的下标，比如 7>>1 就跑到了父节点，6也是。

一个节点的下标，比如 1<<1，就跑到了左子节点2，然后2+1，就跑到了右子节点3。

TimerThread类源码

class TimerThread extends Thread {
    /**
     * true代表队列中已经没有任务了，false代表Timer对象的引用已经无效了
     */
    boolean newTasksMayBeScheduled = true;

    /**
     * 任务队列，最小堆
     */
    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) {
            }
        }
    }
}