概覽

通過上一篇對ThreadPoolExecutor的構造方法分析可以感受到，通過ThreadPoolExecutor來建立執行緒池是比較複雜的，引數比較多，考慮因素也多。

因此java自己提供了一個工廠類Executors，裡面提供了一些方法，用來建立常用的幾種ThreadPoolExecutor執行緒池。

下面是方法概覽：

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


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

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

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

分析

FixedThreadPool

FixedThreadPool呼叫的是ThreadPoolExecutor的構造方法。有下面兩種使用方式：

//不帶工廠的
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
//帶工廠的
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

通過對ThreadPoolExecutor構造引數的分析可以看出來，這個執行緒池的最大執行緒數就是核心執行緒數，也就是沒有非核心執行緒的存在。這些執行緒都是核心執行緒，即使在閒置狀態也不會被回收，除非執行緒池關閉了，所以超時機制並沒有用。他的任務佇列是無界的LinkedBlockingQueue，因此超過核心執行緒數量的任務會放在佇列中排隊。

這樣的執行緒池優點很明顯，只會建立固定數量的執行緒，然後這些執行緒一直存活重用，不會有額外的建立和銷燬執行緒的開銷，能更快的執行任務。

測試

ExecutorService executor = Executors.newFixedThreadPool(2);
Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " run time: "+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
};
for (int i = 0; i < 6; i++) {
    executor.execute(myRunnable);
}

建立一個固定大小為2的FixedThreadPool，然後新增6個任務，輸出是：

pool-1-thread-2 run time: 1493863106021
pool-1-thread-1 run time: 1493863106021
pool-1-thread-2 run time: 1493863108022
pool-1-thread-1 run time: 1493863108022
pool-1-thread-1 run time: 1493863110026
pool-1-thread-2 run time: 1493863110027

可以看到這個執行緒池只會建立2個執行緒，其他的都在排隊。

執行緒工廠

public static void main(String[] args) throws InterruptedException {
     ExecutorService executor = Executors.newFixedThreadPool(2,new MyFactory());
     Runnable myRunnable = new Runnable() {
         @Override
         public void run() {
             try {
                 Thread.sleep(2000);
                 System.out.println(Thread.currentThread().getName() + " run time: "+System.currentTimeMillis());
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }

         }
     };
     for (int i = 0; i < 6; i++) {
         executor.execute(myRunnable);
     }
 }

static class MyFactory implements ThreadFactory{

     @Override
     public Thread newThread(@NonNull Runnable r) {
         Thread thread = new Thread(r);
         thread.setName("哈哈"+ UUID.randomUUID().toString().substring(0,3));
         return thread;
     }
 }

建立一個工廠，自定義設定執行緒名字，然後在newFixedThreadPool時傳入工廠，看輸出

哈哈fea run time: 1493863498244
哈哈491 run time: 1493863498244
哈哈fea run time: 1493863500250
哈哈491 run time: 1493863500250
哈哈fea run time: 1493863502253
哈哈491 run time: 1493863502253

下面的工廠引數都是這樣，就不在寫了。

CachedThreadPool

CachedThreadPool也是用的ThreadPoolExecutor的構造方法

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

public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1, threadFactory));
}

分析這個引數可以看出，這個執行緒池沒有核心執行緒，所有的執行緒都會在限制60秒後被回收。而且最大執行緒數為Integer.MAX_VALUE，相當於無限大。因為任務佇列是SynchronousQueue，不會儲存任何任務，所以當有新任務時，如果當前執行緒都在活動著，就會新建一個執行緒來執行任務。

這樣的執行緒池的特點就是，適合執行大量的耗時短的任務。而且當所有任務執行完後，閒置超過60秒就會全部回收，這是執行緒池裡就沒有任何執行緒，不會佔用系統資源。

測試

ExecutorService executor = Executors.newCachedThreadPool();
        Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " run time: "+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};
for (int i = 0; i < 3; i++) {
    executor.execute(myRunnable);
}
Thread.sleep(30000);
System.out.println("睡眠30秒後");
for (int i = 0; i < 3; i++) {
    executor.execute(myRunnable);
}
Thread.sleep(65000);
System.out.println("再睡眠65秒後");
for (int i = 0; i < 3; i++) {
    executor.execute(myRunnable);
}

先執行三個任務，30秒後再新增3個任務，再過65秒再新增3個任務。

pool-1-thread-1 run time: 1493864065635
pool-1-thread-2 run time: 1493864065635
pool-1-thread-3 run time: 1493864065639
睡眠30秒後
pool-1-thread-3 run time: 1493864095637
pool-1-thread-2 run time: 1493864095637
pool-1-thread-1 run time: 1493864095637
再睡眠65秒後
pool-1-thread-5 run time: 1493864160643
pool-1-thread-4 run time: 1493864160643
pool-1-thread-6 run time: 1493864160643

可以看到一開始建立了3個執行緒，30秒後重用了這三個執行緒。但是再過65秒後，者三個執行緒就因為超時被回收了，所以新建了三個執行緒。

SingleThreadExecutor

SingleThreadExecutor使用new FinalizableDelegatedExecutorService來建立執行緒池。但是其實通過一個委託呼叫了ThreadPoolExecutor的構造方法

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

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

從ThreadPoolExecutor的構造引數依然可以看出，這個執行緒池僅有一個核心執行緒，其他的任務都在任務佇列中排隊。

這樣的執行緒池會讓所有的任務都在同一個執行緒中執行，避免的同步問題。

測試

ExecutorService executor = Executors.newSingleThreadExecutor();
        Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " run time: "+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};
for (int i = 0; i < 3; i++) {
    executor.execute(myRunnable);
}

Thread.sleep(65000);
System.out.println("睡眠65秒後");
for (int i = 0; i < 3; i++) {
    executor.execute(myRunnable);
}

pool-1-thread-1 run time: 1493864476076
pool-1-thread-1 run time: 1493864478078
pool-1-thread-1 run time: 1493864480082
睡眠65秒後
pool-1-thread-1 run time: 1493864541080
pool-1-thread-1 run time: 1493864543083
pool-1-thread-1 run time: 1493864545087

自始至終都只有一個執行緒。而且不會被回收。

ScheduledThreadPool

ScheduledThreadPool使用new ScheduledThreadPoolExecutor來建立

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

看一下具體使用的構造引數：

public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

可以看到，這個執行緒池的核心執行緒數是固定的，但是匯流排程數是無限的，然而因為DelayedWorkQueue是個無界佇列，所以這個值沒有意義，超過核心執行緒的任務都會放在佇列中。

ScheduledThreadPoolExecutor主要是用來執行定時任務和有周期性的重複任務。

這裡就舉個不恰當的例子，不是ScheduledThreadPoolExecutor的用法

ExecutorService executor = Executors.newScheduledThreadPool(3);
        Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " run time: "+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};
for (int i = 0; i < 6; i++) {
    executor.execute(myRunnable);
}

pool-1-thread-3 run time: 1493866372444
pool-1-thread-1 run time: 1493866372444
pool-1-thread-2 run time: 1493866372444
pool-1-thread-2 run time: 1493866374450
pool-1-thread-1 run time: 1493866374450
pool-1-thread-3 run time: 1493866374450

設定的是3，就只會建立3個執行緒。