細(xì)數(shù)線程池的10個(gè)坑

前言

日常開(kāi)發(fā)中，為了更好管理線程資源，減少創(chuàng)建線程和銷(xiāo)毀線程的資源損耗，我們會(huì)使用線程池來(lái)執(zhí)行一些異步任務(wù)。但是線程池使用不當(dāng)，就可能會(huì)引發(fā)生產(chǎn)事故。今天跟大家聊聊線程池的10個(gè)坑。大家看完肯定會(huì)有幫助的~

線程池默認(rèn)使用無(wú)界隊(duì)列，任務(wù)過(guò)多導(dǎo)致OOM

線程創(chuàng)建過(guò)多，導(dǎo)致OOM

共享線程池，次要邏輯拖垮主要邏輯

線程池拒絕策略的坑

Spring內(nèi)部線程池的坑

使用線程池時(shí)，沒(méi)有自定義命名

線程池參數(shù)設(shè)置不合理

線程池異常處理的坑

使用完線程池忘記關(guān)閉

ThreadLocal與線程池搭配，線程復(fù)用，導(dǎo)致信息錯(cuò)亂。

1.線程池默認(rèn)使用無(wú)界隊(duì)列，任務(wù)過(guò)多導(dǎo)致OOM

JDK開(kāi)發(fā)者提供了線程池的實(shí)現(xiàn)類(lèi)，我們基于Executors組件，就可以快速創(chuàng)建一個(gè)線程池 。日常工作中，一些小伙伴為了開(kāi)發(fā)效率，反手就用Executors新建個(gè)線程池。寫(xiě)出類(lèi)似以下的代碼：

publicclassNewFixedTest{

publicstaticvoidmain(String[]args){
ExecutorServiceexecutor=Executors.newFixedThreadPool(10);
for(inti=0;i{
try{
Thread.sleep(10000);
}catch(InterruptedExceptione){
//donothing
}
});
}
}
}

使用newFixedThreadPool創(chuàng)建的線程池，是會(huì)有坑的，它默認(rèn)是無(wú)界的阻塞隊(duì)列，如果任務(wù)過(guò)多，會(huì)導(dǎo)致OOM問(wèn)題。運(yùn)行一下以上代碼，出現(xiàn)了OOM。

Exceptioninthread"main"java.lang.OutOfMemoryError:GCoverheadlimitexceeded
atjava.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
atjava.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
atcom.example.dto.NewFixedTest.main(NewFixedTest.java:14)

這是因?yàn)閚ewFixedThreadPool使用了無(wú)界的阻塞隊(duì)列的LinkedBlockingQueue，如果線程獲取一個(gè)任務(wù)后，任務(wù)的執(zhí)行時(shí)間比較長(zhǎng)(比如，上面demo代碼設(shè)置了10秒)，會(huì)導(dǎo)致隊(duì)列的任務(wù)越積越多，導(dǎo)致機(jī)器內(nèi)存使用不停飆升， 最終出現(xiàn)OOM。

看下newFixedThreadPool的相關(guān)源碼，是可以看到一個(gè)無(wú)界的阻塞隊(duì)列的，如下：

//阻塞隊(duì)列是LinkedBlockingQueue，并且是使用的是無(wú)參構(gòu)造函數(shù)
publicstaticExecutorServicenewFixedThreadPool(intnThreads){
returnnewThreadPoolExecutor(nThreads,nThreads,
0L,TimeUnit.MILLISECONDS,
newLinkedBlockingQueue());
}

//無(wú)參構(gòu)造函數(shù)，默認(rèn)最大容量是Integer.MAX_VALUE，相當(dāng)于無(wú)界的阻塞隊(duì)列的了
publicLinkedBlockingQueue(){
this(Integer.MAX_VALUE);
}

因此，工作中，建議大家自定義線程池 ，并使用指定長(zhǎng)度的阻塞隊(duì)列 。

2. 線程池創(chuàng)建線程過(guò)多，導(dǎo)致OOM

有些小伙伴說(shuō)，既然Executors組件創(chuàng)建出的線程池newFixedThreadPool，使用的是無(wú)界隊(duì)列，可能會(huì)導(dǎo)致OOM。那么，Executors組件還可以創(chuàng)建別的線程池，如newCachedThreadPool，我們用它也不行嘛？

我們可以看下newCachedThreadPool的構(gòu)造函數(shù)：

publicstaticExecutorServicenewCachedThreadPool(){
returnnewThreadPoolExecutor(0,Integer.MAX_VALUE,
60L,TimeUnit.SECONDS,
newSynchronousQueue());
}

