java.util.Timer浅析

   Timer是JDK中的定时调度类，主要用来定时触发任务：

1. 用法：

Timer是调度控制器，TimerTask是可调度的任务：

import java.util.Date;
import java.util.TimerTask;

public class PlainTimerTask extends TimerTask {

    @Override
    public void run() {
        System.out.println(new Date());

    }

}

调度过程：

import java.util.Timer;

public class TimerRunner {

    public static void main(String [] args){
        Timer timer=new Timer();
        timer.schedule(new PlainTimerTask(), 5000L);
    }

}

2.原理：

     其基本处理模型是单线程调度的任务队列模型，Timer不停地接受调度任务，所有任务接受Timer调度后加入TaskQueue,TimerThread不停地去TaskQueue中取任务来执行.

     从图上不难看出，这就是生产者--消费者模型的一种特例：多生产者,单消费者模型。

     此种消息队列实现方式在浏览器中的编程模型中也有类似的实现，javascript中的定时执行函数setTimeout(expression,milliseconds)也是基于此种原理实现的。

     此种方式的不足之处为当某个任务执行时间较长，以致于超过了TaskQueue中下一个任务开始执行的时间，会影响整个任务执行的实时性。为了提高实时性，可以采用多个消费者一起消费来提高处理效率，避免此类问题的实现。

3.核心代码：

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

1.先获得队列锁，然后去TaskQueue中取TimerTask，然后去判断此队列为空且新任务可安排标记是打开的。如果不满足，线程等待，将队列锁释放。

2.如果队列为空，那么跳出死循环。

3.取得队列中的下一个元素，并获得任务锁。

4.检查任务状态，如果任务状态为取消，那么直接取消，并跳过此轮循环。

5.得到任务的计划执行时间，并检查与当前时间的先后，如果当前时间已经到或者超过计划执行时间，那么置状态位为执行。

6.释放任务锁。

7.如果没有，线程等待执行时间和当前时间差。

8.释放队列锁

9.看任务是否可以执行标记，来确定是否执行任务

10反复从1开始