Timer

public class TimerTest {
    public static void main(String[] args) {
        final Timer1 timer = new Timer1("定时器线程");
        Ticket ticket = new Ticket(timer);
        Thread t0 = new Thread(ticket);
        t0.start();
        Thread t1 = new Thread(ticket);
        t1.start();
        Thread t2 = new Thread(ticket);
        t2.start();
    }
    
    static class Ticket implements Runnable {
        private Timer1 timer = null;
        Ticket(Timer1 timer){
            this.timer = timer;
        }
        public void  run() {
             MyTimerTask myTask = new MyTimerTask("TimerTask1 1");
            timer.schedule(myTask, 2000L, 1000L);
        }
    }
}

public class MyTimerTask extends TimerTask1 {
    private String taskName;
    public MyTimerTask(String taskName) {
        this.taskName = taskName;
    }
    public String getTaskName() {
        return taskName;
    }
    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }
    @Override
    public void run() {
        System.out.println("当前执行的任务是：" + taskName);
    }
}

public class Timer1 {
     
    private final TaskQueue queue = new TaskQueue();//这是一个最小堆，它存放所有TimerTask。一个数组
    
    //定时任务只会创建一个线程，所以如果存在多个任务，且任务时间过长，超过了两个任务的间隔时间
    private final TimerThread thread = new TimerThread(queue);//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.
            }
        }
    };

    private final static AtomicInteger nextSerialNumber = new AtomicInteger(0);
    private static int serialNumber() {
        return nextSerialNumber.getAndIncrement();
    }

    public Timer1() {
        this("Timer-" + serialNumber());
    }

    public Timer1(boolean isDaemon) {
        this("Timer-" + serialNumber(), isDaemon);//是否守护线程
    }

    public Timer1(String name) {
        thread.setName(name);
        thread.start();
    }

    public Timer1(String name, boolean isDaemon) {
        thread.setName(name);
        thread.setDaemon(isDaemon);
        thread.start();
    }

    public void schedule(TimerTask1 task, long delay) {//在时间等于或超过time的时候执行且只执行一次task，
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        sched(task, System.currentTimeMillis()+delay, 0);
    }

    public void schedule(TimerTask1 task, Date time) {
        sched(task, time.getTime(), 0);
    }

    public void schedule(TimerTask1 task, long delay, long period) {//在时间等于或超过time的时候首次执行task，之后每隔period毫秒重复执行一次task 。
        if (delay < 0)
            throw new IllegalArgumentException("Negative delay.");
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, System.currentTimeMillis()+delay, -period);
    }

    public void schedule(TimerTask1 task, Date firstTime, long period) {
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, firstTime.getTime(), -period);
    }

    public void scheduleAtFixedRate(TimerTask1 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);
    }

    public void scheduleAtFixedRate(TimerTask1 task, Date firstTime,
                                    long period) {
        if (period <= 0)
            throw new IllegalArgumentException("Non-positive period.");
        sched(task, firstTime.getTime(), period);
    }

    private void sched(TimerTask1 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 != TimerTask1.VIRGIN)
                    throw new IllegalStateException(
                        "Task already scheduled or cancelled");
                task.nextExecutionTime = time;
                task.period = period;
                task.state = TimerTask1.SCHEDULED;
            }
            queue.add(task);
            //当timer对象调用schedule方法时，都会向队列添加元素，并唤醒TaskQueue队列上的线程，
            //这时候TimerThread会被唤醒，继续执行mainLoop方法。
            if (queue.getMin() == task)
                queue.notify();//多线程对同一队列出队入队，使用synchronized，queue.notify()
        }
    }

    public void cancel() {
        synchronized(queue) {
            thread.newTasksMayBeScheduled = false;
            queue.clear();
            queue.notify();  // In case queue was already empty.
        }
    }

     public int purge() {
         int result = 0;
         synchronized(queue) {
             for (int i = queue.size(); i > 0; i--) {
                 if (queue.get(i).state == TimerTask1.CANCELLED) {
                     queue.quickRemove(i);
                     result++;
                 }
             }
             if (result != 0)
                 queue.heapify();
         }
         return result;
     }
}

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;

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

    private void mainLoop() {//拿出任务队列中的第一个任务，如果执行时间还没有到，则继续等待，否则立即执行。
        while (true) {//函数执行的是一个死循环
            try {
                TimerTask1 task;
                boolean taskFired;
                synchronized(queue) {//并且加了queue锁，从而保证是线程安全的。
                    // 队列为空等待
                    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();
                    /*
                    queue.getMin()找到任务队列中执行时间最早的元素，
                      然后判断元素的state，period，nextExecutionTime，SCHEDULED等属性，从而确定任务是否可执行。
                       主要是判断这几个属性：1，state 属性，如果为取消（即我们调用了timer的cancel方法取消了某一任务），
                       则会从队列中删除这个元素，然后继续循环；2，period 属性，如果为单次执行，这个值为0，周期执行的话，
                       为我们传入的intervalTime值，如果为0，则会移出队列，并设置任务状态为已执行，然后下面的 task.run()会执行任务，
                       如果这个值不为0，则会修正队列，设置这个任务的再一次执行时间，queue.rescheduleMin这个函数来完成的这个操作； 3，taskFired
                       属性， 如果 executionTime<=currentTime 则设置为true，可以执行， 否则线程就会进行休眠，休眠时间为两者之差。
                     */
                    synchronized(task.lock) {
                        if (task.state == TimerTask1.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 = TimerTask1.EXECUTED;
                            } else { // Repeating task, reschedule
                                queue.rescheduleMin(
                                  task.period<0 ? currentTime   - task.period
                                                : executionTime + task.period);
                            }
                        }
                    }
                    //会对TaskQueue队列的首元素进行判断，看是否达到执行时间，
                    //如果没有，则进行休眠，休眠时间为队首任务的开始执行时间到当前时间的时间差。
                    if (!taskFired) 
                        queue.wait(executionTime - currentTime);
                }
                if (taskFired)  
                    task.run();
            } catch(InterruptedException e) {
            }
        }
    }
}

