一文搞懂Executor执行器和线程池的关系，整体介绍其任务执行/调度体系：ThreadPoolExecutor、ScheduledExecutorService（下）

ThreadPoolExecutor：
    public void execute(Runnable command) {
        if (command == null) throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        } else if (!addWorker(command, false))
            reject(command);
    }

public interface ScheduledExecutorService extends ExecutorService {
  // ========这个两个方法提交的任务只会执行一次========
  // 创建并执行启用的一次性操作在给定的延迟之后。
    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);
    // 创建并执行启用的一次性操作在给定的延迟之后。
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);
  // ========这个两个方法提交的任务会周期性的执行多次========
  // 在给定的初始延迟之后，以给定的时间间隔执行周期性动作。
  // 即在 initialDelay 初始延迟后initialDelay + period 执行第一次
  // initialDelay + 2 * period  执行第二次，依次类推
  // 特点：下一次任务的执行并不管你上次任务是否执行完毕
  // 所以它名叫FixedRate：固定的频率执行（每次都是独立事件）
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
  // 给定的初始延迟之后首先启用的定期动作
  // 随后**上一个执行的终止**和**下一个执行的开始之间**给定的延迟。
  // 也就是说delay表示的是上一次的end和下一次start之间的时间，两次之间是有关系的，不同于上个方法
  // 所以它名叫FixedDelay：两次执行间固定的延迟
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);
}

public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService { ... }

Executors：
  // 默认线程工厂：
  // 线程名称为：pool-[poolNum]-thread-[threadNumber]
  // 非守护线程（请注意：非守护线程，看看是否符合你的要求）
    public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
    }
  // 很方便的把一个Runnable适配为一个Callable<T>
  // result可以是个常量值。当然也可以是null
    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
    public static Callable<Object> callable(Runnable task) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<Object>(task, null);
    }