public ScheduledThreadPoolExecutor(int corePoolSize) {
 // 對于其他幾個參數(shù)在ThreadPoolExecutor中都已經詳細分析過了，所以這里,將不再展開
 // 這里我們可以看到調用基類中的方法時有個特殊的入參DelayedWorkQueue。
 // 同時我們也可以發(fā)現(xiàn)這里并沒有設置延遲時間、周期等參數(shù)入口。
 // 所以定時執(zhí)行的實現(xiàn)必然在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，這是關鍵點，獲取執(zhí)行延時時間
    // 但是如果我們有延時設置的話，這就返回空了，然后就會調用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 {
       // 使用鎖，執(zhí)行延時等待。
       // 使用鎖，執(zhí)行延時等待。
       // 使用鎖，執(zhí)行延時等待。
        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);
  }

// 判斷是否需要按周期執(zhí)行，如果周期設置成0，不是無間隔執(zhí)行，而是只執(zhí)行一次，這個需要特別注意
 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)
   // 如果不是周期性的，就執(zhí)行調用父類的run方法，也就是構造函數(shù)中傳入的Runnable對象的run方法。
    ScheduledFutureTask.super.run();
    // 在if的括號中先執(zhí)行了任務
   else if (ScheduledFutureTask.super.runAndReset()) {
   // 如果是周期性的，就需要設置下次執(zhí)行的時間，然后利用reExecutePeriodic方法，將任務再次丟入任務隊列中。
   // 這里尤其需要注意的是if中的邏輯執(zhí)行失敗，如果沒有捕捉異常，那么后面的邏輯就不會再執(zhí)行了，也就是說中間有一次執(zhí)行失敗，后面這個周期性的任務就失效了。
    setNextRunTime();
    reExecutePeriodic(outerTask);
   }
  }