Timer和ScheduledThreadPoolExecutor的区别及源码分析

基于单线程、系统时间实现的延时、定期任务执行类。具体可以看下面红色标注的代码。

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

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

 Timer延时、定时任务的实现采用单线程，在主循环(mainLoop)中循环遍历任务队列（TaskQueue）,如果执行时间小于等于当前系统时间则执行任务，否则继续等待（执行时间-当前时间）。

基于多线程、JVM时间实现的延时、定期任务执行类。具体可以看下面红色标注的代码。

 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

DelayedWorkQueue中的take方法

public RunnableScheduledFuture<?> take() throws InterruptedException {
            final ReentrantLock lock = this.lock;
            lock.lockInterruptibly();
            try {
                for (;;) {
                    RunnableScheduledFuture<?> first = queue[0];
                    if (first == null)
                        available.await();
                    else {
                        long delay = first.getDelay(NANOSECONDS);
                        if (delay <= 0)
                            return finishPoll(first);
                        first = null; // don't retain ref while waiting
                        if (leader != null)
                            available.await();
                        else {
                            Thread thisThread = Thread.currentThread();
                            leader = thisThread;
                            try {
                                available.awaitNanos(delay);
                            } finally {
                                if (leader == thisThread)
                                    leader = null;
                            }
                        }
                    }
                }
            } finally {
                if (leader == null && queue[0] != null)
                    available.signal();
                lock.unlock();
            }
        }

public long getDelay(TimeUnit unit) {
            return unit.convert(time - now(), NANOSECONDS);
        }

    /**
     * Returns current nanosecond time.
     */
    final long now() {
        return System.nanoTime();
    }

ThreadPoolExecutor执行流程

submit（task）->execute(task)
->1.当前线程数<核心线程数: addWorker(核心工作者线程)->runWorker-> 循环【getTask(workQueue.take)->task.run】
->2.当前线程数>=核心线程数：排队任务成功：task add to workQueue(BlockingQueue)->addWorker（非核心工作者线程）......
->3.当前线程数>=核心线程数：排队任务失败：尝试添加新线程执行任务 addWorker(非核心工作者线程)......

ScheduledThreadPoolExecutor执行延时、定期任务，核心代码就在runWorker,循环获取任务队列中的任务然后执行，在获取任务的时候如果任务的执行时间没到，则进行等待。延时时间的计算都是基于System.nanoTime(),即JVM时间。

优缺点：

1.Timer单线程，执行周期任务时，一次出错，则TimerThread线程终止, 所有任务将无法执行。而且任务的执行时间可能会影响周期的准确性。

2.Timer基于系统时间，系统时间的修改会影响任务的执行。在以系统时间为准的场景中(public void schedule(TimerTask task, Date time))使用非常合适，使用周期性任务则受到极大影响，因为时间间隔被破坏！

3.ScheduledThreadPoolExecutor多线程，任务的执行不会相互影响，且能保证执行时间间隔的准确性。

4.ScheduledThreadPoolExecutor基于JVM时间，该时间本身无任何意义，仅用来计算时间间隔，不受系统时间影响。所以用来计算周期间隔特别合适，而且单位是纳秒更加精确。因此延时任务、周期任务采用它比Timer更加靠谱！

总结：

Timer的使用场景，仅在基于系统时间为准的场景中非常合适（依赖当前系统时间进行判断任务的执行）。

ScheduledThreadPoolExecutor的使用场景则更为广泛，对延时任务、周期任务使用此类更靠谱（依赖时间间隔(JVM时间差值计算得到)进行判断任务的执行）。基于系统时间执行的任务则无法精确（因为系统时间可以随时调整）！