40個Java多線程問題總結

前言

java多線程分類中寫了21篇多線程的文章，21篇文章的内容很多，個人認為，學習，内容越多、越雜的知識，越需要進行深刻的總結，這樣才能記憶深刻，将知識變成自己的。這篇文章主要是對多線程的問題進行總結的，是以羅列了40個多線程的問題。

這些多線程的問題，有些來源于各大網站、有些來源于自己的思考。可能有些問題網上有、可能有些問題對應的答案也有、也可能有些各位網友也都看過，但是本文寫作的重心就是所有的問題都會按照自己的了解回答一遍，不會去看網上的答案，是以可能有些問題講的不對，能指正的希望大家不吝指教。

40個問題彙總

1、多線程有什麼用？

一個可能在很多人看來很扯淡的一個問題：我會用多線程就好了，還管它有什麼用？在我看來，這個回答更扯淡。所謂"知其然知其是以然"，"會用"隻是"知其然"，"為什麼用"才是"知其是以然"，隻有達到"知其然知其是以然"的程度才可以說是把一個知識點運用自如。ok，下面說說我對這個問題的看法：

（1）發揮多核cpu的優勢

随着工業的進步，現在的筆記本、桌上型電腦乃至商用的應用伺服器至少也都是雙核的，4核、8核甚至16核的也都不少見，如果是單線程的程式，那麼在雙核cpu上就浪費了50%，在4核cpu上就浪費了75%。單核cpu上所謂的"多線程"那是假的多線程，同一時間處理器隻會處理一段邏輯，隻不過線程之間切換得比較快，看着像多個線程"同時"運作罷了。多核cpu上的多線程才是真正的多線程，它能讓你的多段邏輯同時工作，多線程，可以真正發揮出多核cpu的優勢來，達到充分利用cpu的目的。

（2）防止阻塞

從程式運作效率的角度來看，單核cpu不但不會發揮出多線程的優勢，反而會因為在單核cpu上運作多線程導緻線程上下文的切換，而降低程式整體的效率。但是單核cpu我們還是要應用多線程，就是為了防止阻塞。試想，如果單核cpu使用單線程，那麼隻要這個線程阻塞了，比方說遠端讀取某個資料吧，對端遲遲未傳回又沒有設定逾時時間，那麼你的整個程式在資料傳回回來之前就停止運作了。多線程可以防止這個問題，多條線程同時運作，哪怕一條線程的代碼執行讀取資料阻塞，也不會影響其它任務的執行。

（3）便于模組化

這是另外一個沒有這麼明顯的優點了。假設有一個大的任務a，單線程程式設計，那麼就要考慮很多，建立整個程式模型比較麻煩。但是如果把這個大的任務a分解成幾個小任務，任務b、任務c、任務d，分别建立程式模型，并通過多線程分别運作這幾個任務，那就簡單很多了。

2、建立線程的方式

比較常見的一個問題了，一般就是兩種：

（1）繼承thread類

（2）實作runnable接口

至于哪個好，不用說肯定是後者好，因為實作接口的方式比繼承類的方式更靈活，也能減少程式之間的耦合度，面向接口程式設計也是設計模式6大原則的核心。

3、start()方法和run()方法的差別

隻有調用了start()方法，才會表現出多線程的特性，不同線程的run()方法裡面的代碼交替執行。如果隻是調用run()方法，那麼代碼還是同步執行的，必須等待一個線程的run()方法裡面的代碼全部執行完畢之後，另外一個線程才可以執行其run()方法裡面的代碼。

4、runnable接口和callable接口的差別

有點深的問題了，也看出一個java程式員學習知識的廣度。

runnable接口中的run()方法的傳回值是void，它做的事情隻是純粹地去執行run()方法中的代碼而已；callable接口中的call()方法是有傳回值的，是一個泛型，和future、futuretask配合可以用來擷取異步執行的結果。

這其實是很有用的一個特性，因為多線程相比單線程更難、更複雜的一個重要原因就是因為多線程充滿着未知性，某條線程是否執行了？某條線程執行了多久？某條線程執行的時候我們期望的資料是否已經指派完畢？無法得知，我們能做的隻是等待這條多線程的任務執行完畢而已。而callable+future/futuretask卻可以擷取多線程運作的結果，可以在等待時間太長沒擷取到需要的資料的情況下取消該線程的任務，真的是非常有用。

5、cyclicbarrier和countdownlatch的差別

兩個看上去有點像的類，都在java.util.concurrent下，都可以用來表示代碼運作到某個點上，二者的差別在于：

