定時(shí)器的實(shí)現(xiàn)原理及參考

public class DebugerTest {
    public static void main(String[] args) {        DebugerTest test = new DebugerTest();        Timer timer = new Timer();        timer.schedule(new TimerTask() {            @Override            public void run() {                try {                    test.moveABrick();                } catch (Exception e) {                    e.printStackTrace();                }            }        }, 1000, 5000);
        timer.schedule(new TimerTask() {            @Override            public void run() {                    Long nowTimestamp = System.currentTimeMillis() / 1000;                    System.out.println(nowTimestamp + " [" + Thread.currentThread().getName() + "] " + ": hello, new schedule...");            }        }, 1000, 1000);    }
    // 去搬磚    public void moveABrick() {        int i = 0;        while (true) {            if(i++ < 3) {                Long nowTimestamp = System.currentTimeMillis() / 1000;                System.out.println(nowTimestamp + " [" + Thread.currentThread().getName() + "] " + ": moving step +" + i);                // 用于展示并發(fā)效果, 驗(yàn)證結(jié)果是，正常情況下并不會存在并發(fā)                try {                    Thread.sleep(3000L);                } catch (InterruptedException e) {                    // interrupt                }            }            else {                break;            }        }        System.out.println("move over.");    }}

private final TimerThread thread = new TimerThread(queue);
    public Timer() {        this("Timer-" + serialNumber());    }
    public Timer(String name) {        thread.setName(name);        // 看到了吧，只要new一個(gè)定時(shí)器，就會有一個(gè)線程在跑了，所以沒事別搞那么多 timer出來哈哈        thread.start();    }

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 {            // 就干一件事，去循環(huán)輪詢，當(dāng)然還要做一些善后工作            mainLoop();        } finally {            // Someone killed this Thread, behave as if Timer cancelled            synchronized(queue) {                newTasksMayBeScheduled = false;                queue.clear();  // Eliminate obsolete references            }        }    }
    private void mainLoop() {        while (true) {            try {                TimerTask task;                boolean taskFired;                // 由于queue是非線程安全的，所以要使用同步鎖定                synchronized(queue) {                    // 如果隊(duì)列為空則一直等待，如果發(fā)生了異常，則結(jié)束任務(wù)                    while (queue.isEmpty() && newTasksMayBeScheduled)                        // 此等待為 Object 類的阻塞等等，與 synchronized 一起使用                        queue.wait();                    if (queue.isEmpty())                        break;
                    long currentTime, executionTime;                    // 獲取隊(duì)列頭的任務(wù)（最早可能執(zhí)行的任務(wù)），進(jìn)行判定                    task = queue.getMin();                    synchronized(task.lock) {                        // 如果任務(wù)已設(shè)置取消，則移除隊(duì)列                        if (task.state == TimerTask.CANCELLED) {                            queue.removeMin();                            continue;                        }                        currentTime = System.currentTimeMillis();                        executionTime = task.nextExecutionTime;                        // 時(shí)間判定，如果小于當(dāng)前時(shí)間，則可以執(zhí)行任務(wù)                        if (taskFired = (executionTime<=currentTime)) {                            // period=0,意味著不需要再循環(huán)任務(wù)了                            if (task.period == 0) {                                 queue.removeMin();                                task.state = TimerTask.EXECUTED;                            } else {                                // 如果是需要多次執(zhí)行的任務(wù)，則重新讓把隊(duì)列加入，然后重排序                                queue.rescheduleMin(                                  task.period<0 ? currentTime   - task.period                                                : executionTime + task.period);                            }                        }                    }                    // 任務(wù)執(zhí)行時(shí)間還沒有到，阻塞等待，超時(shí)時(shí)間到時(shí)，也就是任務(wù)開始執(zhí)行的時(shí)刻到了                    if (!taskFired)                         queue.wait(executionTime - currentTime);                }                // 經(jīng)過前面的檢查，到此處一般就可以執(zhí)行任務(wù)了，同步調(diào)用                if (taskFired)                     // 注意是同步調(diào)用, 原因嘛，我也不知道                    task.run();            } catch(InterruptedException e) {            }        }    }}

// 以定時(shí)間隔的方式重復(fù)執(zhí)行    public void schedule(TimerTask task, long delay, long period) {        if (delay < 0)            throw new IllegalArgumentException("Negative delay.");        if (period <= 0)            throw new IllegalArgumentException("Non-positive period.");        sched(task, System.currentTimeMillis()+delay, -period);    }    // 調(diào)用內(nèi)部封裝好的任務(wù)計(jì)劃     private void sched(TimerTask task, long time, long period) {        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");                // 設(shè)置任務(wù)執(zhí)行時(shí)間，狀態(tài)                task.nextExecutionTime = time;                task.period = period;                task.state = TimerTask.SCHEDULED;            }
            // 添加任務(wù)到隊(duì)列，則判定如果當(dāng)前任務(wù)就是第一個(gè)(有且僅有時(shí)，定時(shí)器處理阻塞等待狀態(tài))的話，觸發(fā)一次notify(), 使用線程的 wait() 開始執(zhí)行。            queue.add(task);            if (queue.getMin() == task)                queue.notify();        }    }

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.     * 隊(duì)列的容器，是經(jīng)過按時(shí)間排序的數(shù)組     */    private TimerTask[] queue = new TimerTask[128];
    private int size = 0;
    int size() {        return size;    }
    // 添加任務(wù)，必要時(shí)進(jìn)行擴(kuò)容    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);    }
    /**     * 獲取隊(duì)列頭的任務(wù)，即第一個(gè)元素     */    TimerTask getMin() {        return queue[1];    }
    TimerTask get(int i) {        return queue[i];    }
    /**     * 執(zhí)行完成后，刪除隊(duì)頭     */    void removeMin() {        queue[1] = queue[size];        queue[size--] = null;  // Drop extra reference to prevent memory leak        fixDown(1);    }
    /**     * 快速刪除隊(duì)列     */    void quickRemove(int i) {        assert i <= size;
        queue[i] = queue[size];        queue[size--] = null;  // Drop extra ref to prevent memory leak    }
    /**     * 將隊(duì)頭任務(wù)重新入隊(duì)，僅改下下次執(zhí)行時(shí)間即可，每次添加更新完成都需要做一次重排序     */    void rescheduleMin(long newTime) {        queue[1].nextExecutionTime = newTime;        fixDown(1);    }
    boolean isEmpty() {        return size==0;    }
    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.     * 隊(duì)列重排序，增加元素時(shí)使用     */    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.     * 隊(duì)列重排序，減少元素時(shí)使用     */    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);    }}

public abstract class TimerTask implements Runnable {
    // 同步鎖    final Object lock = new Object();
    int state = VIRGIN;
    // 定義任務(wù)的幾種狀態(tài)用以判定是否需要執(zhí)行    static final int VIRGIN = 0;
    static final int SCHEDULED   = 1;
    static final int EXECUTED    = 2;
    static final int CANCELLED   = 3;
    long nextExecutionTime;
    /**     * Period in milliseconds for repeating tasks.  A positive value indicates     * fixed-rate execution.  A negative value indicates fixed-delay execution.     * A value of 0 indicates a non-repeating task.     * 正數(shù)代表以固定速度執(zhí)行，負(fù)數(shù)代表以固定時(shí)間延遲執(zhí)行，0代表不重復(fù)執(zhí)行     */    long period = 0;
    /**     * Creates a new timer task.     */    protected TimerTask() {    }
    /**     * The action to be performed by this timer task.     * 實(shí)現(xiàn)類只要實(shí)現(xiàn)這個(gè)方法，就可以執(zhí)行指定的任務(wù)了，     *         其他方法一般情況下，統(tǒng)一由父抽象類實(shí)現(xiàn)即可     */    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);        }    }}

package java.util;import java.util.Date;import java.util.concurrent.atomic.AtomicInteger;
/** * A facility for threads to schedule tasks for future execution in a * background thread.  Tasks may be scheduled for one-time execution, or for * repeated execution at regular intervals. * * 
Corresponding to each Timer object is a single background * thread that is used to execute all of the timer's tasks, sequentially. * Timer tasks should complete quickly.  If a timer task takes excessive time * to complete, it "hogs" the timer's task execution thread.  This can, in * turn, delay the execution of subsequent tasks, which may "bunch up" and * execute in rapid succession when (and if) the offending task finally * completes. * * 
After the last live reference to a Timer object goes away * and all outstanding tasks have completed execution, the timer's task * execution thread terminates gracefully (and becomes subject to garbage * collection).  However, this can take arbitrarily long to occur.  By * default, the task execution thread does not run as a daemon thread, * so it is capable of keeping an application from terminating.  If a caller * wants to terminate a timer's task execution thread rapidly, the caller * should invoke the timer's cancel method. * * 
If the timer's task execution thread terminates unexpectedly, for * example, because its stop method is invoked, any further * attempt to schedule a task on the timer will result in an * IllegalStateException, as if the timer's cancel * method had been invoked. * * 
This class is thread-safe: multiple threads can share a single * Timer object without the need for external synchronization. * * 
This class does not offer real-time guarantees: it schedules * tasks using the Object.wait(long) method. * * 
Java 5.0 introduced the {@code java.util.concurrent} package and * one of the concurrency utilities therein is the {@link * java.util.concurrent.ScheduledThreadPoolExecutor * ScheduledThreadPoolExecutor} which is a thread pool for repeatedly * executing tasks at a given rate or delay.  It is effectively a more * versatile replacement for the {@code Timer}/{@code TimerTask} * combination, as it allows multiple service threads, accepts various * time units, and doesn't require subclassing {@code TimerTask} (just * implement {@code Runnable}).  Configuring {@code * ScheduledThreadPoolExecutor} with one thread makes it equivalent to * {@code Timer}. * * 
Implementation note: This class scales to large numbers of concurrently * scheduled tasks (thousands should present no problem).  Internally, * it uses a binary heap to represent its task queue, so the cost to schedule * a task is O(log n), where n is the number of concurrently scheduled tasks. * * 
Implementation note: All constructors start a timer thread. * * @author  Josh Bloch * @see     TimerTask * @see     Object#wait(long) * @since   1.3 */
public class 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);
    /**     * This object causes the timer's task execution thread to exit     * gracefully when there are no live references to the Timer object and no     * tasks in the timer queue.  It is used in preference to a finalizer on     * Timer as such a finalizer would be susceptible to a subclass's     * finalizer forgetting to call it.     */    private final Object threadReaper = new Object() {        protected void finalize() throws Throwable {            synchronized(queue) {                thread.newTasksMayBeScheduled = false;                queue.notify(); // In case queue is empty.            }        }    };
    /**     * This ID is used to generate thread names.     */    private final static AtomicInteger nextSerialNumber = new AtomicInteger(0);    private static int serialNumber() {        return nextSerialNumber.getAndIncrement();    }
    /**     * Creates a new timer.  The associated thread does not     * {@linkplain Thread#setDaemon run as a daemon}.     */    public Timer() {        this("Timer-" + serialNumber());    }
    /**     * Creates a new timer whose associated thread may be specified to     * {@linkplain Thread#setDaemon run as a daemon}.     * A daemon thread is called for if the timer will be used to     * schedule repeating "maintenance activities", which must be     * performed as long as the application is running, but should not     * prolong the lifetime of the application.     *     * @param isDaemon true if the associated thread should run as a daemon.     */    public Timer(boolean isDaemon) {        this("Timer-" + serialNumber(), isDaemon);    }
    /**     * Creates a new timer whose associated thread has the specified name.     * The associated thread does not     * {@linkplain Thread#setDaemon run as a daemon}.     *     * @param name the name of the associated thread     * @throws NullPointerException if {@code name} is null     * @since 1.5     */    public Timer(String name) {        thread.setName(name);        thread.start();    }
    /**     * Creates a new timer whose associated thread has the specified name,     * and may be specified to     * {@linkplain Thread#setDaemon run as a daemon}.     *     * @param name the name of the associated thread     * @param isDaemon true if the associated thread should run as a daemon     * @throws NullPointerException if {@code name} is null     * @since 1.5     */    public Timer(String name, boolean isDaemon) {        thread.setName(name);        thread.setDaemon(isDaemon);        thread.start();    }
    /**     * Schedules the specified task for execution after the specified delay.     *     * @param task  task to be scheduled.     * @param delay delay in milliseconds before task is to be executed.     * @throws IllegalArgumentException if delay is negative, or     *         delay + System.currentTimeMillis() is negative.     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} is null     */    public void schedule(TimerTask task, long delay) {        if (delay < 0)            throw new IllegalArgumentException("Negative delay.");        sched(task, System.currentTimeMillis()+delay, 0);    }
    /**     * Schedules the specified task for execution at the specified time.  If     * the time is in the past, the task is scheduled for immediate execution.     *     * @param task task to be scheduled.     * @param time time at which task is to be executed.     * @throws IllegalArgumentException if time.getTime() is negative.     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} or {@code time} is null     */    public void schedule(TimerTask task, Date time) {        sched(task, time.getTime(), 0);    }
    /**     * Schedules the specified task for repeated fixed-delay execution,     * beginning after the specified delay.  Subsequent executions take place     * at approximately regular intervals separated by the specified period.     *     * 
In fixed-delay execution, each execution is scheduled relative to     * the actual execution time of the previous execution.  If an execution     * is delayed for any reason (such as garbage collection or other     * background activity), subsequent executions will be delayed as well.     * In the long run, the frequency of execution will generally be slightly     * lower than the reciprocal of the specified period (assuming the system     * clock underlying Object.wait(long) is accurate).     *     * 
Fixed-delay execution is appropriate for recurring activities     * that require "smoothness."  In other words, it is appropriate for     * activities where it is more important to keep the frequency accurate     * in the short run than in the long run.  This includes most animation     * tasks, such as blinking a cursor at regular intervals.  It also includes     * tasks wherein regular activity is performed in response to human     * input, such as automatically repeating a character as long as a key     * is held down.     *     * @param task   task to be scheduled.     * @param delay  delay in milliseconds before task is to be executed.     * @param period time in milliseconds between successive task executions.     * @throws IllegalArgumentException if {@code delay < 0}, or     *         {@code delay + System.currentTimeMillis() < 0}, or     *         {@code period <= 0}     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} is null     */    public void schedule(TimerTask task, long delay, long period) {        if (delay < 0)            throw new IllegalArgumentException("Negative delay.");        if (period <= 0)            throw new IllegalArgumentException("Non-positive period.");        sched(task, System.currentTimeMillis()+delay, -period);    }
    /**     * Schedules the specified task for repeated fixed-delay execution,     * beginning at the specified time. Subsequent executions take place at     * approximately regular intervals, separated by the specified period.     *     * 
In fixed-delay execution, each execution is scheduled relative to     * the actual execution time of the previous execution.  If an execution     * is delayed for any reason (such as garbage collection or other     * background activity), subsequent executions will be delayed as well.     * In the long run, the frequency of execution will generally be slightly     * lower than the reciprocal of the specified period (assuming the system     * clock underlying Object.wait(long) is accurate).  As a     * consequence of the above, if the scheduled first time is in the past,     * it is scheduled for immediate execution.     *     * 
Fixed-delay execution is appropriate for recurring activities     * that require "smoothness."  In other words, it is appropriate for     * activities where it is more important to keep the frequency accurate     * in the short run than in the long run.  This includes most animation     * tasks, such as blinking a cursor at regular intervals.  It also includes     * tasks wherein regular activity is performed in response to human     * input, such as automatically repeating a character as long as a key     * is held down.     *     * @param task   task to be scheduled.     * @param firstTime First time at which task is to be executed.     * @param period time in milliseconds between successive task executions.     * @throws IllegalArgumentException if {@code firstTime.getTime() < 0}, or     *         {@code period <= 0}     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} or {@code firstTime} is null     */    public void schedule(TimerTask task, Date firstTime, long period) {        if (period <= 0)            throw new IllegalArgumentException("Non-positive period.");        sched(task, firstTime.getTime(), -period);    }
    /**     * Schedules the specified task for repeated fixed-rate execution,     * beginning after the specified delay.  Subsequent executions take place     * at approximately regular intervals, separated by the specified period.     *     * 
In fixed-rate execution, each execution is scheduled relative to the     * scheduled execution time of the initial execution.  If an execution is     * delayed for any reason (such as garbage collection or other background     * activity), two or more executions will occur in rapid succession to     * "catch up."  In the long run, the frequency of execution will be     * exactly the reciprocal of the specified period (assuming the system     * clock underlying Object.wait(long) is accurate).     *     * 
Fixed-rate execution is appropriate for recurring activities that     * are sensitive to absolute time, such as ringing a chime every     * hour on the hour, or running scheduled maintenance every day at a     * particular time.  It is also appropriate for recurring activities     * where the total time to perform a fixed number of executions is     * important, such as a countdown timer that ticks once every second for     * ten seconds.  Finally, fixed-rate execution is appropriate for     * scheduling multiple repeating timer tasks that must remain synchronized     * with respect to one another.     *     * @param task   task to be scheduled.     * @param delay  delay in milliseconds before task is to be executed.     * @param period time in milliseconds between successive task executions.     * @throws IllegalArgumentException if {@code delay < 0}, or     *         {@code delay + System.currentTimeMillis() < 0}, or     *         {@code period <= 0}     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} is null     */    public void scheduleAtFixedRate(TimerTask task, long delay, long period) {        if (delay < 0)            throw new IllegalArgumentException("Negative delay.");        if (period <= 0)            throw new IllegalArgumentException("Non-positive period.");        sched(task, System.currentTimeMillis()+delay, period);    }
    /**     * Schedules the specified task for repeated fixed-rate execution,     * beginning at the specified time. Subsequent executions take place at     * approximately regular intervals, separated by the specified period.     *     * 
In fixed-rate execution, each execution is scheduled relative to the     * scheduled execution time of the initial execution.  If an execution is     * delayed for any reason (such as garbage collection or other background     * activity), two or more executions will occur in rapid succession to     * "catch up."  In the long run, the frequency of execution will be     * exactly the reciprocal of the specified period (assuming the system     * clock underlying Object.wait(long) is accurate).  As a     * consequence of the above, if the scheduled first time is in the past,     * then any "missed" executions will be scheduled for immediate "catch up"     * execution.     *     * 
Fixed-rate execution is appropriate for recurring activities that     * are sensitive to absolute time, such as ringing a chime every     * hour on the hour, or running scheduled maintenance every day at a     * particular time.  It is also appropriate for recurring activities     * where the total time to perform a fixed number of executions is     * important, such as a countdown timer that ticks once every second for     * ten seconds.  Finally, fixed-rate execution is appropriate for     * scheduling multiple repeating timer tasks that must remain synchronized     * with respect to one another.     *     * @param task   task to be scheduled.     * @param firstTime First time at which task is to be executed.     * @param period time in milliseconds between successive task executions.     * @throws IllegalArgumentException if {@code firstTime.getTime() < 0} or     *         {@code period <= 0}     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} or {@code firstTime} is null     */    public void scheduleAtFixedRate(TimerTask task, Date firstTime,                                    long period) {        if (period <= 0)            throw new IllegalArgumentException("Non-positive period.");        sched(task, firstTime.getTime(), period);    }
    /**     * Schedule the specified timer task for execution at the specified     * time with the specified period, in milliseconds.  If period is     * positive, the task is scheduled for repeated execution; if period is     * zero, the task is scheduled for one-time execution. Time is specified     * in Date.getTime() format.  This method checks timer state, task state,     * and initial execution time, but not period.     *     * @throws IllegalArgumentException if time is negative.     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} is null     */    private void sched(TimerTask task, long time, long period) {        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();        }    }
    /**     * Terminates this timer, discarding any currently scheduled tasks.     * Does not interfere with a currently executing task (if it exists).     * Once a timer has been terminated, its execution thread terminates     * gracefully, and no more tasks may be scheduled on it.     *     * 
Note that calling this method from within the run method of a     * timer task that was invoked by this timer absolutely guarantees that     * the ongoing task execution is the last task execution that will ever     * be performed by this timer.     *     * 
This method may be called repeatedly; the second and subsequent     * calls have no effect.     */    public void cancel() {        synchronized(queue) {            thread.newTasksMayBeScheduled = false;            queue.clear();            queue.notify();  // In case queue was already empty.        }    }
    /**     * Removes all cancelled tasks from this timer's task queue.  Calling     * this method has no effect on the behavior of the timer, but     * eliminates the references to the cancelled tasks from the queue.     * If there are no external references to these tasks, they become     * eligible for garbage collection.     *     * 
Most programs will have no need to call this method.     * It is designed for use by the rare application that cancels a large     * number of tasks.  Calling this method trades time for space: the     * runtime of the method may be proportional to n + c log n, where n     * is the number of tasks in the queue and c is the number of cancelled     * tasks.     *     * 
Note that it is permissible to call this method from within a     * a task scheduled on this timer.     *     * @return the number of tasks removed from the queue.     * @since 1.5     */     public int purge() {         int result = 0;
         synchronized(queue) {             for (int i = queue.size(); i > 0; i--) {                 if (queue.get(i).state == TimerTask.CANCELLED) {                     queue.quickRemove(i);                     result++;                 }             }
             if (result != 0)                 queue.heapify();         }
         return result;     }}
/** * This "helper class" implements the timer's task execution thread, which * waits for tasks on the timer queue, executions them when they fire, * reschedules repeating tasks, and removes cancelled tasks and spent * non-repeating tasks from the queue. */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) {            }        }    }}
/** * This class represents a timer task queue: a priority queue of TimerTasks, * ordered on nextExecutionTime.  Each Timer object has one of these, which it * shares with its TimerThread.  Internally this class uses a heap, which * offers log(n) performance for the add, removeMin and rescheduleMin * operations, and constant time performance for the getMin operation. */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];
    /**     * 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) {        // 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);    }}