通過Executors線程池創建的四種方法分別為：

newCachedThreadPool：創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。

newFixedThreadPool：創建一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。

newScheduledThreadPool：創建一個定長線程池，支持定時及周期性任務執行。

newSingleThreadExecutor：創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

1. public class ThreadPoolExecutor extends AbstractExecutorService{//第一個構造方法public ThreadPoolExecutor(int corePoolSize, 
2.                               int maximumPoolSize, 
3.                               long keepAliveTime, 
4.                               TimeUnit unit, 
5.                               BlockingQueue<Runnable> workQueue) { 
6.         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, 
7.              Executors.defaultThreadFactory(), defaultHandler); 
8.     }//第二個構造方法public ThreadPoolExecutor(int corePoolSize, 
9.                               int maximumPoolSize, 
10.                               long keepAliveTime, 
11.                               TimeUnit unit, 
12.                               BlockingQueue<Runnable> workQueue, 
13.                               ThreadFactory threadFactory) { 
14.         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, 
15.              threadFactory, defaultHandler); 
16.     }//第三個構造方法public ThreadPoolExecutor(int corePoolSize, 
17.                               int maximumPoolSize, 
18.                               long keepAliveTime, 
19.                               TimeUnit unit, 
20.                               BlockingQueue<Runnable> workQueue, 
21.                               RejectedExecutionHandler handler) { 
22.         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, 
23.              Executors.defaultThreadFactory(), handler); 
24.     }//第四個也是真正的初始化構造函數public ThreadPoolExecutor(int corePoolSize, 
25.                               int maximumPoolSize, 
26.                               long keepAliveTime, 
27.                               TimeUnit unit, 
28.                               BlockingQueue<Runnable> workQueue, 
29.                               ThreadFactory threadFactory, 
30.                               RejectedExecutionHandler handler) { 
31.         if (corePoolSize < 0 || 
32.             maximumPoolSize <= 0 || 
33.             maximumPoolSize < corePoolSize || 
34.             keepAliveTime < 0) 
35.             throw new IllegalArgumentException(); 
36.         if (workQueue == null || threadFactory == null || handler == null) 
37.             throw new NullPointerException(); 
38.         this.corePoolSize = corePoolSize; 
39.         this.maximumPoolSize = maximumPoolSize; 
40.         this.workQueue = workQueue; 
41.         this.keepAliveTime = unit.toNanos(keepAliveTime); 
42.         this.threadFactory = threadFactory; 
43.         this.handler = handler; 
44.     }} 

其它答案

牛仔很忙2020-06-22 18:56:36

newCachedThreadPool創建可緩存線程池、newFixedThreadPool創建定長線程池、newScheduledThreadPool創建定長線程池、newSingleThreadExecutor創建單線程化線程池