（1）cyclicbarrier的某個線程運作到某個點上之後，該線程即停止運作，直到所有的線程都到達了這個點，所有線程才重新運作；countdownlatch則不是，某線程運作到某個點上之後，隻是給某個數值-1而已，該線程繼續運作

（2）cyclicbarrier隻能喚起一個任務，countdownlatch可以喚起多個任務

（3）cyclicbarrier可重用，countdownlatch不可重用，計數值為0該countdownlatch就不可再用了

6、volatile關鍵字的作用

一個非常重要的問題，是每個學習、應用多線程的java程式員都必須掌握的。了解volatile關鍵字的作用的前提是要了解java記憶體模型，這裡就不講java記憶體模型了，可以參見第31點，volatile關鍵字的作用主要有兩個：

（1）多線程主要圍繞可見性和原子性兩個特性而展開，使用volatile關鍵字修飾的變量，保證了其在多線程之間的可見性，即每次讀取到volatile變量，一定是最新的資料

（2）代碼底層執行不像我們看到的進階語言----java程式這麼簡單，它的執行是java代碼-->位元組碼-->根據位元組碼執行對應的c/c++代碼-->c/c++代碼被編譯成彙編語言-->和硬體電路互動，現實中，為了擷取更好的性能jvm可能會對指令進行重排序，多線程下可能會出現一些意想不到的問題。使用volatile則會對禁止語義重排序，當然這也一定程度上降低了代碼執行效率

從實踐角度而言，volatile的一個重要作用就是和cas結合，保證了原子性，詳細的可以參見java.util.concurrent.atomic包下的類，比如atomicinteger。

7、什麼是線程安全

又是一個理論的問題，各式各樣的答案有很多，我給出一個個人認為解釋地最好的：如果你的代碼在多線程下執行和在單線程下執行永遠都能獲得一樣的結果，那麼你的代碼就是線程安全的。

這個問題有值得一提的地方，就是線程安全也是有幾個級别的：

（1）不可變

像string、integer、long這些，都是final類型的類，任何一個線程都改變不了它們的值，要改變除非新建立一個，是以這些不可變對象不需要任何同步手段就可以直接在多線程環境下使用

（2）絕對線程安全

不管運作時環境如何，調用者都不需要額外的同步措施。要做到這一點通常需要付出許多額外的代價，java中标注自己是線程安全的類，實際上絕大多數都不是線程安全的，不過絕對線程安全的類，java中也有，比方說copyonwritearraylist、copyonwritearrayset

（3）相對線程安全

相對線程安全也就是我們通常意義上所說的線程安全，像vector這種，add、remove方法都是原子操作，不會被打斷，但也僅限于此，如果有個線程在周遊某個vector、有個線程同時在add這個vector，99%的情況下都會出現concurrentmodificationexception，也就是fail-fast機制。

（4）線程非安全

這個就沒什麼好說的了，arraylist、linkedlist、hashmap等都是線程非安全的類

8、java中如何擷取到線程dump檔案

死循環、死鎖、阻塞、頁面打開慢等問題，打線程dump是最好的解決問題的途徑。所謂線程dump也就是線程堆棧，擷取到線程堆棧有兩步：

（1）擷取到線程的pid，可以通過使用jps指令，在linux環境下還可以使用ps -ef | grep java

（2）列印線程堆棧，可以通過使用jstack pid指令，在linux環境下還可以使用kill -3 pid

另外提一點，thread類提供了一個getstacktrace()方法也可以用于擷取線程堆棧。這是一個執行個體方法，是以此方法是和具體線程執行個體綁定的，每次擷取擷取到的是具體某個線程目前運作的堆棧，

9、一個線程如果出現了運作時異常會怎麼樣

如果這個異常沒有被捕獲的話，這個線程就停止執行了。另外重要的一點是：如果這個線程持有某個某個對象的螢幕，那麼這個對象螢幕會被立即釋放

10、如何在兩個線程之間共享資料

通過線上程之間共享對象就可以了，然後通過wait/notify/notifyall、await/signal/signalall進行喚起和等待，比方說阻塞隊列blockingqueue就是為線程之間共享資料而設計的

11、sleep方法和wait方法有什麼差別 

這個問題常問，sleep方法和wait方法都可以用來放棄cpu一定的時間，不同點在于如果線程持有某個對象的螢幕，sleep方法不會放棄這個對象的螢幕，wait方法會放棄這個對象的螢幕

12、生産者消費者模型的作用是什麼

