1)創(chuàng)建一個(gè)線程的線程池。
 Executors.newSingleThreadExecutor();
 //創(chuàng)建的源碼
   public static ExecutorService newSingleThreadExecutor() {
         return new FinalizableDelegatedExecutorService
             (new ThreadPoolExecutor(1, 1,
                                     0L, TimeUnit.MILLISECONDS,
                                     new LinkedBlockingQueue<Runnable>()));
     }
 2)創(chuàng)建固定大小的線程池，參數(shù)為int，是線程池核心線程和最大線程的數(shù)量
 Executors.newFixedThreadPool(2);
  //創(chuàng)建的源碼
   public static ExecutorService newFixedThreadPool(int nThreads) {
         return new ThreadPoolExecutor(nThreads, nThreads,
                                       0L, TimeUnit.MILLISECONDS,
                                       new LinkedBlockingQueue<Runnable>());
     }
 3)創(chuàng)建一個(gè)線程數(shù)不設(shè)限的線程池，
  //創(chuàng)建的源碼，核心線程是0，最大線程是Integer.MAX_VALUE
   Executors.newCachedThreadPool()；
       public static ExecutorService newCachedThreadPool() {
           return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                         60L, TimeUnit.SECONDS,
                                         new SynchronousQueue<Runnable>());
   }

使用方法：
  private static ExecutorService sSingleThreadExecutor = null; // lazy, guarded by class
     public static ExecutorService singleThreadExecutor() {
        //當(dāng)前的類對(duì)象為鎖
         synchronized (ThreadPool.class) {
             if (sSingleThreadExecutor == null) {
                 sSingleThreadExecutor = Executors.newSingleThreadExecutor();
             }
             return sSingleThreadExecutor;
         }
   }

 ExecutorService executorService;
 public synchronized ExecutorService executorService() {
    if (executorService == null) {
         executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
 }

 private static final Executor executor = new ThreadPoolExecutor(0 ,
       Integer.MAX_VALUE , 60L , TimeUnit.SECONDS,
       new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp ConnectionPool", true));

//call 實(shí)現(xiàn) Runnable 接口。調(diào)用execute方法即可將入線程池，執(zhí)行run方法中的代碼。
executorService().execute(call);

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
}

public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
AbortPolicy:拒絕行為直接拋出異常 RejectedExecutionException
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
DiscardPolicy:保持靜默，什么也不做。
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
DiscardOldestPolicy：丟棄任務(wù)隊(duì)里中最老的任務(wù)，嘗試將新任務(wù)加入隊(duì)列
 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
 }
CallerRunsPolicy：直接由提交任務(wù)這執(zhí)行這個(gè)任務(wù)。
 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
 }
如果在創(chuàng)建線程池的時(shí)候，不知道具體的拒絕策略。那么ThreadPoolExecutor默認(rèn)的策略是AbortPolicy。
private static final RejectedExecutionHandler defaultHandler =  new AbortPolicy();

class MyRunable implements Runnable{
        @Override
        public void run() {
        }
}
class MyCallable implements Callable{
    @Override
    public Object call() throws Exception {
        return null;
    }
}
Runnable 沒(méi)有返回值，返回的是void，不允許拋出異常。
Callable 有返回值，返回的是Object，允許拋出異常。

//運(yùn)行狀態(tài)，可以接受新任務(wù)，并且處理排隊(duì)任務(wù)。
private static final int RUNNING    = -1 << COUNT_BITS;
//關(guān)閉狀態(tài)，不再接受新任務(wù)，不過(guò)仍然會(huì)處理排隊(duì)任務(wù)。
private static final int SHUTDOWN   =  0 << COUNT_BITS;
//停止?fàn)顟B(tài)，不再接受新任務(wù)，也不處理排隊(duì)任務(wù)，同時(shí)中斷處理中的任務(wù)
private static final int STOP       =  1 << COUNT_BITS;
//整理狀態(tài)，當(dāng)前所有任務(wù)終止，workerCount計(jì)數(shù)為0，線程切換為TIDYING狀態(tài)，并且執(zhí)行terminal()方法
private static final int TIDYING    =  2 << COUNT_BITS;
//終止?fàn)顟B(tài)，說(shuō)明terminal()方法執(zhí)行完成。
private static final int TERMINATED =  3 << COUNT_BITS;