它的最大線程數(shù)是Integer.MAX_VALUE。大家應(yīng)該意識(shí)到使用它，可能會(huì)引發(fā)什么問(wèn)題了吧。沒(méi)錯(cuò)，如果創(chuàng)建了大量的線程也有可能引發(fā)OOM！

筆者在以前公司，遇到這么一個(gè)OOM問(wèn)題：一個(gè)第三方提供的包，是直接使用new Thread實(shí)現(xiàn)多線程的。在某個(gè)夜深人靜的夜晚，我們的監(jiān)控系統(tǒng)報(bào)警了。。。這個(gè)相關(guān)的業(yè)務(wù)請(qǐng)求瞬間特別多，監(jiān)控系統(tǒng)告警OOM了。

所以我們使用線程池的時(shí)候，還要當(dāng)心線程創(chuàng)建過(guò)多，導(dǎo)致OOM問(wèn)題。大家盡量不要使用newCachedThreadPool，并且如果自定義線程池時(shí)，要注意一下最大線程數(shù)。

3. 共享線程池，次要邏輯拖垮主要邏輯

要避免所有的業(yè)務(wù)邏輯共享一個(gè)線程池。比如你用線程池A來(lái)做登錄異步通知，又用線程池A來(lái)做對(duì)賬。如下圖：

如果對(duì)賬任務(wù)checkBillService響應(yīng)時(shí)間過(guò)慢，會(huì)占據(jù)大量的線程池資源，可能直接導(dǎo)致沒(méi)有足夠的線程資源去執(zhí)行l(wèi)oginNotifyService的任務(wù)，最后影響登錄。就這樣，因?yàn)橐粋€(gè)次要服務(wù)，影響到重要的登錄接口，顯然這是絕對(duì)不允許的。因此，我們不能將所有的業(yè)務(wù)一鍋燉，都共享一個(gè)線程池，因?yàn)檫@樣做，風(fēng)險(xiǎn)太高了，猶如所有雞蛋放到一個(gè)籃子里。應(yīng)當(dāng)做線程池隔離 ！

4. 線程池拒絕策略的坑，使用不當(dāng)導(dǎo)致阻塞

我們知道線程池主要有四種拒絕策略，如下：

AbortPolicy: 丟棄任務(wù)并拋出RejectedExecutionException異常。(默認(rèn)拒絕策略)

DiscardPolicy：丟棄任務(wù)，但是不拋出異常。

DiscardOldestPolicy：丟棄隊(duì)列最前面的任務(wù)，然后重新嘗試執(zhí)行任務(wù)。

CallerRunsPolicy：由調(diào)用方線程處理該任務(wù)。

如果線程池拒絕策略設(shè)置不合理，就容易有坑。我們把拒絕策略設(shè)置為DiscardPolicy或DiscardOldestPolicy并且在被拒絕的任務(wù)，F(xiàn)uture對(duì)象調(diào)用get()方法,那么調(diào)用線程會(huì)一直被阻塞。

我們來(lái)看個(gè)demo：

publicclassDiscardThreadPoolTest{

publicstaticvoidmain(String[]args)throwsExecutionException,InterruptedException{
//一個(gè)核心線程，隊(duì)列最大為1，最大線程數(shù)也是1.拒絕策略是DiscardPolicy
ThreadPoolExecutorexecutorService=newThreadPoolExecutor(1,1,1L,TimeUnit.MINUTES,
newArrayBlockingQueue<>(1),newThreadPoolExecutor.DiscardPolicy());

Futuref1=executorService.submit(()->{
System.out.println("提交任務(wù)1");
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
});

Futuref2=executorService.submit(()->{
System.out.println("提交任務(wù)2");
});

Futuref3=executorService.submit(()->{
System.out.println("提交任務(wù)3");
});

System.out.println("任務(wù)1完成"+f1.get());//等待任務(wù)1執(zhí)行完畢
System.out.println("任務(wù)2完成"+f2.get());//等待任務(wù)2執(zhí)行完畢
System.out.println("任務(wù)3完成"+f3.get());//等待任務(wù)3執(zhí)行完畢

executorService.shutdown();//關(guān)閉線程池，阻塞直到所有任務(wù)執(zhí)行完畢

}
}

運(yùn)行結(jié)果：一直在運(yùn)行中。。。

這是因?yàn)镈iscardPolicy拒絕策略，是什么都沒(méi)做，源碼如下：

publicstaticclassDiscardPolicyimplementsRejectedExecutionHandler{
/**
*Createsa{@codeDiscardPolicy}.
*/
publicDiscardPolicy(){}

/**
*Doesnothing,whichhastheeffectofdiscardingtaskr.
*/
publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){
}
}

