java 定时器线程池（ScheduledThreadPoolExecutor）的实现

 public ScheduledThreadPoolExecutor(int corePoolSize) {
 // 对于其他几个参数在ThreadPoolExecutor中都已经详细分析过了，所以这里,将不再展开
 // 这里我们可以看到调用基类中的方法时有个特殊的入参DelayedWorkQueue。
 // 同时我们也可以发现这里并没有设置延迟时间、周期等参数入口。
 // 所以定时执行的实现必然在DelayedWorkQueue这个对象中了。
  super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
    new DelayedWorkQueue());
 }

private RunnableScheduledFuture<?>[] queue =
   new RunnableScheduledFuture<?>[INITIAL_CAPACITY];

public RunnableScheduledFuture<?> poll() {
   final ReentrantLock lock = this.lock;
   lock.lock();
   try {
    RunnableScheduledFuture<?> first = queue[0];
    // 这里有个getDelay，这是关键点，获取执行延时时间
    // 但是如果我们有延时设置的话，这就返回空了，然后就会调用take方法
    if (first == null || first.getDelay(NANOSECONDS) > 0)
     return null;
    else
     return finishPoll(first);
   } finally {
    lock.unlock();
   }
  }

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

// 判断是否需要按周期执行，如果周期设置成0，不是无间隔执行，而是只执行一次，这个需要特别注意
 public boolean isPeriodic() {
   return period != 0;
  }

 private void setNextRunTime() {
   long p = period;
   if (p > 0)
   // 这里将周期加给time，这样获取的延迟时间就是周期时间了。
    time += p;
   else
    time = triggerTime(-p);
  }

 public void run() {
   // 先判断是否为周期性的任务
   boolean periodic = isPeriodic();
   if (!canRunInCurrentRunState(periodic))
    cancel(false);
   else if (!periodic)
   // 如果不是周期性的，就执行调用父类的run方法，也就是构造函数中传入的Runnable对象的run方法。
    ScheduledFutureTask.super.run();
    // 在if的括号中先执行了任务
   else if (ScheduledFutureTask.super.runAndReset()) {
   // 如果是周期性的，就需要设置下次执行的时间，然后利用reExecutePeriodic方法，将任务再次丢入任务队列中。
   // 这里尤其需要注意的是if中的逻辑执行失败，如果没有捕捉异常，那么后面的逻辑就不会再执行了，也就是说中间有一次执行失败，后面这个周期性的任务就失效了。
    setNextRunTime();
    reExecutePeriodic(outerTask);
   }
  }