// ctlOf計(jì)算ctl的新值，也就是線程池狀態(tài)和線程池中線程數(shù)量。
private static int ctlOf(int rs, int wc) { return rs | wc; }
//獲取ctl的高三位，也就是線程池的狀態(tài)。
private static int runStateOf(int c)     { return c & ~CAPACITY; }
//獲取ctl的低29位，也就是線程池中的線程數(shù)。
private static int workerCountOf(int c)  { return c & CAPACITY; }
其中runStateOf(int c)和workerCountOf(int c)的參數(shù)c就是通過(guò)ctlOf(int rs, int wc)獲得的ctl值。

ctl 用來(lái)表示線程池的狀態(tài)和線程數(shù)量，
在ThreadPoolExcutor中使用32位二進(jìn)制數(shù)來(lái)表示線程池的狀態(tài)和線程中線程數(shù)量。
其中前3位表示線程池的狀態(tài)，后29位表示線程池中的線程數(shù)。
public void execute(Runnable command) {
         int c = ctl.get();
        //如果工作線程數(shù)量小于核心線程數(shù)，
        //提交的任務(wù)會(huì)通過(guò)addWorker(command, true)創(chuàng)建一個(gè)新的核心線程來(lái)執(zhí)行， 這個(gè)參數(shù)傳的是true，表示去新增核心線程。
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true)){
                //添加成功則return
                return;
            }
           //添加核心線程失敗則重新獲取線程池的狀態(tài)和數(shù)量
            c = ctl.get();
        }
        //進(jìn)入到下面說(shuō)明當(dāng)前工作線程大于或等于核心線程。
        //如果線程池處于運(yùn)行狀態(tài)，則加入隊(duì)列
        if (isRunning(c) && workQueue.offer(command)) {
            //如果入隊(duì)成功，則重新獲取線程池的狀態(tài)
            int recheck = ctl.get();
            //如果線程池不處于運(yùn)行狀態(tài)，則從隊(duì)列中remove
            if (!isRunning(recheck) && remove(command)){
              //成功刪除，則執(zhí)行拒絕策略
              reject(command);
            }else if (workerCountOf(recheck) == 0){
             //進(jìn)入這個(gè)分支有兩種情況1.線程池處于運(yùn)行狀態(tài) 2.線程從不處于運(yùn)行狀態(tài)，但是remove失敗
                則會(huì)判斷workerCountOf如果工作線程為0，則會(huì)創(chuàng)建非核心線程去執(zhí)行任務(wù)。
              addWorker為null，和false。false表示非核心線程。null說(shuō)明創(chuàng)建的線程去執(zhí)行隊(duì)列里的任務(wù)。
              addWorker(null, false);
            }
         //進(jìn)入到這個(gè)分支有兩種情況1.線程池處于非運(yùn)行狀態(tài)2.運(yùn)行狀態(tài)但是入隊(duì)失敗了。
         這時(shí)候創(chuàng)建非核心線程去執(zhí)行任務(wù)
        }else if (!addWorker(command, false)){
            如果創(chuàng)建非核心線程失敗了，則執(zhí)行拒絕策略。
           reject(command);
        }
}

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
 
            // 如果線程池處于非運(yùn)行狀態(tài)，則不會(huì)創(chuàng)建線程。
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty())){
                        return false;
                   }
            //如果線程池處于運(yùn)行狀態(tài)，則直接走下面的創(chuàng)建添加邏輯。
            for (;;) {
                //獲取工作線程數(shù)量
                int wc = workerCountOf(c);
                //wc >= CAPACITY 工作線程大于最大容量
                // wc >= (core ? corePoolSize : maximumPoolSize) 如果工作線程大于了核心線程或最大線程，
                //只要這兩個(gè)條件有一個(gè)成立則return。
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize)){
                    return false;
                 }
                //創(chuàng)建線程數(shù)量+1，這里用到了CAS。關(guān)于CAS后面再寫文章分析。
                if (compareAndIncrementWorkerCount(c)){
                    break retry;
                 }
                 //如果CAS操作失敗，線程數(shù)量沒(méi)有加1，則重新獲取線程的狀態(tài)。
                c = ctl.get();  // Re-read ctl
                //判斷當(dāng)前狀態(tài)和之前狀態(tài)，如果不同，說(shuō)明線程池狀態(tài)發(fā)生了變化。重新跳到retry的外層循環(huán)。
                //如果相同，則說(shuō)明線程池沒(méi)有變化，繼續(xù)進(jìn)行內(nèi)層循環(huán)。
                if (runStateOf(c) != rs){
                    continue retry;
                }
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
        //執(zhí)行到這說(shuō)明線程數(shù)量已經(jīng)完成+1，接下來(lái)進(jìn)行線程的創(chuàng)建。
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            //這個(gè)創(chuàng)建一個(gè)worker對(duì)象。在worker構(gòu)造方法中，會(huì)利用ThreadPoolExecutor中傳遞過(guò)了的ThreadFactory創(chuàng)建一個(gè)Thread
            //默認(rèn)是通過(guò)Executors.defaultThreadFactory()，創(chuàng)建一個(gè)線程。
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                //拿到一個(gè)重入鎖對(duì)象。
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    //拿到線程池的狀態(tài)
                    int rs = runStateOf(ctl.get());
                    //如果線程池處于運(yùn)行狀態(tài)或者處于關(guān)閉狀態(tài)并且firstTask == null
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) {
                            throw new IllegalThreadStateException();
                        }
                        //添加到work集合
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize){ //更新一下最大線程數(shù)
                            largestPoolSize = s;
                        }
                        //標(biāo)志位，添加成功
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    //添加成功則啟動(dòng)線程
                    t.start();
                    //啟動(dòng)成功
                    workerStarted = true;
                }
            }
        } finally {
            //如果沒(méi)有啟動(dòng)成功則從線程池中移除。
            if (! workerStarted){
                addWorkerFailed(w);
            }
        }
        return workerStarted;
    }

 Worker(Runnable firstTask) {
        setState(-1);
        //將傳進(jìn)來(lái)的任務(wù)賦值給成員變量
        this.firstTask = firstTask;
        //創(chuàng)建一個(gè)線程，并把Worker本身當(dāng)做Runnable傳進(jìn)了Thread中去。
        this.thread = getThreadFactory().newThread(this);
 }
 public interface ThreadFactory {
     Thread newThread(Runnable r);
 }