這個問題很理論，但是很重要：

（1）通過平衡生産者的生産能力和消費者的消費能力來提升整個系統的運作效率，這是生産者消費者模型最重要的作用

（2）解耦，這是生産者消費者模型附帶的作用，解耦意味着生産者和消費者之間的聯系少，聯系越少越可以獨自發展而不需要收到互相的制約

13、threadlocal有什麼用

簡單說threadlocal就是一種以空間換時間的做法，在每個thread裡面維護了一個以開位址法實作的threadlocal.threadlocalmap，把資料進行隔離，資料不共享，自然就沒有線程安全方面的問題了

14、為什麼wait()方法和notify()/notifyall()方法要在同步塊中被調用

這是jdk強制的，wait()方法和notify()/notifyall()方法在調用前都必須先獲得對象的鎖

15、wait()方法和notify()/notifyall()方法在放棄對象螢幕時有什麼差別

wait()方法和notify()/notifyall()方法在放棄對象螢幕的時候的差別在于：wait()方法立即釋放對象螢幕，notify()/notifyall()方法則會等待線程剩餘代碼執行完畢才會放棄對象螢幕。

16、為什麼要使用線程池

避免頻繁地建立和銷毀線程，達到線程對象的重用。另外，使用線程池還可以根據項目靈活地控制并發的數目。

17、怎麼檢測一個線程是否持有對象螢幕

我也是在網上看到一道多線程面試題才知道有方法可以判斷某個線程是否持有對象螢幕：thread類提供了一個holdslock(object obj)方法，當且僅當對象obj的螢幕被某條線程持有的時候才會傳回true，注意這是一個static方法，這意味着"某條線程"指的是目前線程。

18、synchronized和reentrantlock的差別

synchronized是和if、else、for、while一樣的關鍵字，reentrantlock是類，這是二者的本質差別。既然reentrantlock是類，那麼它就提供了比synchronized更多更靈活的特性，可以被繼承、可以有方法、可以有各種各樣的類變量，reentrantlock比synchronized的擴充性展現在幾點上：

（1）reentrantlock可以對擷取鎖的等待時間進行設定，這樣就避免了死鎖

（2）reentrantlock可以擷取各種鎖的資訊

（3）reentrantlock可以靈活地實作多路通知

另外，二者的鎖機制其實也是不一樣的。reentrantlock底層調用的是unsafe的park方法加鎖，synchronized操作的應該是對象頭中mark word，這點我不能确定。

19、concurrenthashmap的并發度是什麼

concurrenthashmap的并發度就是segment的大小，預設為16，這意味着最多同時可以有16條線程操作concurrenthashmap，這也是concurrenthashmap對hashtable的最大優勢，任何情況下，hashtable能同時有兩條線程擷取hashtable中的資料嗎？

20、readwritelock是什麼

首先明确一下，不是說reentrantlock不好，隻是reentrantlock某些時候有局限。如果使用reentrantlock，可能本身是為了防止線程a在寫資料、線程b在讀資料造成的資料不一緻，但這樣，如果線程c在讀資料、線程d也在讀資料，讀資料是不會改變資料的，沒有必要加鎖，但是還是加鎖了，降低了程式的性能。

因為這個，才誕生了讀寫鎖readwritelock。readwritelock是一個讀寫鎖接口，reentrantreadwritelock是readwritelock接口的一個具體實作，實作了讀寫的分離，讀鎖是共享的，寫鎖是獨占的，讀和讀之間不會互斥，讀和寫、寫和讀、寫和寫之間才會互斥，提升了讀寫的性能。

21、futuretask是什麼

這個其實前面有提到過，futuretask表示一個異步運算的任務。futuretask裡面可以傳入一個callable的具體實作類，可以對這個異步運算的任務的結果進行等待擷取、判斷是否已經完成、取消任務等操作。當然，由于futuretask也是runnable接口的實作類，是以futuretask也可以放入線程池中。

22、linux環境下如何查找哪個線程使用cpu最長

這是一個比較偏實踐的問題，這種問題我覺得挺有意義的。可以這麼做：

（1）擷取項目的pid，jps或者ps -ef | grep java，這個前面有講過

（2）top -h -p pid，順序不能改變

這樣就可以列印出目前的項目，每條線程占用cpu時間的百分比。注意這裡打出的是lwp，也就是作業系統原生線程的線程号，我筆記本山沒有部署linux環境下的java工程，是以沒有辦法截圖示範，網友朋友們如果公司是使用linux環境部署項目的話，可以嘗試一下。