我們?cè)賮?lái)看看線程池 submit 的方法：

publicFuturesubmit(Runnabletask){
if(task==null)thrownewNullPointerException();
//把Runnable任務(wù)包裝為Future對(duì)象
RunnableFutureftask=newTaskFor(task,null);
//執(zhí)行任務(wù)
execute(ftask);
//返回Future對(duì)象
returnftask;
}

publicFutureTask(Runnablerunnable,Vresult){
this.callable=Executors.callable(runnable,result);
this.state=NEW;//Future的初始化狀態(tài)是New
}

我們?cè)賮?lái)看看Future的get() 方法

//狀態(tài)大于COMPLETING，才會(huì)返回，要不然都會(huì)阻塞等待
publicVget()throwsInterruptedException,ExecutionException{
ints=state;
if(s<=?COMPLETING)
????????????s?=?awaitDone(false,?0L);
????????return?report(s);
????}
????
????FutureTask的狀態(tài)枚舉
????private?static?final?int?NEW??????????=?0;
????private?static?final?int?COMPLETING???=?1;
????private?static?final?int?NORMAL???????=?2;
????private?static?final?int?EXCEPTIONAL??=?3;
????private?static?final?int?CANCELLED????=?4;
????private?static?final?int?INTERRUPTING?=?5;
????private?static?final?int?INTERRUPTED??=?6;

阻塞的真相水落石出啦，F(xiàn)utureTask的狀態(tài)大于COMPLETING才會(huì)返回，要不然都會(huì)一直阻塞等待 。又因?yàn)榫芙^策略啥沒(méi)做，沒(méi)有修改FutureTask的狀態(tài)，因此FutureTask的狀態(tài)一直是NEW，所以它不會(huì)返回，會(huì)一直等待。

這個(gè)問(wèn)題，可以使用別的拒絕策略，比如CallerRunsPolicy，它讓主線程去執(zhí)行拒絕的任務(wù)，會(huì)更新FutureTask狀態(tài)。如果確實(shí)想用DiscardPolicy，則需要重寫(xiě)DiscardPolicy的拒絕策略。

溫馨提示 ，日常開(kāi)發(fā)中，使用 Future.get() 時(shí)，盡量使用帶超時(shí)時(shí)間的 ，因?yàn)樗亲枞摹?/p>

future.get(1,TimeUnit.SECONDS);

難道使用別的拒絕策略，就萬(wàn)無(wú)一失了嘛？ 不是的，如果使用CallerRunsPolicy拒絕策略，它表示拒絕的任務(wù)給調(diào)用方線程用，如果這是主線程，那會(huì)不會(huì)可能也導(dǎo)致主線程阻塞 呢？總結(jié)起來(lái)，大家日常開(kāi)發(fā)的時(shí)候，多一份心眼吧，多一點(diǎn)思考吧。

5. Spring內(nèi)部線程池的坑

工作中，個(gè)別開(kāi)發(fā)者，為了快速開(kāi)發(fā)，喜歡直接用spring的@Async，來(lái)執(zhí)行異步任務(wù)。

@Async
publicvoidtestAsync()throwsInterruptedException{
System.out.println("處理異步任務(wù)");
TimeUnit.SECONDS.sleep(newRandom().nextInt(100));
}

Spring內(nèi)部線程池，其實(shí)是SimpleAsyncTaskExecutor，這玩意有點(diǎn)坑，它不會(huì)復(fù)用線程的 ，它的設(shè)計(jì)初衷就是執(zhí)行大量的短時(shí)間的任務(wù)。有興趣的小伙伴，可以去看看它的源碼：

/**
*{@linkTaskExecutor}implementationthatfiresupanewThreadforeachtask,
*executingitasynchronously.
*
*
Supportslimitingconcurrentthreadsthroughthe"concurrencyLimit"
*beanproperty.Bydefault,thenumberofconcurrentthreadsisunlimited.
*
*
NOTE:Thisimplementationdoesnotreusethreads!Considera
*thread-poolingTaskExecutorimplementationinstead,inparticularfor
*executingalargenumberofshort-livedtasks.
*
*@authorJuergenHoeller
*@since2.0
*@see#setConcurrencyLimit
*@seeSyncTaskExecutor
*@seeorg.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
*@seeorg.springframework.scheduling.commonj.WorkManagerTaskExecutor
*/
@SuppressWarnings("serial")
publicclassSimpleAsyncTaskExecutorextendsCustomizableThreadCreatorimplementsAsyncListenableTaskExecutor,Serializable{
......
}

