public ThreadPoolExecutor(int corePoolSize, /// 核心线程数
                          int maximumPoolSize, /// 最大线程数
                          long keepAliveTime, /// 非核心线程空闲后的存活时间的数量值
                          TimeUnit unit, /// 非核心线程空闲后的存活时间的单位
                          BlockingQueue<Runnable> workQueue, /// 工作队列（阻塞队列）
                          ThreadFactory threadFactory, /// 线程工厂，主要负责创建线程
                          RejectedExecutionHandler handler) { /// 拒绝策略
}

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { /// 1、核心线程是否已经满
            if (addWorker(command, true))/// 2、添加worker，以核心线程消费任务(第二个参数为true)
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {/// 3、添加到工作队列是否可行
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))/// 4、添加worker，以非核心线程消费任务(第二个参数为false)
            reject(command);/// 5、如果添加失败，说明非核心线程是否已经满，执行拒绝策略
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public LinkedBlockingQueue() {
       this(Integer.MAX_VALUE);// 队列元素最大数量为Integer.MAX_VALUE
   }

public static ExecutorService newSingleThreadExecutor() {
       return new FinalizableDelegatedExecutorService
           (new ThreadPoolExecutor(1, 1,
                                   0L, TimeUnit.MILLISECONDS,
                                   new LinkedBlockingQueue<Runnable>()));
   }

static class FinalizableDelegatedExecutorService extends DelegatedExecutorService {
      FinalizableDelegatedExecutorService(ExecutorService executor) {
          super(executor);
      }
      protected void finalize() {
          super.shutdown();
      }
  }

static class DelegatedExecutorService extends AbstractExecutorService {
    private final ExecutorService e;/// 我才是干活的线程池
    DelegatedExecutorService(ExecutorService executor) { e = executor; }
    public void execute(Runnable command) { e.execute(command); }
    // ...
    }