class TaskQueue {
    
    /*TaskQueue是一个平衡二叉堆，具有最小 nextExecutionTime 的 TimerTask 在队列中为 queue[1] ，
                  也就是堆中的根节点。第 n 个位置 queue[n] 的子节点分别在 queue[2n] 和 queue[2n+1] 
      
                  也就是说TimerTask 在堆中的位置其实是通过nextExecutionTime 来决定的。
      nextExecutionTime 越小，那么在堆中的位置越靠近根，越有可能先被执行。而nextExecutionTime意思就是下一次执行开始的时间。
    */
    private TimerTask1[] queue = new TimerTask1[128];//默认128

    private int size = 0;

    int size() {
        return size;
    }

    void add(TimerTask1 task) {//根据执行时间的先后对数组元素进行排序，从而确定最先开始执行的任务，
        if (size + 1 == queue.length)
            queue = Arrays.copyOf(queue, 2*queue.length);
        queue[++size] = task;
        fixUp(size);
    }

    TimerTask1 getMin() {
        return queue[1];
    }

    TimerTask1 get(int i) {
        return queue[i];
    }

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

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

    private void fixUp(int k) {//维护最小堆
        while (k > 1) {
            int j = k >> 1;
            if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
                break;
            TimerTask1 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;
            TimerTask1 tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
            k = j;
        }
    }

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

public abstract class TimerTask1 implements Runnable {
    /**
     * This object is used to control access to the TimerTask1 internals.
     */
    final Object lock = new Object();

    /**
     * The state of this task, chosen from the constants below.
     */
    int state = VIRGIN;

    /**
     * This task has not yet been scheduled.
     */
    static final int VIRGIN = 0;

    /**
     * This task is scheduled for execution.  If it is a non-repeating task,
     * it has not yet been executed.
     */
    static final int SCHEDULED   = 1;

    /**
     * This non-repeating task has already executed (or is currently
     * executing) and has not been cancelled.
     */
    static final int EXECUTED    = 2;

    /**
     * This task has been cancelled (with a call to TimerTask1.cancel).
     */
    static final int CANCELLED   = 3;

    /**
     * Next execution time for this task in the format returned by
     * System.currentTimeMillis, assuming this task is scheduled for execution.
     * For repeating tasks, this field is updated prior to each task execution.
     */
    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.
     */
    long period = 0;

    /**
     * Creates a new timer task.
     */
    protected TimerTask1() {
    }

    /**
     * The action to be performed by this timer task.
     */
    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);
        }
    }
}