使用"top -h -p pid"+"jps pid"可以很容易地找到某條占用cpu高的線程的線程堆棧，進而定位占用cpu高的原因，一般是因為不當的代碼操作導緻了死循環。

最後提一點，"top -h -p pid"打出來的lwp是十進制的，"jps pid"打出來的本地線程号是十六進制的，轉換一下，就能定位到占用cpu高的線程的目前線程堆棧了。

23、java程式設計寫一個會導緻死鎖的程式

第一次看到這個題目，覺得這是一個非常好的問題。很多人都知道死鎖是怎麼一回事兒：線程a和線程b互相等待對方持有的鎖導緻程式無限死循環下去。當然也僅限于此了，問一下怎麼寫一個死鎖的程式就不知道了，這種情況說白了就是不懂什麼是死鎖，懂一個理論就完事兒了，實踐中碰到死鎖的問題基本上是看不出來的。

真正了解什麼是死鎖，這個問題其實不難，幾個步驟：

（1）兩個線程裡面分别持有兩個object對象：lock1和lock2。這兩個lock作為同步代碼塊的鎖；

（2）線程1的run()方法中同步代碼塊先擷取lock1的對象鎖，thread.sleep(xxx)，時間不需要太多，50毫秒差不多了，然後接着擷取lock2的對象鎖。這麼做主要是為了防止線程1啟動一下子就連續獲得了lock1和lock2兩個對象的對象鎖

