第Java線程池Executor怎么使用使用Executors創建線程池

使用Executors可以創建四種線程池：分別對應上邊提到的四種線程池初始化方法

Executors.newCachedThreadPool

newCachedThreadPool是一個根據需要創建新線程的線程池，當一個任務提交時，corePoolSize為0不創建核心線程，SynchronousQueue是一個不存儲元素的隊列，可以理解為隊里永遠是滿的，因此最終會創建非核心線程來執行任務。對于非核心線程空閑60s時將被回收。因為Integer.MAX_VALUE非常大，可以認為是可以無限創建線程的，在資源有限的情況下容易引起OOM異常。

//創建newCachedThreadPool線程池源碼

publicstaticExecutorServicenewCachedThreadPool(){

*corePoolSize：0，核心線程池的數量為0

*maximumPoolSize：Integer.MAX_VALUE，可以認為最大線程數是無限的

*keepAliveTime：60L

*unit:秒

*workQueue:SynchronousQueue

returnnewThreadPoolExecutor(0,Integer.MAX_VALUE,

60L,TimeUnit.SECONDS,

newSynchronousQueueRunnable

}

使用案例：

publicstaticvoidmAIn(String[]args){

ExecutorServiceexecutor=Executors.newCachedThreadPool();

for(inti=0;ii++){

finalintindex=i;

executor.execute(newRunnable(){

@Override

publicvoidrun(){

(task:{},index);

}

值得注意的一點是，newCachedThreadPool的返回值是ExecutorService類型，該類型只包含基礎的線程池方法，但卻不包含線程監控相關方法，因此在使用返回值為ExecutorService的線程池類型創建新線程時要考慮到具體情況。

Executors.newSingleThreadExecutor

newSingleThreadExecutor是單線程線程池，只有一個核心線程，用唯一的一個共用線程執行任務，保證所有任務按指定順序執行（FIFO、優先級hellip;）

//newSingleThreadExecutor創建線程池源碼

publicstaticExecutorServicenewSingleThreadExecutor(){

*corePoolSize:1，核心線程池的數量為1

*maximumPoolSize:1，只可以創建一個非核心線程

*keepAliveTime:0L

*unit=秒

*workQueue=LinkedBlockingQueue

returnnewFinalizableDelegatedExecutorService

(newThreadPoolExecutor(1,1,

0L,TimeUnit.MILLISECONDS,

newLinkedBlockingQueueRunnable()));

}

當一個任務提交時，首先會創建一個核心線程來執行任務，如果超過核心線程的數量，將會放入隊列中，因為LinkedBlockingQueue是長度為Integer.MAX_VALUE的隊列，可以認為是無界隊列，因此往隊列中可以插入無限多的任務，在資源有限的時候容易引起OOM異常，同時因為無界隊列，maximumPoolSize和keepAliveTime參數將無效，壓根就不會創建非核心線程。

Executors.newFixedThreadPool

定長線程池，核心線程數和最大線程數由用戶傳入，可以設置線程的最大并發數，超出在隊列等待

//newFixedThreadPool創建線程池源碼

publicstaticExecutorServicenewFixedThreadPool(intnThreads){

*corePoolSize:核心線程的數量為自定義輸入nThreads

*maximumPoolSize：最大線程的數量為自定義輸入nThreads

*keepAliveTime：0L

*unit：秒

*workQueue：LinkedBlockingQueue

returnnewThreadPoolExecutor(nThreads,nThreads,

0L,TimeUnit.MILLISECONDS,

newLinkedBlockingQueueRunnable

}

newFixedThreadPool和SingleThreadExecutor類似，唯一的區別就是核心線程數不同，并且由于使用的是LinkedBlockingQueue，在資源有限的時候容易引起OOM異常。

Executors.newScheduledThreadPool

定長線程池，核心線程數由用戶傳入，支持定時和周期任務執行

//newScheduledThreadPool創建線程池源碼

publicstaticScheduledExecutorServicenewScheduledThreadPool(intcorePoolSize){

returnnewScheduledThreadPoolExecutor(corePoolSize);

publicScheduledThreadPoolExecutor(intcorePoolSize){

*corePoolSize:核心線程的數量為自定義輸入corePoolSize

*maximumPoolSize：最大線程的數量為Integer.MAX_VALUE

*keepAliveTime：0L

*unit：納秒

*workQueue：DelayedWorkQueue

super(corePoolSize,Integer.MAX_VALUE,0,NANOSECONDS,

newDelayedWorkQueue());

}

當一個任務提交時，corePoolSize為自定義輸入，首先創建核心線程，核心線程滿了之后，因此最終會創建非核心線程來執行任務。非核心線程使用后將被回收。因為Integer.MAX_VALUE非常大，可以認為是可以無限創建線程的，在資源有限的情況下容易引起OOM異常。因為使用的DelayedWorkQueue可以實現定時和周期任務。ScheduledExecutorService提供了三種方法可以使用：

schedule：延遲后執行任務scheduleAtFixedRate：以指定的速率執行任務scheduleWithFixedDelay：以指定的延遲執行任務使用案例：

publicstaticvoidmain(String[]args){

ScheduledExecutorServiceexecutorService=Executors.newScheduledThreadPool(1);

//executorService.schedule(newRunnable(){

//@Override

//publicvoidrun(){

//log.warn(schedulerun

////延遲3秒后執行

//},3,TimeUnit.SECONDS);

//executorService.shutdown();

//executorService.scheduleWithFixedDelay(newRunnable(){

//@Override

//publicvoidrun(){

//log.warn(scheduleWithFixedDelayrun

////延遲一秒后每隔3秒執行

//},1,3,TimeUnit.SECONDS);

executorService.scheduleAtFixedRate(newRunnable(){

@Override

publicvoidrun(){

log.warn(schedulerun

//延遲一秒后每隔3秒執行

},1,3,TimeUnit.SECONDS);

*定時器調度，不推薦使用，