JDK scheduler

Java JDK实现调度方式有Timer和ScheduledThreadPoolExecutor (不考虑Quartz以及Spring Scheduler等)

Timer

基本类Timer/TimerTask，JDK Timer两个缺点

• 只有一个线程执行所有TimerTask，如果有一个TimerTask比较耗时，其他TimerTask执行时间就不准了
• TimerTask中间抛出异常会终止Timer，其他任务也不能调度了

ScheduledExecutorService / ScheduledThreadPoolExecutor

Executors.newScheduledThreadPool能解决Timer上面两个问题。从实现看，它基于优先级队列实现。

/**
 * Creates a new {@code ScheduledThreadPoolExecutor} with the
 * given core pool size.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @throws IllegalArgumentException if {@code corePoolSize < 0}
 */
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

FixedRate & FixedDealy

• 调度中的FixedRate指的是任务以固定时间频率执行（本次任务开始执行时间和下次任务开始执行时间是固定的）
• 调度中的FixedDelay指的是任务结束后以固定间隔执行下一个任务（本次任务执行完成后和下次任务开始执行间隔是固定的，下次任务执行时间不固定，取决于上次任务结束时间）
• Executors.newScheduledThreadPool FixedRate方式执行时，如果前一个任务执行时间太长，后一个任务顺延，不会并发执行。参考下面源码。
• Timer的scheduleAtFixedRate如果任务执行时间>时间间隔，会并发执行

/**
   * Creates and executes a periodic action that becomes enabled first
   * after the given initial delay, and subsequently with the given
   * period; that is executions will commence after
   * {@code initialDelay} then {@code initialDelay+period}, then
   * {@code initialDelay + 2 * period}, and so on.
   * If any execution of the task
   * encounters an exception, subsequent executions are suppressed.
   * Otherwise, the task will only terminate via cancellation or
   * termination of the executor.  If any execution of this task
   * takes longer than its period, then subsequent executions
   * may start late, but will not concurrently execute.
   *
   * @param command the task to execute
   * @param initialDelay the time to delay first execution
   * @param period the period between successive executions
   * @param unit the time unit of the initialDelay and period parameters
   * @return a ScheduledFuture representing pending completion of
   *         the task, and whose {@code get()} method will throw an
   *         exception upon cancellation
   * @throws RejectedExecutionException if the task cannot be
   *         scheduled for execution
   * @throws NullPointerException if command is null
   * @throws IllegalArgumentException if period less than or equal to zero
   */
  public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                long initialDelay,
                                                long period,
                                                TimeUnit unit);

/**
    * Schedules the specified task for repeated <i>fixed-rate execution</i>,
    * beginning after the specified delay.  Subsequent executions take place
    * at approximately regular intervals, separated by the specified period.
    *
    * <p>In fixed-rate execution, each execution is scheduled relative to the
    * scheduled execution time of the initial execution.  If an execution is
    * delayed for any reason (such as garbage collection or other background
    * activity), two or more executions will occur in rapid succession to
    * "catch up."  In the long run, the frequency of execution will be
    * exactly the reciprocal of the specified period (assuming the system
    * clock underlying <tt>Object.wait(long)</tt> is accurate).
    *
    * <p>Fixed-rate execution is appropriate for recurring activities that
    * are sensitive to <i>absolute</i> time, such as ringing a chime every
    * hour on the hour, or running scheduled maintenance every day at a
    * particular time.  It is also appropriate for recurring activities
    * where the total time to perform a fixed number of executions is
    * important, such as a countdown timer that ticks once every second for
    * ten seconds.  Finally, fixed-rate execution is appropriate for
    * scheduling multiple repeating timer tasks that must remain synchronized
    * with respect to one another.
    *
    * @param task   task to be scheduled.
    * @param delay  delay in milliseconds before task is to be executed.
    * @param period time in milliseconds between successive task executions.
    * @throws IllegalArgumentException if {@code delay < 0}, or
    *         {@code delay + System.currentTimeMillis() < 0}, or
    *         {@code period <= 0}
    * @throws IllegalStateException if task was already scheduled or
    *         cancelled, timer was cancelled, or timer thread terminated.
    * @throws NullPointerException if {@code task} is null
    */
   public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
       if (delay < 0)
           throw new IllegalArgumentException("Negative delay.");
       if (period <= 0)
           throw new IllegalArgumentException("Non-positive period.");
       sched(task, System.currentTimeMillis()+delay, period);
   }