也就是說(shuō)來(lái)了一個(gè)請(qǐng)求，就會(huì)新建一個(gè)線程！大家使用spring的@Async時(shí)，要避開(kāi)這個(gè)坑，自己再定義一個(gè)線程池。正例如下：

@Bean(name="threadPoolTaskExecutor")
publicExecutorthreadPoolTaskExecutor(){
ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setThreadNamePrefix("tianluo-%d");
//其他參數(shù)設(shè)置
returnnewThreadPoolTaskExecutor();
}

6. 使用線程池時(shí)，沒(méi)有自定義命名

使用線程池時(shí)，如果沒(méi)有給線程池一個(gè)有意義的名稱(chēng)，將不好排查回溯問(wèn)題。這不算一個(gè)坑吧，只能說(shuō)給以后排查埋坑 ，哈哈。我還是單獨(dú)把它放出來(lái)算一個(gè)點(diǎn)，因?yàn)閭€(gè)人覺(jué)得這個(gè)還是比較重要的。反例如下：

publicclassThreadTest{

publicstaticvoidmain(String[]args)throwsException{
ThreadPoolExecutorexecutorOne=newThreadPoolExecutor(5,5,1,
TimeUnit.MINUTES,newArrayBlockingQueue(20));
executorOne.execute(()->{
System.out.println("關(guān)注：芋道源碼");
thrownewNullPointerException();
});
}
}

運(yùn)行結(jié)果：

Exceptioninthread"pool-1-thread-1"java.lang.NullPointerException
atcom.example.dto.ThreadTest.lambda$main$0(ThreadTest.java:17)
atjava.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
atjava.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
atjava.lang.Thread.run(Thread.java:748)

可以發(fā)現(xiàn)，默認(rèn)打印的線程池名字是pool-1-thread-1，如果排查問(wèn)題起來(lái)，并不友好。因此建議大家給自己線程池自定義個(gè)容易識(shí)別的名字。其實(shí)用CustomizableThreadFactory即可，正例如下：

publicclassThreadTest{

publicstaticvoidmain(String[]args)throwsException{
ThreadPoolExecutorexecutorOne=newThreadPoolExecutor(5,5,1,
TimeUnit.MINUTES,newArrayBlockingQueue(20),newCustomizableThreadFactory("Tianluo-Thread-pool"));
executorOne.execute(()->{
System.out.println("關(guān)注：芋道源碼");
thrownewNullPointerException();
});
}
}

7. 線程池參數(shù)設(shè)置不合理

線程池最容易出坑的地方，就是線程參數(shù)設(shè)置不合理。比如核心線程設(shè)置多少合理，最大線程池設(shè)置多少合理等等。當(dāng)然，這塊不是亂設(shè)置的，需要結(jié)合具體業(yè)務(wù) 。

比如線程池如何調(diào)優(yōu)，如何確認(rèn)最佳線程數(shù)？

最佳線程數(shù)目=（（線程等待時(shí)間+線程CPU時(shí)間）/線程CPU時(shí)間）*CPU數(shù)目

我們的服務(wù)器CPU核數(shù)為8核，一個(gè)任務(wù)線程cpu耗時(shí)為20ms，線程等待（網(wǎng)絡(luò)IO、磁盤(pán)IO）耗時(shí)80ms，那最佳線程數(shù)目：( 80 + 20 )/20 * 8 = 40。也就是設(shè)置 40個(gè)線程數(shù)最佳。

8. 線程池異常處理的坑

我們來(lái)看段代碼：

publicclassThreadTest{

publicstaticvoidmain(String[]args)throwsException{
ThreadPoolExecutorexecutorOne=newThreadPoolExecutor(5,5,1,
TimeUnit.MINUTES,newArrayBlockingQueue(20),newCustomizableThreadFactory("Tianluo-Thread-pool"));
for(inti=0;i{
System.out.println("currentthreadname"+Thread.currentThread().getName());
Objectobject=null;
System.out.print("result#"+object.toString());
});
}

}
}

按道理，運(yùn)行這塊代碼應(yīng)該拋空指針異常 才是的，對(duì)吧。但是，運(yùn)行結(jié)果卻是這樣的;

currentthreadnameTianluo-Thread-pool1
currentthreadnameTianluo-Thread-pool2
currentthreadnameTianluo-Thread-pool3
currentthreadnameTianluo-Thread-pool4
currentthreadnameTianluo-Thread-pool5

