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 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）,如果执行时间小于等于当前系统时间则执行任务，否则继续等待（执行时间-当前时间）。
ScheduledThreadPoolExecutor
基于多线程、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时间差值计算得到)进行判断任务的执行）。基于系统时间执行的任务则无法精确（因为系统时间可以随时调整）！
