Timer和TimerTask

最近遇到了一下Timer和TimerTask。以前没有认真看，这次正好有空就看看。略记如下。

先看下简单的例子：

public class TestTimer {
	private static final int MAX_COUNT = 10;
	private static volatile int count = 0;
	public static void main(String[] args) {
		Timer t = new Timer();		
		//t.schedule(new ETimer(), 0);
		t.schedule(new ETimer(),0, 2000);
		//Notice here, the count must be volatile !!!!!
		while(count < MAX_COUNT) {
			;
		}
		t.cancel();
		
	}	
	
	private static class ETimer extends TimerTask {
		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName() + ",count=" + count);
			count++;
		}		
	}
}

例子很简单。新建一个Timer，然后需要重新写一个Task类继承TimeTask。调用Schedule() 方法就可以了。结果如下：

Timer-0,count=0
Timer-0,count=1
Timer-0,count=2
Timer-0,count=3
Timer-0,count=4
Timer-0,count=5
Timer-0,count=6
Timer-0,count=7
Timer-0,count=8
Timer-0,count=9

TimeTask里面必须要Override的方法是run，猜测应该是跟Runnable有关。点进去看看。

public abstract class TimerTask implements Runnable

猜测没错。

那么这个run方法是怎么被调用的呢？肯定是Timer在schedule里面调用的。

看看Timer的结构：

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 TaskQueue queue = new TaskQueue();

    /**
     * The timer thread.
     */
    private TimerThread thread = new TimerThread(queue);

哦哦，里面有个Queue保存着Task。

开了一个线程TimerThread，并把queue赋给了它。

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;

这个Queue是用数组实现的，且数组的0号index不存放TimerTask。

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

这个add方法就是往数组里面加一个TimerTask吧。慢着，这个fixUp是干嘛的？

除了fixUp还有一个fixDown哈哈。

堆， 对，就是堆！

那就是把最前面的那个TimerTask放在堆的顶部了。下次直接取前面的那个就好啦。

再看看TimerThread：

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; //一个很重要的标志位。Timer的cancel方法跟这个有关。

    /**
     * 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) {
            }
        }
    }
}

主要在mainLoop里面，取堆顶的元素，然后看看它是否需要执行。如果需要执行，设定好时间，到时候执行

  task.run();

看看Timer的cancel方法是怎么影响这个的

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

将标志位置0，然后清空queue。

再到mainLoop，可以跳到break， 跳出最外面的while循环（注意是run方法中的while， 不是mainLoop中的while），TimerThread结束。因此整个方法也结束了。

在Timer里面， 有单次的也有循环的，通过参数个数不同而很容易区分。但是有两个特别相近:

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);//NOTICE 最后的参数是一个负数
    }

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);//NOTICE:最后的参数是一个正数
    }

private void sched(TimerTask task, long time, long period) {
        if (time < 0)
            throw new IllegalArgumentException("Illegal execution time.");

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

两个方法都调用了上面的sched方法。主要是往Queue里面加入Task。注意在：

task.period = period; 

处，period的正反性是不变的.

回想上面TimerThread类的mainLoop方法里面是不是有关于period的正负性质的判断？

queue.rescheduleMin(
                                  task.period<0 ? currentTime   - task.period
                                                : executionTime + task.period);

看看rescheduleMin方法：

void rescheduleMin(long newTime) {
        queue[1].nextExecutionTime = newTime;
        fixDown(1);
    }

可以看到一个设置的是在当前时间之后的period的时间， 一个是设置的在执行时间后的时间。

那有什么区别呢？在于TimeTask的任务是不是能够在间隔时间内执行完。schedule方法和scheduleAtFixedRate主要是为了解决--如果执行时间超过了间隔时间，该如何重新设置定时器的问题。

关于这两个的比较一个比较好的博客是：

http://www.ewdna.com/2011/12/java-timerschedulescheduleatfixedrate.html

也可以顺带着看下：

http://www.ewdna.com/2011/12/java-timer.html

结合例子和源码可以看出更深层次的不同之处。

后续有空可以仔细看看内部的细节如锁机制等等。