這是因?yàn)槭褂胹ubmit提交任務(wù)，不會(huì)把異常直接這樣拋出來(lái)。大家有興趣的話，可以去看看源碼。可以改為execute方法執(zhí)行，當(dāng)然最好就是try...catch捕獲，如下：

publicclassThreadTest{

publicstaticvoidmain(String[]args)throwsException{
ThreadPoolExecutorexecutorOne=newThreadPoolExecutor(5,5,1,
TimeUnit.MINUTES,newArrayBlockingQueue(20),newCustomizableThreadFactory("Tianluo-Thread-pool"));
for(inti=0;i{
System.out.println("currentthreadname"+Thread.currentThread().getName());
try{
Objectobject=null;
System.out.print("result#"+object.toString());
}catch(Exceptione){
System.out.println("異常了"+e);
}
});
}

}
}

其實(shí)，我們還可以為工作者線程設(shè)置UncaughtExceptionHandler，在uncaughtException方法中處理異常。大家知道這個(gè)坑就好啦。

9. 線程池使用完畢后，忘記關(guān)閉

如果線程池使用完，忘記關(guān)閉的話，有可能會(huì)導(dǎo)致內(nèi)存泄露 問(wèn)題。所以，大家使用完線程池后，記得關(guān)閉一下。同時(shí)，線程池最好也設(shè)計(jì)成單例模式，給它一個(gè)好的命名，以方便排查問(wèn)題。

publicclassThreadTest{

publicstaticvoidmain(String[]args)throwsException{

ThreadPoolExecutorexecutorOne=newThreadPoolExecutor(5,5,1,
TimeUnit.MINUTES,newArrayBlockingQueue(20),newCustomizableThreadFactory("Tianluo-Thread-pool"));
executorOne.execute(()->{
System.out.println("關(guān)注：芋道源碼");
});

//關(guān)閉線程池
executorOne.shutdown();
}
}

10. ThreadLocal與線程池搭配，線程復(fù)用，導(dǎo)致信息錯(cuò)亂。

使用ThreadLocal緩存信息，如果配合線程池一起，有可能出現(xiàn)信息錯(cuò)亂的情況。先看下一下例子：

privatestaticfinalThreadLocalcurrentUser=ThreadLocal.withInitial(()->null);

@GetMapping("wrong")
publicMapwrong(@RequestParam("userId")IntegeruserId){
//設(shè)置用戶(hù)信息之前先查詢(xún)一次ThreadLocal中的用戶(hù)信息
Stringbefore=Thread.currentThread().getName()+":"+currentUser.get();
//設(shè)置用戶(hù)信息到ThreadLocal
currentUser.set(userId);
//設(shè)置用戶(hù)信息之后再查詢(xún)一次ThreadLocal中的用戶(hù)信息
Stringafter=Thread.currentThread().getName()+":"+currentUser.get();
//匯總輸出兩次查詢(xún)結(jié)果
Mapresult=newHashMap();
result.put("before",before);
result.put("after",after);
returnresult;
}

按理說(shuō)，每次獲取的before應(yīng)該都是null，但是呢，程序運(yùn)行在 Tomcat 中，執(zhí)行程序的線程是Tomcat的工作線程，而Tomcat的工作線程是基于線程池 的。

線程池會(huì)重用固定的幾個(gè)線程 ，一旦線程重用，那么很可能首次從 ThreadLocal 獲取的值是之前其他用戶(hù)的請(qǐng)求遺留的值。這時(shí)，ThreadLocal 中的用戶(hù)信息就是其他用戶(hù)的信息。

把tomcat的工作線程設(shè)置為1

server.tomcat.max-threads=1

用戶(hù)1，請(qǐng)求過(guò)來(lái)，會(huì)有以下結(jié)果，符合預(yù)期：

用戶(hù)2請(qǐng)求過(guò)來(lái)，會(huì)有以下結(jié)果，「不符合預(yù)期」：

因此，使用類(lèi)似 ThreadLocal 工具來(lái)存放一些數(shù)據(jù)時(shí)，需要特別注意在代碼運(yùn)行完后，顯式地去清空設(shè)置的數(shù)據(jù)，正例如下：

@GetMapping("right")
publicMapright(@RequestParam("userId")IntegeruserId){
Stringbefore=Thread.currentThread().getName()+":"+currentUser.get();
currentUser.set(userId);
try{
Stringafter=Thread.currentThread().getName()+":"+currentUser.get();
Mapresult=newHashMap();
result.put("before",before);
result.put("after",after);
returnresult;
}finally{
//在finally代碼塊中刪除ThreadLocal中的數(shù)據(jù)，確保數(shù)據(jù)不串
currentUser.remove();
}
}

審核編輯：劉清