（3）線程2的run)(方法中同步代碼塊先擷取lock2的對象鎖，接着擷取lock1的對象鎖，當然這時lock1的對象鎖已經被線程1鎖持有，線程2肯定是要等待線程1釋放lock1的對象鎖的

這樣，線程1"睡覺"睡完，線程2已經擷取了lock2的對象鎖了，線程1此時嘗試擷取lock2的對象鎖，便被阻塞，此時一個死鎖就形成了。代碼就不寫了，占的篇幅有點多，​​java多線程7：死鎖​​這篇文章裡面有，就是上面步驟的代碼實作。

24、怎麼喚醒一個阻塞的線程

如果線程是因為調用了wait()、sleep()或者join()方法而導緻的阻塞，可以中斷線程，并且通過抛出interruptedexception來喚醒它；如果線程遇到了io阻塞，無能為力，因為io是作業系統實作的，java代碼并沒有辦法直接接觸到作業系統。

25、不可變對象對多線程有什麼幫助

前面有提到過的一個問題，不可變對象保證了對象的記憶體可見性，對不可變對象的讀取不需要進行額外的同步手段，提升了代碼執行效率。

26、什麼是多線程的上下文切換

多線程的上下文切換是指cpu控制權由一個已經正在運作的線程切換到另外一個就緒并等待擷取cpu執行權的線程的過程。

27、如果你送出任務時，線程池隊列已滿，這時會發生什麼

這裡區分一下：

如果使用的是無界隊列linkedblockingqueue，也就是無界隊列的話，沒關系，繼續添加任務到阻塞隊列中等待執行，因為linkedblockingqueue可以近乎認為是一個無窮大的隊列，可以無限存放任務

如果使用的是有界隊列比如arrayblockingqueue，任務首先會被添加到arrayblockingqueue中，arrayblockingqueue滿了，會根據maximumpoolsize的值增加線程數量，如果增加了線程數量還是處理不過來，arrayblockingqueue繼續滿，那麼則會使用拒絕政策rejectedexecutionhandler處理滿了的任務，預設是abortpolicy

28、java中用到的線程排程算法是什麼

搶占式。一個線程用完cpu之後，作業系統會根據線程優先級、線程饑餓情況等資料算出一個總的優先級并配置設定下一個時間片給某個線程執行。

29、thread.sleep(0)的作用是什麼

這個問題和上面那個問題是相關的，我就連在一起了。由于java采用搶占式的線程排程算法，是以可能會出現某條線程常常擷取到cpu控制權的情況，為了讓某些優先級比較低的線程也能擷取到cpu控制權，可以使用thread.sleep(0)手動觸發一次作業系統配置設定時間片的操作，這也是平衡cpu控制權的一種操作。

30、什麼是自旋

很多synchronized裡面的代碼隻是一些很簡單的代碼，執行時間非常快，此時等待的線程都加鎖可能是一種不太值得的操作，因為線程阻塞涉及到使用者态和核心态切換的問題。既然synchronized裡面的代碼執行得非常快，不妨讓等待鎖的線程不要被阻塞，而是在synchronized的邊界做忙循環，這就是自旋。如果做了多次忙循環發現還沒有獲得鎖，再阻塞，這樣可能是一種更好的政策。

31、什麼是java記憶體模型

java記憶體模型定義了一種多線程通路java記憶體的規範。java記憶體模型要完整講不是這裡幾句話能說清楚的，我簡單總結一下java記憶體模型的幾部分内容：

（1）java記憶體模型将記憶體分為了主記憶體和工作記憶體。類的狀态，也就是類之間共享的變量，是存儲在主記憶體中的，每次java線程用到這些主記憶體中的變量的時候，會讀一次主記憶體中的變量，并讓這些記憶體在自己的工作記憶體中有一份拷貝，運作自己線程代碼的時候，用到這些變量，操作的都是自己工作記憶體中的那一份。線上程代碼執行完畢之後，會将最新的值更新到主記憶體中去

（2）定義了幾個原子操作，用于操作主記憶體和工作記憶體中的變量

（3）定義了volatile變量的使用規則

（4）happens-before，即先行發生原則，定義了操作a必然先行發生于操作b的一些規則，比如在同一個線程内控制流前面的代碼一定先行發生于控制流後面的代碼、一個釋放鎖unlock的動作一定先行發生于後面對于同一個鎖進行鎖定lock的動作等等，隻要符合這些規則，則不需要額外做同步措施，如果某段代碼不符合所有的happens-before規則，則這段代碼一定是線程非安全的

32、什麼是cas

cas，全稱為compare and swap，即比較-替換。假設有三個操作數：記憶體值v、舊的預期值a、要修改的值b，當且僅當預期值a和記憶體值v相同時，才會将記憶體值修改為b并傳回true，否則什麼都不做并傳回false。當然cas一定要volatile變量配合，這樣才能保證每次拿到的變量是主記憶體中最新的那個值，否則舊的預期值a對某條線程來說，永遠是一個不會變的值a，隻要某次cas操作失敗，永遠都不可能成功。

33、什麼是樂觀鎖和悲觀鎖

（1）樂觀鎖：就像它的名字一樣，對于并發間操作産生的線程安全問題持樂觀狀态，樂觀鎖認為競争不總是會發生，是以它不需要持有鎖，将比較-替換這兩個動作作為一個原子操作嘗試去修改記憶體中的變量，如果失敗則表示發生沖突，那麼就應該有相應的重試邏輯。

（2）悲觀鎖：還是像它的名字一樣，對于并發間操作産生的線程安全問題持悲觀狀态，悲觀鎖認為競争總是會發生，是以每次對某資源進行操作時，都會持有一個獨占的鎖，就像synchronized，不管三七二十一，直接上了鎖就操作資源了。

34、什麼是aqs

簡單說一下aqs，aqs全稱為abstractqueuedsychronizer，翻譯過來應該是抽象隊列同步器。

如果說java.util.concurrent的基礎是cas的話，那麼aqs就是整個java并發包的核心了，reentrantlock、countdownlatch、semaphore等等都用到了它。aqs實際上以雙向隊列的形式連接配接所有的entry，比方說reentrantlock，所有等待的線程都被放在一個entry中并連成雙向隊列，前面一個線程使用reentrantlock好了，則雙向隊列實際上的第一個entry開始運作。

aqs定義了對雙向隊列所有的操作，而隻開放了trylock和tryrelease方法給開發者使用，開發者可以根據自己的實作重寫trylock和tryrelease方法，以實作自己的并發功能。

35、單例模式的線程安全性

老生常談的問題了，首先要說的是單例模式的線程安全意味着：某個類的執行個體在多線程環境下隻會被建立一次出來。單例模式有很多種的寫法，我總結一下：

（1）餓漢式單例模式的寫法：線程安全

（2）懶漢式單例模式的寫法：非線程安全

（3）雙檢鎖單例模式的寫法：線程安全

36、semaphore有什麼作用

semaphore就是一個信号量，它的作用是限制某段代碼塊的并發數。semaphore有一個構造函數，可以傳入一個int型整數n，表示某段代碼最多隻有n個線程可以通路，如果超出了n，那麼請等待，等到某個線程執行完畢這段代碼塊，下一個線程再進入。由此可以看出如果semaphore構造函數中傳入的int型整數n=1，相當于變成了一個synchronized了。

37、hashtable的size()方法中明明隻有一條語句"return count"，為什麼還要做同步？

這是我之前的一個困惑，不知道大家有沒有想過這個問題。某個方法中如果有多條語句，并且都在操作同一個類變量，那麼在多線程環境下不加鎖，勢必會引發線程安全問題，這很好了解，但是size()方法明明隻有一條語句，為什麼還要加鎖？

關于這個問題，在慢慢地工作、學習中，有了了解，主要原因有兩點：

（1）同一時間隻能有一條線程執行固定類的同步方法，但是對于類的非同步方法，可以多條線程同時通路。是以，這樣就有問題了，可能線程a在執行hashtable的put方法添加資料，線程b則可以正常調用size()方法讀取hashtable中目前元素的個數，那讀取到的值可能不是最新的，可能線程a添加了完了資料，但是沒有對size++，線程b就已經讀取size了，那麼對于線程b來說讀取到的size一定是不準确的。而給size()方法加了同步之後，意味着線程b調用size()方法隻有線上程a調用put方法完畢之後才可以調用，這樣就保證了線程安全性

（2）cpu執行代碼，執行的不是java代碼，這點很關鍵，一定得記住。java代碼最終是被翻譯成彙編代碼執行的，彙編代碼才是真正可以和硬體電路互動的代碼。即使你看到java代碼隻有一行，甚至你看到java代碼編譯之後生成的位元組碼也隻有一行，也不意味着對于底層來說這句語句的操作隻有一個。一句"return count"假設被翻譯成了三句彙編語句執行，完全可能執行完第一句，線程就切換了。

38、線程類的構造方法、靜态塊是被哪個線程調用的

這是一個非常刁鑽和狡猾的問題。請記住：線程類的構造方法、靜态塊是被new這個線程類所在的線程所調用的，而run方法裡面的代碼才是被線程自身所調用的。

如果說上面的說法讓你感到困惑，那麼我舉個例子，假設thread2中new了thread1，main函數中new了thread2，那麼：

（1）thread2的構造方法、靜态塊是main線程調用的，thread2的run()方法是thread2自己調用的

（2）thread1的構造方法、靜态塊是thread2調用的，thread1的run()方法是thread1自己調用的

39、同步方法和同步塊，哪個是更好的選擇

同步塊，這意味着同步塊之外的代碼是異步執行的，這比同步整個方法更提升代碼的效率。請知道一條原則：同步的範圍越小越好。

借着這一條，我額外提一點，雖說同步的範圍越少越好，但是在java虛拟機中還是存在着一種叫做鎖粗化的優化方法，這種方法就是把同步範圍變大。這是有用的，比方說stringbuffer，它是一個線程安全的類，自然最常用的append()方法是一個同步方法，我們寫代碼的時候會反複append字元串，這意味着要進行反複的加鎖->解鎖，這對性能不利，因為這意味着java虛拟機在這條線程上要反複地在核心态和使用者态之間進行切換，是以java虛拟機會将多次append方法調用的代碼進行一個鎖粗化的操作，将多次的append的操作擴充到append方法的頭尾，變成一個大的同步塊，這樣就減少了加鎖-->解鎖的次數，有效地提升了代碼執行的效率。

40、高并發、任務執行時間短的業務怎樣使用線程池？并發不高、任務執行時間長的業務怎樣使用線程池？并發高、業務執行時間長的業務怎樣使用線程池？

這是我在并發程式設計網上看到的一個問題，把這個問題放在最後一個，希望每個人都能看到并且思考一下，因為這個問題非常好、非常實際、非常專業。關于這個問題，個人看法是：

（1）高并發、任務執行時間短的業務，線程池線程數可以設定為cpu核數+1，減少線程上下文的切換

（2）并發不高、任務執行時間長的業務要區分開看：

　　a）假如是業務時間長集中在io操作上，也就是io密集型的任務，因為io操作并不占用cpu，是以不要讓所有的cpu閑下來，可以加大線程池中的線程數目，讓cpu處理更多的業務

　　b）假如是業務時間長集中在計算操作上，也就是計算密集型任務，這個就沒辦法了，和（1）一樣吧，線程池中的線程數設定得少一些，減少線程上下文的切換

（3）并發高、業務執行時間長，解決這種類型任務的關鍵不在于線程池而在于整體架構的設計，看看這些業務裡面某些資料是否能做緩存是第一步，增加伺服器是第二步，至于線程池的設定，設定參考（2）。最後，業務執行時間長的問題，也可能需要分析一下，看看能不能使用中間件對任務進行拆分和解耦。

================================================================================== 

http://www.cnblogs.com/xrq730/p/5060921.html