摘要：創建一個線程池，具有固定線程數，運行在共享的無界隊列中。固定線程數源碼如下是的實現類。線程池中允許最大的線程數。如果線程數超過了核心線程數，過量的線程在關閉前等待新任務的最大時間。處理因為線程邊界和隊列容量導致的堵塞。

1.Executors.newFixedThreadPool(int nThreads)：創建一個線程池，具有固定線程數，運行在共享的無界隊列中。在大多數時候，線程會主動執行任務，當所有的線程都在執行任務時，有新的任務加入進來，就會進入等待隊列(可以有源源不斷的任務加入進來，因為是無界隊列)，當有空閑的線程，等待隊列中的任務就會被執行。如果有線程在執行過程中因為執行失敗要關閉，新創建的線程會替失敗的線程執行接下來的任務。如果想要關閉這個線程池，可以調用ExecutorService的shutDown方法。

nThreads 固定線程數

源碼如下：

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

2.ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue workQueue):是ExecutorService的實現類。

corePoolSize 核心線程數，即使是空閑的時候，線程池中也會保留線程的數量。如果設置allowCoreThreadTimeOut為true，會使用keepAliveTime作為等待工作時間，默認為false。

maximumPoolSize 線程池中允許最大的線程數。

keepAliveTime 如果線程數超過了核心線程數，過量的線程在關閉前等待新任務的最大時間。

unit keepAliveTime 參數的時間單元。

workQueue 用來存放等待執行的任務，這些任務是通過execute方法提交的Runnable任務。

源碼如下：

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

3.ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

threadFactory 用來創建新線程的工廠。

handler 處理因為線程邊界和隊列容量導致的堵塞。

源碼如下：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue 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;
}

4.LinkedBlockingQueue:Executors.newFixedThreadPool()使用基于鏈表結點的無界隊列LinkedBlockingQueue存儲待執行的任務。繼承了AbstractQueue類，實現了BlockingQueue接口，采用先進先出的排列方式，頭結點是入隊時間最長的元素，尾結點是入隊時間最短的元素。新結點添加到隊尾，從隊頭彈出結點。鏈表隊列的特點是：跟基于數組的隊列相比有更大的吞吐量，但在大多并發應用中性能會比較差。LinkedBlockingQueue可以在創建的時候傳遞一個容量參數，限制隊列的長度，不設定的情況下，默認是Integer.MAX_VALUE。在沒有超過隊列邊界的情況下，每次添加會自動創建鏈表結點。

源碼如下：

 public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node(null);
}

5.DefaultThreadFactory:返回默認的線程工廠創建新線程。執行器Executor在同一個線程組中創建所有新的線程。如果存在SecurityManager，就使用SecurityManager的線程組，否則使用當前線程的線程組。每一個新創建的線程作為非守護線程，其優先級設置為Thread.NORM_PRIORITY和線程組允許的最大優先級的較小者。可以通過Thread.getName()獲取線程的名稱，形式如：pool-N-thread-M，N表示線程工廠的序列號，M表示線程工廠創建的線程的序列號。

源碼如下：

public static ThreadFactory defaultThreadFactory() {
    return new DefaultThreadFactory();
}

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    ......
}

6.AbortPolicy：默認的拒絕執行處理器。拋出一個RejectedExecutionException。

源碼如下：

private static final RejectedExecutionHandler defaultHandler =
    new AbortPolicy();

 public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

7.例子

@Test
public void testFixedDemo01() {
    ExecutorService executorService = Executors.newFixedThreadPool(4);
    for(int i = 0;i < 10;i++) {
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " "  +" 走啦");
            }
        });
    }
}

運行結果：

核心線程數和最大線程數都是4，創建了一個線程工廠。