public void run() {
    runWorker(this);
}
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        //如果task不為null，則先執(zhí)行當(dāng)前任務(wù)
        //如果task傳進(jìn)來(lái)是null則從隊(duì)列中取任務(wù)，執(zhí)行隊(duì)列里的任務(wù)。
        //getTask()就是從任務(wù)隊(duì)列中提取在等待的隊(duì)伍。
        while (task != null || (task = getTask()) != null) {
            w.lock();
            //(runStateAtLeast(ctl.get(), STOP) 線程池處于STOP，TIDYING，TERMINATED狀態(tài)
             處于這些狀態(tài)的線程池是無(wú)法執(zhí)行任務(wù)的。
          if ((runStateAtLeast(ctl.get(), STOP) ||
               (Thread.interrupted() &&
                runStateAtLeast(ctl.get(), STOP))) &&
              !wt.isInterrupted()){
                 //中斷線程
                  wt.interrupt();
              }
          //執(zhí)行到下面說(shuō)明線程池處于RUNNING或SHUTDOWN狀態(tài)
          //由此也可以看出SHUTDOWN狀態(tài)的線程池，是可以執(zhí)行隊(duì)列里的任務(wù)的，但是隊(duì)列不在接收新的任務(wù)添加
            try {
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    //執(zhí)行任務(wù)的
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

  private Runnable getTask() {
   boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
      try {
            //從任務(wù)隊(duì)列中取出任務(wù)
             Runnable r = timed ?
             workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
             workQueue.take();
         if (r != null)
             return r;
         timedOut = true;
     } catch (InterruptedException retry) {
         timedOut = false;
     }
  }