手把手教小白创建线程池，并讲解ThreadPoolExecutor和Executors

public class ThreadPoolExecutor extends AbstractExecutorService {……}

public class ThreadPoolExecutor extends AbstractExecutorService {
   // 线程池的控制状态（用来表示线程池的运行状态（整形的高3位）和运行的worker数量（低29位））
   private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
   // 29位的偏移量
   private static final int COUNT_BITS = Integer.SIZE - 3;
   // 最大容量（2^29 - 1）
   private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
   // runState is stored in the high-order bits
   // 线程运行状态，总共有5个状态，需要3位来表示（所以偏移量的29 = 32 - 3）
   private static final int RUNNING    = -1 << COUNT_BITS;
   private static final int SHUTDOWN   =  0 << COUNT_BITS;
   private static final int STOP       =  1 << COUNT_BITS;
   private static final int TIDYING    =  2 << COUNT_BITS;
   private static final int TERMINATED =  3 << COUNT_BITS;
   // 阻塞队列
   private final BlockingQueue<Runnable> workQueue;
   // 可重入锁
   private final ReentrantLock mainLock = new ReentrantLock();
   // 存放工作线程集合
   private final HashSet<Worker> workers = new HashSet<Worker>();
   // 终止条件
   private final Condition termination = mainLock.newCondition();
   // 最大线程池容量
   private int largestPoolSize;
   // 已完成任务数量
   private long completedTaskCount;
   // 线程工厂
   private volatile ThreadFactory threadFactory;
   // 拒绝执行处理器
   private volatile RejectedExecutionHandler handler;
   // 线程等待运行时间
   private volatile long keepAliveTime;
   // 是否运行核心线程超时
   private volatile boolean allowCoreThreadTimeOut;
   // 核心池的大小
   private volatile int corePoolSize;
   // 最大线程池大小
   private volatile int maximumPoolSize;
   // 默认拒绝执行处理器
   private static final RejectedExecutionHandler defaultHandler =
       new AbortPolicy();
   //
   private static final RuntimePermission shutdownPerm =
       new RuntimePermission("modifyThread");
}

/**
   * RUNNING    :    接受新任务并且处理已经进入阻塞队列的任务
   * SHUTDOWN    ：    不接受新任务，但是处理已经进入阻塞队列的任务
   * STOP        :    不接受新任务，不处理已经进入阻塞队列的任务并且中断正在运行的任务
   * TIDYING    :    所有的任务都已经终止，workerCount为0， 线程转化为TIDYING状态并且调用terminated钩子函数
   * TERMINATED:    terminated钩子函数已经运行完成
   **/
   private static final int RUNNING    = -1 << COUNT_BITS;
   private static final int SHUTDOWN   =  0 << COUNT_BITS;
   private static final int STOP       =  1 << COUNT_BITS;
   private static final int TIDYING    =  2 << COUNT_BITS;
   private static final int TERMINATED =  3 << COUNT_BITS;

解释：该构造函数用给定的初始参数和默认的线程工厂及被拒绝的执行处理程序创建新的 ThreadPoolExecutor。
public ThreadPoolExecutor(int corePoolSize,
                         int maximumPoolSize,
                         long keepAliveTime,
                         TimeUnit unit,
                         BlockingQueue<Runnable> workQueue) {
   this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
        Executors.defaultThreadFactory(), defaultHandler);}

解释：该构造函数用给定的初始参数和默认被拒绝的执行处理程序创建新的 ThreadPoolExecutorpublic ThreadPoolExecutor(int corePoolSize,
                         int maximumPoolSize,
                         long keepAliveTime,
                         TimeUnit unit,
                         BlockingQueue<Runnable> workQueue,
                         ThreadFactory threadFactory) {
   this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
        threadFactory, defaultHandler);}

 解释：该构造函数用给定的初始参数和默认的线程工厂创建新的 ThreadPoolExecutorpublic ThreadPoolExecutor(int corePoolSize,
                         int maximumPoolSize,
                         long keepAliveTime,
                         TimeUnit unit,
                         BlockingQueue<Runnable> workQueue,
                         RejectedExecutionHandler handler) {
   this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
        Executors.defaultThreadFactory(), handler);}

解释：该构造函数用给定的初始参数创建新的 ThreadPoolExecutor，其他的构造函数都会调用到此构造函数。public ThreadPoolExecutor(int corePoolSize,
                         int maximumPoolSize,
                         long keepAliveTime,
                         TimeUnit unit,
                         BlockingQueue<Runnable> workQueue,
                         ThreadFactory threadFactory,
                         RejectedExecutionHandler handler) {
   if (corePoolSize < 0 ||
       maximumPoolSize <= 0 ||
       maximumPoolSize < corePoolSize ||
       keepAliveTime < 0)
       throw new IllegalArgumentException();
   if (workQueue == null || threadFactory == null || handler == null)
       throw new NullPointerException();
   this.acc = System.getSecurityManager() == null ?
           null :
           AccessController.getContext();
   this.corePoolSize = corePoolSize;
   this.maximumPoolSize = maximumPoolSize;
   this.workQueue = workQueue;
   this.keepAliveTime = unit.toNanos(keepAliveTime);
   this.threadFactory = threadFactory;
   this.handler = handler;}

private final class Worker
   extends AbstractQueuedSynchronizer
   implements Runnable {省略……}

private final class Worker
       extends AbstractQueuedSynchronizer
       implements Runnable
   {
       /**
        * This class will never be serialized, but we provide a
        * serialVersionUID to suppress a javac warning.
        */
       // 版本号
       private static final long serialVersionUID = 6138294804551838833L;
       /** Thread this worker is running in.  Null if factory fails. */
       // worker 所对应的线程
       final Thread thread;
       /** Initial task to run.  Possibly null. */
       // worker所对应的第一个任务
       Runnable firstTask;
       /** Per-thread task counter */
       // 已完成任务数量
       volatile long completedTasks;……省略代码    }

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