前言
這篇文章主要是對多線程的問題進(jìn)行總結(jié)的，因此羅列了100個多線程的問題。
這些多線程的問題來源于各大網(wǎng)站，可能有些問題網(wǎng)上有、可能有些問題對應(yīng)的答案也有、也可能有些各位網(wǎng)友也都看過，但是本文寫作的重心就是所有的問題都會按照自己的理解回答一遍，不會去看網(wǎng)上的答案，因此可能有些問題講的不對，能指正的希望大家不吝指教。整理了一份Java面試寶典完整版PDF
100個問題匯總
1、多線程有什么用？
一個可能在很多人看來很扯淡的一個問題：我會用多線程就好了，還管它有什么用？在我看來，這個回答更扯淡。所謂"知其然知其所以然"，"會用"只是"知其然"，"為什么用"才是"知其所以然"，只有達(dá)到"知其然知其所以然"的程度才可以說是把一個知識點(diǎn)運(yùn)用自如。OK，下面說說我對這個問題的看法：
（1）發(fā)揮多核CPU的優(yōu)勢
隨著工業(yè)的進(jìn)步，現(xiàn)在的筆記本、臺式機(jī)乃至商用的應(yīng)用服務(wù)器至少也都是雙核的，4核、8核甚至16核的也都不少見，如果是單線程的程序，那么在雙核CPU上就浪費(fèi)了50%，在4核CPU上就浪費(fèi)了75%。單核CPU上所謂的"多線程"那是假的多線程，同一時間處理器只會處理一段邏輯，只不過線程之間切換得比較快，看著像多個線程"同時"運(yùn)行罷了。多核CPU上的多線程才是真正的多線程，它能讓你的多段邏輯同時工作，多線程，可以真正發(fā)揮出多核CPU的優(yōu)勢來，達(dá)到充分利用CPU的目的。
（2）防止阻塞
從程序運(yùn)行效率的角度來看，單核CPU不但不會發(fā)揮出多線程的優(yōu)勢，反而會因?yàn)樵趩魏薈PU上運(yùn)行多線程導(dǎo)致線程上下文的切換，而降低程序整體的效率。但是單核CPU我們還是要應(yīng)用多線程，就是為了防止阻塞。試想，如果單核CPU使用單線程，那么只要這個線程阻塞了，比方說遠(yuǎn)程讀取某個數(shù)據(jù)吧，對端遲遲未返回又沒有設(shè)置超時時間，那么你的整個程序在數(shù)據(jù)返回回來之前就停止運(yùn)行了。多線程可以防止這個問題，多條線程同時運(yùn)行，哪怕一條線程的代碼執(zhí)行讀取數(shù)據(jù)阻塞，也不會影響其它任務(wù)的執(zhí)行。
（3）便于建模
這是另外一個沒有這么明顯的優(yōu)點(diǎn)了。假設(shè)有一個大的任務(wù)A，單線程編程，那么就要考慮很多，建立整個程序模型比較麻煩。但是如果把這個大的任務(wù)A分解成幾個小任務(wù)，任務(wù)B、任務(wù)C、任務(wù)D，分別建立程序模型，并通過多線程分別運(yùn)行這幾個任務(wù)，那就簡單很多了。
2、創(chuàng)建線程的方式
比較常見的一個問題了，一般就是兩種：
（1）繼承Thread類
（2）實(shí)現(xiàn)Runnable接口
至于哪個好，不用說肯定是后者好，因?yàn)閷?shí)現(xiàn)接口的方式比繼承類的方式更靈活，也能減少程序之間的耦合度，面向接口編程也是設(shè)計(jì)模式6大原則的核心。
3、start()方法和run()方法的區(qū)別
只有調(diào)用了start()方法，才會表現(xiàn)出多線程的特性，不同線程的run()方法里面的代碼交替執(zhí)行。如果只是調(diào)用run()方法，那么代碼還是同步執(zhí)行的，必須等待一個線程的run()方法里面的代碼全部執(zhí)行完畢之后，另外一個線程才可以執(zhí)行其run()方法里面的代碼。
4、Runnable接口和Callable接口的區(qū)別
有點(diǎn)深的問題了，也看出一個Java程序員學(xué)習(xí)知識的廣度。
Runnable接口中的run()方法的返回值是void，它做的事情只是純粹地去執(zhí)行run()方法中的代碼而已；Callable接口中的call()方法是有返回值的，是一個泛型，和Future、FutureTask配合可以用來獲取異步執(zhí)行的結(jié)果。
這其實(shí)是很有用的一個特性，因?yàn)槎嗑€程相比單線程更難、更復(fù)雜的一個重要原因就是因?yàn)槎嗑€程充滿著未知性，某條線程是否執(zhí)行了？某條線程執(zhí)行了多久？某條線程執(zhí)行的時候我們期望的數(shù)據(jù)是否已經(jīng)賦值完畢？無法得知，我們能做的只是等待這條多線程的任務(wù)執(zhí)行完畢而已。而Callable+Future/FutureTask卻可以獲取多線程運(yùn)行的結(jié)果，可以在等待時間太長沒獲取到需要的數(shù)據(jù)的情況下取消該線程的任務(wù)，真的是非常有用。
5、CyclicBarrier和CountDownLatch的區(qū)別
兩個看上去有點(diǎn)像的類，都在java.util.concurrent下，都可以用來表示代碼運(yùn)行到某個點(diǎn)上，二者的區(qū)別在于：
（1）CyclicBarrier的某個線程運(yùn)行到某個點(diǎn)上之后，該線程即停止運(yùn)行，直到所有的線程都到達(dá)了這個點(diǎn)，所有線程才重新運(yùn)行；CountDownLatch則不是，某線程運(yùn)行到某個點(diǎn)上之后，只是給某個數(shù)值-1而已，該線程繼續(xù)運(yùn)行
（2）CyclicBarrier只能喚起一個任務(wù)，CountDownLatch可以喚起多個任務(wù)
（3）CyclicBarrier可重用，CountDownLatch不可重用，計(jì)數(shù)值為0該CountDownLatch就不可再用了
6、volatile關(guān)鍵字的作用
一個非常重要的問題，是每個學(xué)習(xí)、應(yīng)用多線程的Java程序員都必須掌握的。理解volatile關(guān)鍵字的作用的前提是要理解Java內(nèi)存模型，這里就不講Java內(nèi)存模型了，可以參見第31點(diǎn)，volatile關(guān)鍵字的作用主要有兩個：
（1）多線程主要圍繞可見性和原子性兩個特性而展開，使用volatile關(guān)鍵字修飾的變量，保證了其在多線程之間的可見性，即每次讀取到volatile變量，一定是最新的數(shù)據(jù)
（2）代碼底層執(zhí)行不像我們看到的高級語言----Java程序這么簡單，它的執(zhí)行是Java代碼-->字節(jié)碼-->根據(jù)字節(jié)碼執(zhí)行對應(yīng)的C/C++代碼-->C/C++代碼被編譯成匯編語言-->和硬件電路交互，現(xiàn)實(shí)中，為了獲取更好的性能JVM可能會對指令進(jìn)行重排序，多線程下可能會出現(xiàn)一些意想不到的問題。使用volatile則會對禁止語義重排序，當(dāng)然這也一定程度上降低了代碼執(zhí)行效率
從實(shí)踐角度而言，volatile的一個重要作用就是和CAS結(jié)合，保證了原子性，詳細(xì)的可以參見java.util.concurrent.atomic包下的類，比如AtomicInteger。
7、什么是線程安全
又是一個理論的問題，各式各樣的答案有很多，我給出一個個人認(rèn)為解釋地最好的：如果你的代碼在多線程下執(zhí)行和在單線程下執(zhí)行永遠(yuǎn)都能獲得一樣的結(jié)果，那么你的代碼就是線程安全的。
這個問題有值得一提的地方，就是線程安全也是有幾個級別的：
（1）不可變
像String、Integer、Long這些，都是final類型的類，任何一個線程都改變不了它們的值，要改變除非新創(chuàng)建一個，因此這些不可變對象不需要任何同步手段就可以直接在多線程環(huán)境下使用
（2）絕對線程安全
不管運(yùn)行時環(huán)境如何，調(diào)用者都不需要額外的同步措施。要做到這一點(diǎn)通常需要付出許多額外的代價，Java中標(biāo)注自己是線程安全的類，實(shí)際上絕大多數(shù)都不是線程安全的，不過絕對線程安全的類，Java中也有，比方說CopyOnWriteArrayList、CopyOnWriteArraySet
（3）相對線程安全
相對線程安全也就是我們通常意義上所說的線程安全，像Vector這種，add、remove方法都是原子操作，不會被打斷，但也僅限于此，如果有個線程在遍歷某個Vector、有個線程同時在add這個Vector，99%的情況下都會出現(xiàn)ConcurrentModificationException，也就是fail-fast機(jī)制。
（4）線程非安全
這個就沒什么好說的了，ArrayList、LinkedList、HashMap等都是線程非安全的類
8、Java中如何獲取到線程dump文件
死循環(huán)、死鎖、阻塞、頁面打開慢等問題，打線程dump是最好的解決問題的途徑。所謂線程dump也就是線程堆棧，獲取到線程堆棧有兩步：
（1）獲取到線程的pid，可以通過使用jps命令，在Linux環(huán)境下還可以使用ps -ef | grep java
（2）打印線程堆棧，可以通過使用jstack pid命令，在Linux環(huán)境下還可以使用kill -3 pid
另外提一點(diǎn)，Thread類提供了一個getStackTrace()方法也可以用于獲取線程堆棧。這是一個實(shí)例方法，因此此方法是和具體線程實(shí)例綁定的，每次獲取獲取到的是具體某個線程當(dāng)前運(yùn)行的堆棧，
9、一個線程如果出現(xiàn)了運(yùn)行時異常會怎么樣
如果這個異常沒有被捕獲的話，這個線程就停止執(zhí)行了。另外重要的一點(diǎn)是：如果這個線程持有某個某個對象的監(jiān)視器，那么這個對象監(jiān)視器會被立即釋放
10、如何在兩個線程之間共享數(shù)據(jù)
通過在線程之間共享對象就可以了，然后通過wait/notify/notifyAll、await/signal/signalAll進(jìn)行喚起和等待，比方說阻塞隊(duì)列BlockingQueue就是為線程之間共享數(shù)據(jù)而設(shè)計(jì)的
11、sleep方法和wait方法有什么區(qū)別
這個問題常問，sleep方法和wait方法都可以用來放棄CPU一定的時間，不同點(diǎn)在于如果線程持有某個對象的監(jiān)視器，sleep方法不會放棄這個對象的監(jiān)視器，wait方法會放棄這個對象的監(jiān)視器
12、生產(chǎn)者消費(fèi)者模型的作用是什么
這個問題很理論，但是很重要：
（1）通過平衡生產(chǎn)者的生產(chǎn)能力和消費(fèi)者的消費(fèi)能力來提升整個系統(tǒng)的運(yùn)行效率，這是生產(chǎn)者消費(fèi)者模型最重要的作用
（2）解耦，這是生產(chǎn)者消費(fèi)者模型附帶的作用，解耦意味著生產(chǎn)者和消費(fèi)者之間的聯(lián)系少，聯(lián)系越少越可以獨(dú)自發(fā)展而不需要收到相互的制約
13、ThreadLocal有什么用
簡單說ThreadLocal就是一種以空間換時間的做法，在每個Thread里面維護(hù)了一個以開地址法實(shí)現(xiàn)的ThreadLocal.ThreadLocalMap，把數(shù)據(jù)進(jìn)行隔離，數(shù)據(jù)不共享，自然就沒有線程安全方面的問題了
14、為什么wait()方法和notify()/notifyAll()方法要在同步塊中被調(diào)用
這是JDK強(qiáng)制的，wait()方法和notify()/notifyAll()方法在調(diào)用前都必須先獲得對象的鎖
15、wait()方法和notify()/notifyAll()方法在放棄對象監(jiān)視器時有什么區(qū)別
wait()方法和notify()/notifyAll()方法在放棄對象監(jiān)視器的時候的區(qū)別在于：
wait()方法立即釋放對象監(jiān)視器，notify()/notifyAll()方法則會等待線程剩余代碼執(zhí)行完畢才會放棄對象監(jiān)視器。
16、為什么要使用線程池
避免頻繁地創(chuàng)建和銷毀線程，達(dá)到線程對象的重用。另外，使用線程池還可以根據(jù)項(xiàng)目靈活地控制并發(fā)的數(shù)目。
17、怎么檢測一個線程是否持有對象監(jiān)視器
我也是在網(wǎng)上看到一道多線程面試題才知道有方法可以判斷某個線程是否持有對象監(jiān)視器：Thread類提供了一個holdsLock(Object obj)方法，當(dāng)且僅當(dāng)對象obj的監(jiān)視器被某條線程持有的時候才會返回true，注意這是一個static方法，這意味著"某條線程"指的是當(dāng)前線程。
18、synchronized和ReentrantLock的區(qū)別
synchronized是和if、else、for、while一樣的關(guān)鍵字，ReentrantLock是類，這是二者的本質(zhì)區(qū)別。既然ReentrantLock是類，那么它就提供了比
synchronized更多更靈活的特性，可以被繼承、可以有方法、可以有各種各樣的類變量，ReentrantLock比synchronized的擴(kuò)展性體現(xiàn)在幾點(diǎn)上：
（1）ReentrantLock可以對獲取鎖的等待時間進(jìn)行設(shè)置，這樣就避免了死鎖
（2）ReentrantLock可以獲取各種鎖的信息
（3）ReentrantLock可以靈活地實(shí)現(xiàn)多路通知
另外，二者的鎖機(jī)制其實(shí)也是不一樣的。ReentrantLock底層調(diào)用的是Unsafe的park方法加鎖，synchronized操作的應(yīng)該是對象頭中mark word，這點(diǎn)我不能確定。
19、ConcurrentHashMap的并發(fā)度是什么
ConcurrentHashMap的并發(fā)度就是segment的大小，默認(rèn)為16，這意味著最多同時可以有16條線程操作ConcurrentHashMap，這也是ConcurrentHashMap對Hashtable的最大優(yōu)勢，任何情況下，Hashtable能同時有兩條線程獲取Hashtable中的數(shù)據(jù)嗎？
20、ReadWriteLock是什么
首先明確一下，不是說ReentrantLock不好，只是ReentrantLock某些時候有局限。如果使用ReentrantLock，可能本身是為了防止線程A在寫數(shù)據(jù)、線程B在讀數(shù)據(jù)造成的數(shù)據(jù)不一致，但這樣，如果線程C在讀數(shù)據(jù)、線程D也在讀數(shù)據(jù)，讀數(shù)據(jù)是不會改變數(shù)據(jù)的，沒有必要加鎖，但是還是加鎖了，降低了程序的性能。
因?yàn)檫@個，才誕生了讀寫鎖ReadWriteLock。ReadWriteLock是一個讀寫鎖接口，ReentrantReadWriteLock是ReadWriteLock接口的一個具體實(shí)現(xiàn)，實(shí)現(xiàn)了讀寫的分離，讀鎖是共享的，寫鎖是獨(dú)占的，讀和讀之間不會互斥，讀和寫、寫和讀、寫和寫之間才會互斥，提升了讀寫的性能。
21、FutureTask是什么
這個其實(shí)前面有提到過，F(xiàn)utureTask表示一個異步運(yùn)算的任務(wù)。FutureTask里面可以傳入一個Callable的具體實(shí)現(xiàn)類，可以對這個異步運(yùn)算的任務(wù)的結(jié)果進(jìn)行等待獲取、判斷是否已經(jīng)完成、取消任務(wù)等操作。當(dāng)然，由于FutureTask也是Runnable接口的實(shí)現(xiàn)類，所以FutureTask也可以放入線程池中。
22、Linux環(huán)境下如何查找哪個線程使用CPU最長
這是一個比較偏實(shí)踐的問題，這種問題我覺得挺有意義的?？梢赃@么做：
（1）獲取項(xiàng)目的pid，jps或者ps -ef | grep java，這個前面有講過
（2）top -H -p pid，順序不能改變
這樣就可以打印出當(dāng)前的項(xiàng)目，每條線程占用CPU時間的百分比。注意這里打出的是LWP，也就是操作系統(tǒng)原生線程的線程號，我筆記本山?jīng)]有部署Linux環(huán)境下的Java工程，因此沒有辦法截圖演示，網(wǎng)友朋友們?nèi)绻臼鞘褂肔inux環(huán)境部署項(xiàng)目的話，可以嘗試一下。
使用"top -H -p pid"+"jps pid"可以很容易地找到某條占用CPU高的線程的線程堆棧，從而定位占用CPU高的原因，一般是因?yàn)椴划?dāng)?shù)拇a操作導(dǎo)致了死循環(huán)。
最后提一點(diǎn)，"top -H -p pid"打出來的LWP是十進(jìn)制的，"jps pid"打出來的本地線程號是十六進(jìn)制的，轉(zhuǎn)換一下，就能定位到占用CPU高的線程的當(dāng)前線程堆棧了。
23、Java編程寫一個會導(dǎo)致死鎖的程序
第一次看到這個題目，覺得這是一個非常好的問題。很多人都知道死鎖是怎么一回事兒：線程A和線程B相互等待對方持有的鎖導(dǎo)致程序無限死循環(huán)下去。當(dāng)然也僅限于此了，問一下怎么寫一個死鎖的程序就不知道了，這種情況說白了就是不懂什么是死鎖，懂一個理論就完事兒了，實(shí)踐中碰到死鎖的問題基本上是看不出來的。
真正理解什么是死鎖，這個問題其實(shí)不難，幾個步驟：
（1）兩個線程里面分別持有兩個Object對象：lock1和lock2。這兩個lock作為同步代碼塊的鎖；
（2）線程1的run()方法中同步代碼塊先獲取lock1的對象鎖，Thread.sleep(xxx)，時間不需要太多，50毫秒差不多了，然后接著獲取lock2的對象鎖。這么做主要是為了防止線程1啟動一下子就連續(xù)獲得了lock1和lock2兩個對象的對象鎖
（3）線程2的run)(方法中同步代碼塊先獲取lock2的對象鎖，接著獲取lock1的對象鎖，當(dāng)然這時lock1的對象鎖已經(jīng)被線程1鎖持有，線程2肯定是要等待線程1釋放lock1的對象鎖的
這樣，線程1"睡覺"睡完，線程2已經(jīng)獲取了lock2的對象鎖了，線程1此時嘗試獲取lock2的對象鎖，便被阻塞，此時一個死鎖就形成了。代碼就不寫了，占的篇幅有點(diǎn)多，Java多線程7：死鎖這篇文章里面有，就是上面步驟的代碼實(shí)現(xiàn)。
24、怎么喚醒一個阻塞的線程
如果線程是因?yàn)檎{(diào)用了wait()、sleep()或者join()方法而導(dǎo)致的阻塞，可以中斷線程，并且通過拋出InterruptedException來喚醒它；如果線程遇到了IO阻塞，無能為力，因?yàn)镮O是操作系統(tǒng)實(shí)現(xiàn)的，Java代碼并沒有辦法直接接觸到操作系統(tǒng)。
25、不可變對象對多線程有什么幫助
前面有提到過的一個問題，不可變對象保證了對象的內(nèi)存可見性，對不可變對象的讀取不需要進(jìn)行額外的同步手段，提升了代碼執(zhí)行效率。
26、什么是多線程的上下文切換
多線程的上下文切換是指CPU控制權(quán)由一個已經(jīng)正在運(yùn)行的線程切換到另外一個就緒并等待獲取CPU執(zhí)行權(quán)的線程的過程。
27、如果你提交任務(wù)時，線程池隊(duì)列已滿，這時會發(fā)生什么
這里區(qū)分一下：
如果使用的是無界隊(duì)列LinkedBlockingQueue，也就是無界隊(duì)列的話，沒關(guān)系，繼續(xù)添加任務(wù)到阻塞隊(duì)列中等待執(zhí)行，因?yàn)長inkedBlockingQueue可以近乎認(rèn)為是一個無窮大的隊(duì)列，可以無限存放任務(wù)
如果使用的是有界隊(duì)列比如ArrayBlockingQueue，任務(wù)首先會被添加到ArrayBlockingQueue中，ArrayBlockingQueue滿了，會根據(jù)maximumPoolSize的值增加線程數(shù)量，如果增加了線程數(shù)量還是處理不過來，ArrayBlockingQueue繼續(xù)滿，那么則會使用拒絕策略RejectedExecutionHandler處理滿了的任務(wù)，默認(rèn)是AbortPolicy
28、Java中用到的線程調(diào)度算法是什么
搶占式。一個線程用完CPU之后，操作系統(tǒng)會根據(jù)線程優(yōu)先級、線程饑餓情況等數(shù)據(jù)算出一個總的優(yōu)先級并分配下一個時間片給某個線程執(zhí)行。
29、Thread.sleep(0)的作用是什么
這個問題和上面那個問題是相關(guān)的，我就連在一起了。由于Java采用搶占式的線程調(diào)度算法，因此可能會出現(xiàn)某條線程常常獲取到CPU控制權(quán)的情況，為了讓某些優(yōu)先級比較低的線程也能獲取到CPU控制權(quán)，可以使用Thread.sleep(0)手動觸發(fā)一次操作系統(tǒng)分配時間片的操作，這也是平衡CPU控制權(quán)的一種操作。
30、什么是自旋
很多synchronized里面的代碼只是一些很簡單的代碼，執(zhí)行時間非?？?，此時等待的線程都加鎖可能是一種不太值得的操作，因?yàn)榫€程阻塞涉及到用戶態(tài)和內(nèi)核態(tài)切換的問題。既然synchronized里面的代碼執(zhí)行得非?？?，不妨讓等待鎖的線程不要被阻塞，而是在synchronized的邊界做忙循環(huán)，這就是自旋。如果做了多次忙循環(huán)發(fā)現(xiàn)還沒有獲得鎖，再阻塞，這樣可能是一種更好的策略。
31、什么是Java內(nèi)存模型
Java內(nèi)存模型定義了一種多線程訪問Java內(nèi)存的規(guī)范。Java內(nèi)存模型要完整講不是這里幾句話能說清楚的，我簡單總結(jié)一下Java內(nèi)存模型的幾部分內(nèi)容：
（1）Java內(nèi)存模型將內(nèi)存分為了主內(nèi)存和工作內(nèi)存。類的狀態(tài)，也就是類之間共享的變量，是存儲在主內(nèi)存中的，每次Java線程用到這些主內(nèi)存中的變量的時候，會讀一次主內(nèi)存中的變量，并讓這些內(nèi)存在自己的工作內(nèi)存中有一份拷貝，運(yùn)行自己線程代碼的時候，用到這些變量，操作的都是自己工作內(nèi)存中的那一份。在線程代碼執(zhí)行完畢之后，會將最新的值更新到主內(nèi)存中去
（2）定義了幾個原子操作，用于操作主內(nèi)存和工作內(nèi)存中的變量
（3）定義了volatile變量的使用規(guī)則
（4）happens-before，即先行發(fā)生原則，定義了操作A必然先行發(fā)生于操作B的一些規(guī)則，比如在同一個線程內(nèi)控制流前面的代碼一定先行發(fā)生于控制流后面的代碼、一個釋放鎖unlock的動作一定先行發(fā)生于后面對于同一個鎖進(jìn)行鎖定lock的動作等等，只要符合這些規(guī)則，則不需要額外做同步措施，如果某段代碼不符合所有的happens-before規(guī)則，則這段代碼一定是線程非安全的
32、什么是CAS
CAS，全稱為Compare and Swap，即比較-替換。假設(shè)有三個操作數(shù)：內(nèi)存值V、舊的預(yù)期值A(chǔ)、要修改的值B，當(dāng)且僅當(dāng)預(yù)期值A(chǔ)和內(nèi)存值V相同時，才會將內(nèi)存值修改為B并返回true，否則什么都不做并返回false。當(dāng)然CAS一定要volatile變量配合，這樣才能保證每次拿到的變量是主內(nèi)存中最新的那個值，否則舊的預(yù)期值A(chǔ)對某條線程來說，永遠(yuǎn)是一個不會變的值A(chǔ)，只要某次CAS操作失敗，永遠(yuǎn)都不可能成功。
33、什么是樂觀鎖和悲觀鎖
（1）樂觀鎖：就像它的名字一樣，對于并發(fā)間操作產(chǎn)生的線程安全問題持樂觀狀態(tài)，樂觀鎖認(rèn)為競爭不總是會發(fā)生，因此它不需要持有鎖，將比較-替換這兩個動作作為一個原子操作嘗試去修改內(nèi)存中的變量，如果失敗則表示發(fā)生沖突，那么就應(yīng)該有相應(yīng)的重試邏輯。
（2）悲觀鎖：還是像它的名字一樣，對于并發(fā)間操作產(chǎn)生的線程安全問題持悲觀狀態(tài)，悲觀鎖認(rèn)為競爭總是會發(fā)生，因此每次對某資源進(jìn)行操作時，都會持有一個獨(dú)占的鎖，就像synchronized，不管三七二十一，直接上了鎖就操作資源了。
34、什么是AQS
簡單說一下AQS，AQS全稱為AbstractQueuedSychronizer，翻譯過來應(yīng)該是抽象隊(duì)列同步器。
如果說java.util.concurrent的基礎(chǔ)是CAS的話，那么AQS就是整個Java并發(fā)包的核心了，ReentrantLock、CountDownLatch、Semaphore等等都用到了它。AQS實(shí)際上以雙向隊(duì)列的形式連接所有的Entry，比方說ReentrantLock，所有等待的線程都被放在一個Entry中并連成雙向隊(duì)列，前面一個線程使用ReentrantLock好了，則雙向隊(duì)列實(shí)際上的第一個Entry開始運(yùn)行。
AQS定義了對雙向隊(duì)列所有的操作，而只開放了tryLock和tryRelease方法給開發(fā)者使用，開發(fā)者可以根據(jù)自己的實(shí)現(xiàn)重寫tryLock和tryRelease方法，以實(shí)現(xiàn)自己的并發(fā)功能。
35、單例模式的線程安全性
老生常談的問題了，首先要說的是單例模式的線程安全意味著：某個類的實(shí)例在多線程環(huán)境下只會被創(chuàng)建一次出來。單例模式有很多種的寫法，我總結(jié)一下：
（1）餓漢式單例模式的寫法：線程安全
（2）懶漢式單例模式的寫法：非線程安全
（3）雙檢鎖單例模式的寫法：線程安全
36、Semaphore有什么作用
Semaphore就是一個信號量，它的作用是限制某段代碼塊的并發(fā)數(shù)。
Semaphore有一個構(gòu)造函數(shù)，可以傳入一個int型整數(shù)n，表示某段代碼最多只有n個線程可以訪問，如果超出了n，那么請等待，等到某個線程執(zhí)行完畢這段代碼塊，下一個線程再進(jìn)入。由此可以看出如果Semaphore構(gòu)造函數(shù)中傳入的int型整數(shù)n=1，相當(dāng)于變成了一個synchronized了。
37、Hashtable的size()方法中明明只有一條語句"return count"，為什么還要做同步？
這是我之前的一個困惑，不知道大家有沒有想過這個問題。某個方法中如果有多條語句，并且都在操作同一個類變量，那么在多線程環(huán)境下不加鎖，勢必會引發(fā)線程安全問題，這很好理解，但是size()方法明明只有一條語句，為什么還要加鎖？
關(guān)于這個問題，在慢慢地工作、學(xué)習(xí)中，有了理解，主要原因有兩點(diǎn)：
（1）同一時間只能有一條線程執(zhí)行固定類的同步方法，但是對于類的非同步方法，可以多條線程同時訪問。所以，這樣就有問題了，可能線程A在執(zhí)行Hashtable的put方法添加數(shù)據(jù)，線程B則可以正常調(diào)用size()方法讀取Hashtable中當(dāng)前元素的個數(shù)，那讀取到的值可能不是最新的，可能線程A添加了完了數(shù)據(jù)，但是沒有對size++，線程B就已經(jīng)讀取size了，那么對于線程B來說讀取到的size一定是不準(zhǔn)確的。而給size()方法加了同步之后，意味著線程B調(diào)用size()方法只有在線程A調(diào)用put方法完畢之后才可以調(diào)用，這樣就保證了線程安全性
（2）CPU執(zhí)行代碼，執(zhí)行的不是Java代碼，這點(diǎn)很關(guān)鍵，一定得記住。Java代碼最終是被翻譯成機(jī)器碼執(zhí)行的，機(jī)器碼才是真正可以和硬件電路交互的代碼。即使你看到Java代碼只有一行，甚至你看到Java代碼編譯之后生成的字節(jié)碼也只有一行，也不意味著對于底層來說這句語句的操作只有一個。一句"return count"假設(shè)被翻譯成了三句匯編語句執(zhí)行，一句匯編語句和其機(jī)器碼做對應(yīng)，完全可能執(zhí)行完第一句，線程就切換了。
38、線程類的構(gòu)造方法、靜態(tài)塊是被哪個線程調(diào)用的
這是一個非常刁鉆和狡猾的問題。請記?。壕€程類的構(gòu)造方法、靜態(tài)塊是被new這個線程類所在的線程所調(diào)用的，而run方法里面的代碼才是被線程自身所調(diào)用的。
如果說上面的說法讓你感到困惑，那么我舉個例子，假設(shè)Thread2中new了Thread1，main函數(shù)中new了Thread2，那么：
（1）Thread2的構(gòu)造方法、靜態(tài)塊是main線程調(diào)用的，Thread2的run()方法是Thread2自己調(diào)用的
（2）Thread1的構(gòu)造方法、靜態(tài)塊是Thread2調(diào)用的，Thread1的run()方法是Thread1自己調(diào)用的
39、同步方法和同步塊，哪個是更好的選擇
同步塊，這意味著同步塊之外的代碼是異步執(zhí)行的，這比同步整個方法更提升代碼的效率。請知道一條原則：同步的范圍越小越好。
借著這一條，我額外提一點(diǎn)，雖說同步的范圍越少越好，但是在Java虛擬機(jī)中還是存在著一種叫做鎖粗化的優(yōu)化方法，這種方法就是把同步范圍變大。這是有用的，比方說StringBuffer，它是一個線程安全的類，自然最常用的append()方法是一個同步方法，我們寫代碼的時候會反復(fù)append字符串，這意味著要進(jìn)行反復(fù)的加鎖->解鎖，這對性能不利，因?yàn)檫@意味著Java虛擬機(jī)在這條線程上要反復(fù)地在內(nèi)核態(tài)和用戶態(tài)之間進(jìn)行切換，因此Java虛擬機(jī)會將多次append方法調(diào)用的代碼進(jìn)行一個鎖粗化的操作，將多次的append的操作擴(kuò)展到append方法的頭尾，變成一個大的同步塊，這樣就減少了加鎖-->解鎖的次數(shù)，有效地提升了代碼執(zhí)行的效率。
40、高并發(fā)、任務(wù)執(zhí)行時間短的業(yè)務(wù)怎樣使用線程池？并發(fā)不高、任務(wù)執(zhí)行時間長的業(yè)務(wù)怎樣使用線程池？并發(fā)高、業(yè)務(wù)執(zhí)行時間長的業(yè)務(wù)怎樣使用線程池？
這是我在并發(fā)編程網(wǎng)上看到的一個問題，把這個問題放在最后一個，希望每個人都能看到并且思考一下，因?yàn)檫@個問題非常好、非常實(shí)際、非常專業(yè)。關(guān)于這個問題，個人看法是：
（1）高并發(fā)、任務(wù)執(zhí)行時間短的業(yè)務(wù)，線程池線程數(shù)可以設(shè)置為CPU核數(shù)+1，減少線程上下文的切換
（2）并發(fā)不高、任務(wù)執(zhí)行時間長的業(yè)務(wù)要區(qū)分開看：
a）假如是業(yè)務(wù)時間長集中在IO操作上，也就是IO密集型的任務(wù)，因?yàn)镮O操作并不占用CPU，所以不要讓所有的CPU閑下來，可以加大線程池中的線程數(shù)目，讓CPU處理更多的業(yè)務(wù)
b）假如是業(yè)務(wù)時間長集中在計(jì)算操作上，也就是計(jì)算密集型任務(wù)，這個就沒辦法了，和（1）一樣吧，線程池中的線程數(shù)設(shè)置得少一些，減少線程上下文的切換
（3）并發(fā)高、業(yè)務(wù)執(zhí)行時間長，解決這種類型任務(wù)的關(guān)鍵不在于線程池而在于整體架構(gòu)的設(shè)計(jì)，看看這些業(yè)務(wù)里面某些數(shù)據(jù)是否能做緩存是第一步，增加服務(wù)器是第二步，至于線程池的設(shè)置，設(shè)置參考（2）。
最后，業(yè)務(wù)執(zhí)行時間長的問題，也可能需要分析一下，看看能不能使用中間件對任務(wù)進(jìn)行拆分和解耦。
41、為什么使用Executor框架？
每次執(zhí)行任務(wù)創(chuàng)建線程 new Thread()比較消耗性能，創(chuàng)建一個線程是比較耗時、耗資源的。
調(diào)用 new Thread()創(chuàng)建的線程缺乏管理，被稱為野線程，而且可以無限制的創(chuàng)建，線程之間的相互競爭會導(dǎo)致過多占用系統(tǒng)資源而導(dǎo)致系統(tǒng)癱瘓，還有線程之間的頻繁交替也會消耗很多系統(tǒng)資源。
接使用new Thread() 啟動的線程不利于擴(kuò)展，比如定時執(zhí)行、定期執(zhí)行、定時定期執(zhí)行、線程中斷等都不便實(shí)現(xiàn)。
42、在Java中Executor和Executors的區(qū)別？
Executors 工具類的不同方法按照我們的需求創(chuàng)建了不同的線程池，來滿足業(yè)務(wù)的需求。
Executor 接口對象能執(zhí)行我們的線程任務(wù)。ExecutorService接口繼承了Executor接口并進(jìn)行了擴(kuò)展，提供了更多的方法我們能獲得任務(wù)執(zhí)行的狀態(tài)并且可以獲取任務(wù)的返回值。
使用ThreadPoolExecutor 可以創(chuàng)建自定義線程池。Future 表示異步計(jì)算的結(jié)果，他提供了檢查計(jì)算是否完成的方法，以等待計(jì)算的完成，并可以使用get()方法獲取計(jì)算的結(jié)果。
43、什么是原子操作？在Java Concurrency API中有哪些原子類(atomic classes)？
原子操作（atomic operation）意為”不可被中斷的一個或一系列操作” 。處理器使用基于對緩存加鎖或總線加鎖的方式來實(shí)現(xiàn)多處理器之間的原子操作。
在Java中可以通過鎖和循環(huán)CAS的方式來實(shí)現(xiàn)原子操作。CAS操作——Compare & Set，或是 Compare & Swap，現(xiàn)在幾乎所有的CPU指令都支持CAS的原子操作。
原子操作是指一個不受其他操作影響的操作任務(wù)單元。原子操作是在多線程環(huán)境下避免數(shù)據(jù)不一致必須的手段。
int++并不是一個原子操作，所以當(dāng)一個線程讀取它的值并加1時，另外一個線程有可能會讀到之前的值，這就會引發(fā)錯誤。
為了解決這個問題，必須保證增加操作是原子的，在JDK1.5之前我們可以使用同步技術(shù)來做到這一點(diǎn)。到JDK1.5，java.util.concurrent.atomic包提供了int和long類型的原子包裝類，它們可以自動的保證對于他們的操作是原子的并且不需要使用同步。
java.util.concurrent這個包里面提供了一組原子類。其基本的特性就是在多線程環(huán)境下，當(dāng)有多個線程同時執(zhí)行這些類的實(shí)例包含的方法時，具有排他性。
即當(dāng)某個線程進(jìn)入方法，執(zhí)行其中的指令時，不會被其他線程打斷，而別的線程就像自旋鎖一樣，一直等到該方法執(zhí)行完成，才由JVM從等待隊(duì)列中選擇一個另一個線程進(jìn)入，這只是一種邏輯上的理解。
原子類：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
原子數(shù)組：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
原子屬性更新器：AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
解決ABA問題的原子類：AtomicMarkableReference（通過引入一個boolean來反映中間有沒有變過），AtomicStampedReference（通過引入一個int來累加來反映中間有沒有變過）
44、Java Concurrency API中的Lock接口(Lock interface)是什么？對比同步它有什么優(yōu)勢？
Lock接口比同步方法和同步塊提供了更具擴(kuò)展性的鎖操作。他們允許更靈活的結(jié)構(gòu)，可以具有完全不同的性質(zhì)，并且可以支持多個相關(guān)類的條件對象。
它的優(yōu)勢有：
可以使鎖更公平
可以讓線程嘗試獲取鎖，并在無法獲取鎖的時候立即返回或者等待一段時間
可以在不同的范圍，以不同的順序獲取和釋放鎖
整體上來說Lock是synchronized的擴(kuò)展版，Lock提供了無條件的、可輪詢的(tryLock方法)、定時的(tryLock帶參方法)、可中斷的(lockInterruptibly)、可多條件隊(duì)列的(newCondition方法)鎖操作。
另外Lock的實(shí)現(xiàn)類基本都支持非公平鎖(默認(rèn))和公平鎖，synchronized只支持非公平鎖，當(dāng)然，在大部分情況下，非公平鎖是高效的選擇。
45、什么是Executors框架？
Executor框架是一個根據(jù)一組執(zhí)行策略調(diào)用，調(diào)度，執(zhí)行和控制的異步任務(wù)的框架。
無限制的創(chuàng)建線程會引起應(yīng)用程序內(nèi)存溢出。所以創(chuàng)建一個線程池是個更好的的解決方案，因?yàn)榭梢韵拗凭€程的數(shù)量并且可以回收再利用這些線程。利用Executors框架可以非常方便的創(chuàng)建一個線程池。
46、什么是阻塞隊(duì)列？阻塞隊(duì)列的實(shí)現(xiàn)原理是什么？如何使用阻塞隊(duì)列來實(shí)現(xiàn)生產(chǎn)者-消費(fèi)者模型？
阻塞隊(duì)列（BlockingQueue）是一個支持兩個附加操作的隊(duì)列。
這兩個附加的操作是：在隊(duì)列為空時，獲取元素的線程會等待隊(duì)列變?yōu)榉强?。?dāng)隊(duì)列滿時，存儲元素的線程會等待隊(duì)列可用。
阻塞隊(duì)列常用于生產(chǎn)者和消費(fèi)者的場景，生產(chǎn)者是往隊(duì)列里添加元素的線程，消費(fèi)者是從隊(duì)列里拿元素的線程。阻塞隊(duì)列就是生產(chǎn)者存放元素的容器，而消費(fèi)者也只從容器里拿元素。
JDK7提供了7個阻塞隊(duì)列。分別是：
ArrayBlockingQueue ：一個由數(shù)組結(jié)構(gòu)組成的有界阻塞隊(duì)列。
LinkedBlockingQueue ：一個由鏈表結(jié)構(gòu)組成的有界阻塞隊(duì)列。
PriorityBlockingQueue ：一個支持優(yōu)先級排序的無界阻塞隊(duì)列。
DelayQueue：一個使用優(yōu)先級隊(duì)列實(shí)現(xiàn)的無界阻塞隊(duì)列。
SynchronousQueue：一個不存儲元素的阻塞隊(duì)列。
LinkedTransferQueue：一個由鏈表結(jié)構(gòu)組成的無界阻塞隊(duì)列。
LinkedBlockingDeque：一個由鏈表結(jié)構(gòu)組成的雙向阻塞隊(duì)列。
Java 5之前實(shí)現(xiàn)同步存取時，可以使用普通的一個集合，然后在使用線程的協(xié)作和線程同步可以實(shí)現(xiàn)生產(chǎn)者，消費(fèi)者模式，主要的技術(shù)就是用好，wait ,notify,notifyAll,sychronized這些關(guān)鍵字。而在java 5之后，可以使用阻塞隊(duì)列來實(shí)現(xiàn)，此方式大大簡少了代碼量，使得多線程編程更加容易，安全方面也有保障。
BlockingQueue接口是Queue的子接口，它的主要用途并不是作為容器，而是作為線程同步的的工具，因此他具有一個很明顯的特性，當(dāng)生產(chǎn)者線程試圖向BlockingQueue放入元素時，如果隊(duì)列已滿，則線程被阻塞，當(dāng)消費(fèi)者線程試圖從中取出一個元素時，如果隊(duì)列為空，則該線程會被阻塞，正是因?yàn)樗哂羞@個特性，所以在程序中多個線程交替向BlockingQueue中放入元素，取出元素，它可以很好的控制線程之間的通信。
阻塞隊(duì)列使用最經(jīng)典的場景就是socket客戶端數(shù)據(jù)的讀取和解析，讀取數(shù)據(jù)的線程不斷將數(shù)據(jù)放入隊(duì)列，然后解析線程不斷從隊(duì)列取數(shù)據(jù)解析。
47、什么是Callable和Future?
Callable接口類似于Runnable，從名字就可以看出來了，但是Runnable不會返回結(jié)果，并且無法拋出返回結(jié)果的異常，而Callable功能更強(qiáng)大一些，被線程執(zhí)行后，可以返回值，這個返回值可以被Future拿到，也就是說，F(xiàn)uture可以拿到異步執(zhí)行任務(wù)的返回值?？梢哉J(rèn)為是帶有回調(diào)的Runnable。
Future接口表示異步任務(wù)，是還沒有完成的任務(wù)給出的未來結(jié)果。所以說Callable用于產(chǎn)生結(jié)果，F(xiàn)uture用于獲取結(jié)果。
48、什么是FutureTask?使用ExecutorService啟動任務(wù)。
在Java并發(fā)程序中FutureTask表示一個可以取消的異步運(yùn)算。它有啟動和取消運(yùn)算、查詢運(yùn)算是否完成和取回運(yùn)算結(jié)果等方法。只有當(dāng)運(yùn)算完成的時候結(jié)果才能取回，如果運(yùn)算尚未完成get方法將會阻塞。
一個FutureTask對象可以對調(diào)用了Callable和Runnable的對象進(jìn)行包裝，由于FutureTask也是調(diào)用了Runnable接口所以它可以提交給Executor來執(zhí)行。
49、什么是并發(fā)容器的實(shí)現(xiàn)？
何為同步容器：可以簡單地理解為通過synchronized來實(shí)現(xiàn)同步的容器，如果有多個線程調(diào)用同步容器的方法，它們將會串行執(zhí)行。比如Vector，Hashtable，以及Collections.synchronizedSet，synchronizedList等方法返回的容器。
可以通過查看Vector，Hashtable等這些同步容器的實(shí)現(xiàn)代碼，可以看到這些容器實(shí)現(xiàn)線程安全的方式就是將它們的狀態(tài)封裝起來，并在需要同步的方法上加上關(guān)鍵字synchronized。
并發(fā)容器使用了與同步容器完全不同的加鎖策略來提供更高的并發(fā)性和伸縮性，例如在ConcurrentHashMap中采用了一種粒度更細(xì)的加鎖機(jī)制，可以稱為分段鎖，在這種鎖機(jī)制下，允許任意數(shù)量的讀線程并發(fā)地訪問map，并且執(zhí)行讀操作的線程和寫操作的線程也可以并發(fā)的訪問map，同時允許一定數(shù)量的寫操作線程并發(fā)地修改map，所以它可以在并發(fā)環(huán)境下實(shí)現(xiàn)更高的吞吐量。
50、多線程同步和互斥有幾種實(shí)現(xiàn)方法，都是什么？
線程同步是指線程之間所具有的一種制約關(guān)系，一個線程的執(zhí)行依賴另一個線程的消息，當(dāng)它沒有得到另一個線程的消息時應(yīng)等待，直到消息到達(dá)時才被喚醒。
線程互斥是指對于共享的進(jìn)程系統(tǒng)資源，在各單個線程訪問時的排它性。當(dāng)有若干個線程都要使用某一共享資源時，任何時刻最多只允許一個線程去使用，其它要使用該資源的線程必須等待，直到占用資源者釋放該資源。線程互斥可以看成是一種特殊的線程同步。
線程間的同步方法大體可分為兩類：用戶模式和內(nèi)核模式。顧名思義，內(nèi)核模式就是指利用系統(tǒng)內(nèi)核對象的單一性來進(jìn)行同步，使用時需要切換內(nèi)核態(tài)與用戶態(tài)，而用戶模式就是不需要切換到內(nèi)核態(tài)，只在用戶態(tài)完成操作。
用戶模式下的方法有：原子操作（例如一個單一的全局變量），臨界區(qū)。內(nèi)核模式下的方法有：事件，信號量，互斥量。
51、什么是競爭條件？你怎樣發(fā)現(xiàn)和解決競爭？
當(dāng)多個進(jìn)程都企圖對共享數(shù)據(jù)進(jìn)行某種處理，而最后的結(jié)果又取決于進(jìn)程運(yùn)行的順序時，則我們認(rèn)為這發(fā)生了競爭條件（race condition）。
52、為什么我們調(diào)用start()方法時會執(zhí)行run()方法，為什么我們不能直接調(diào)用run()方法？
當(dāng)你調(diào)用start()方法時你將創(chuàng)建新的線程，并且執(zhí)行在run()方法里的代碼。
但是如果你直接調(diào)用run()方法，它不會創(chuàng)建新的線程也不會執(zhí)行調(diào)用線程的代碼，只會把run方法當(dāng)作普通方法去執(zhí)行。
53、Java中你怎樣喚醒一個阻塞的線程？
在Java發(fā)展史上曾經(jīng)使用suspend()、resume()方法對于線程進(jìn)行阻塞喚醒，但隨之出現(xiàn)很多問題，比較典型的還是死鎖問題。
解決方案可以使用以對象為目標(biāo)的阻塞，即利用Object類的wait()和notify()方法實(shí)現(xiàn)線程阻塞。
首先，wait、notify方法是針對對象的，調(diào)用任意對象的wait()方法都將導(dǎo)致線程阻塞，阻塞的同時也將釋放該對象的鎖，相應(yīng)地，調(diào)用任意對象的notify()方法則將隨機(jī)解除該對象阻塞的線程，但它需要重新獲取改對象的鎖，直到獲取成功才能往下執(zhí)行；
其次，wait、notify方法必須在synchronized塊或方法中被調(diào)用，并且要保證同步塊或方法的鎖對象與調(diào)用wait、notify方法的對象是同一個，如此一來在調(diào)用wait之前當(dāng)前線程就已經(jīng)成功獲取某對象的鎖，執(zhí)行wait阻塞后當(dāng)前線程就將之前獲取的對象鎖釋放。
54、在Java中CycliBarriar和CountdownLatch有什么區(qū)別？
CyclicBarrier可以重復(fù)使用，而CountdownLatch不能重復(fù)使用。
Java的concurrent包里面的CountDownLatch其實(shí)可以把它看作一個計(jì)數(shù)器，只不過這個計(jì)數(shù)器的操作是原子操作，同時只能有一個線程去操作這個計(jì)數(shù)器，也就是同時只能有一個線程去減這個計(jì)數(shù)器里面的值。
你可以向CountDownLatch對象設(shè)置一個初始的數(shù)字作為計(jì)數(shù)值，任何調(diào)用這個對象上的await()方法都會阻塞，直到這個計(jì)數(shù)器的計(jì)數(shù)值被其他的線程減為0為止。
所以在當(dāng)前計(jì)數(shù)到達(dá)零之前，await 方法會一直受阻塞。之后，會釋放所有等待的線程，await的所有后續(xù)調(diào)用都將立即返回。這種現(xiàn)象只出現(xiàn)一次——計(jì)數(shù)無法被重置。如果需要重置計(jì)數(shù)，請考慮使用 CyclicBarrier。
CountDownLatch的一個非常典型的應(yīng)用場景是：有一個任務(wù)想要往下執(zhí)行，但必須要等到其他的任務(wù)執(zhí)行完畢后才可以繼續(xù)往下執(zhí)行。假如我們這個想要繼續(xù)往下執(zhí)行的任務(wù)調(diào)用一個CountDownLatch對象的await()方法，其他的任務(wù)執(zhí)行完自己的任務(wù)后調(diào)用同一個CountDownLatch對象上的countDown()方法，這個調(diào)用await()方法的任務(wù)將一直阻塞等待，直到這個CountDownLatch對象的計(jì)數(shù)值減到0為止。
CyclicBarrier一個同步輔助類，它允許一組線程互相等待，直到到達(dá)某個公共屏障點(diǎn) (common barrier point)。在涉及一組固定大小的線程的程序中，這些線程必須不時地互相等待，此時 CyclicBarrier 很有用。因?yàn)樵?barrier 在釋放等待線程后可以重用，所以稱它為循環(huán) 的 barrier。
55、什么是不可變對象，它對寫并發(fā)應(yīng)用有什么幫助？
不可變對象(Immutable Objects)即對象一旦被創(chuàng)建它的狀態(tài)（對象的數(shù)據(jù)，也即對象屬性值）就不能改變，反之即為可變對象(Mutable Objects)。
不可變對象的類即為不可變類(Immutable Class)。Java平臺類庫中包含許多不可變類，如String、基本類型的包裝類、BigInteger和BigDecimal等。
不可變對象天生是線程安全的。它們的常量（域）是在構(gòu)造函數(shù)中創(chuàng)建的。既然它們的狀態(tài)無法修改，這些常量永遠(yuǎn)不會變。
不可變對象永遠(yuǎn)是線程安全的。只有滿足如下狀態(tài)，一個對象才是不可變的；它的狀態(tài)不能在創(chuàng)建后再被修改；所有域都是final類型；并且， 它被正確創(chuàng)建（創(chuàng)建期間沒有發(fā)生this引用的逸出）。
56、什么是多線程中的上下文切換？
在上下文切換過程中，CPU會停止處理當(dāng)前運(yùn)行的程序，并保存當(dāng)前程序運(yùn)行的具體位置以便之后繼續(xù)運(yùn)行。從這個角度來看，上下文切換有點(diǎn)像我們同時閱讀幾本書，在來回切換書本的同時我們需要記住每本書當(dāng)前讀到的頁碼。
在程序中，上下文切換過程中的“頁碼”信息是保存在進(jìn)程控制塊（PCB）中的。PCB還經(jīng)常被稱作“切換楨”（switchframe）?！绊摯a”信息會一直保存到CPU的內(nèi)存中，直到他們被再次使用。
上下文切換是存儲和恢復(fù)CPU狀態(tài)的過程，它使得線程執(zhí)行能夠從中斷點(diǎn)恢復(fù)執(zhí)行。上下文切換是多任務(wù)操作系統(tǒng)和多線程環(huán)境的基本特征。
57、Java中用到的線程調(diào)度算法是什么？
計(jì)算機(jī)通常只有一個CPU,在任意時刻只能執(zhí)行一條機(jī)器指令,每個線程只有獲得CPU的使用權(quán)才能執(zhí)行指令.所謂多線程的并發(fā)運(yùn)行,其實(shí)是指從宏觀上看,各個線程輪流獲得CPU的使用權(quán),分別執(zhí)行各自的任務(wù)。
在運(yùn)行池中,會有多個處于就緒狀態(tài)的線程在等待CPU,JAVA虛擬機(jī)的一項(xiàng)任務(wù)就是負(fù)責(zé)線程的調(diào)度,線程調(diào)度是指按照特定機(jī)制為多個線程分配CPU的使用權(quán).
有兩種調(diào)度模型：分時調(diào)度模型和搶占式調(diào)度模型。分時調(diào)度模型是指讓所有的線程輪流獲得cpu的使用權(quán),并且平均分配每個線程占用的CPU的時間片這個也比較好理解。
java虛擬機(jī)采用搶占式調(diào)度模型，是指優(yōu)先讓可運(yùn)行池中優(yōu)先級高的線程占用CPU，如果可運(yùn)行池中的線程優(yōu)先級相同，那么就隨機(jī)選擇一個線程，使其占用CPU。處于運(yùn)行狀態(tài)的線程會一直運(yùn)行，直至它不得不放棄CPU。
58、什么是線程組，為什么在Java中不推薦使用？
線程組和線程池是兩個不同的概念，他們的作用完全不同，前者是為了方便線程的管理，后者是為了管理線程的生命周期，復(fù)用線程，減少創(chuàng)建銷毀線程的開銷。
59、為什么使用Executor框架比使用應(yīng)用創(chuàng)建和管理線程好？
為什么要使用Executor線程池框架 ？
1、每次執(zhí)行任務(wù)創(chuàng)建線程 new Thread()比較消耗性能，創(chuàng)建一個線程是比較耗時、耗資源的。
2、調(diào)用 new Thread()創(chuàng)建的線程缺乏管理，被稱為野線程，而且可以無限制的創(chuàng)建，線程之間的相互競爭會導(dǎo)致過多占用系統(tǒng)資源而導(dǎo)致系統(tǒng)癱瘓，還有線程之間的頻繁交替也會消耗很多系統(tǒng)資源。
3、直接使用new Thread() 啟動的線程不利于擴(kuò)展，比如定時執(zhí)行、定期執(zhí)行、定時定期執(zhí)行、線程中斷等都不便實(shí)現(xiàn)。
使用Executor線程池框架的優(yōu)點(diǎn) ：
1、能復(fù)用已存在并空閑的線程從而減少線程對象的創(chuàng)建從而減少了消亡線程的開銷。
2、可有效控制最大并發(fā)線程數(shù)，提高系統(tǒng)資源使用率，同時避免過多資源競爭。
3、框架中已經(jīng)有定時、定期、單線程、并發(fā)數(shù)控制等功能。綜上所述使用線程池框架Executor能更好的管理線程、提供系統(tǒng)資源使用率。
60、java中有幾種方法可以實(shí)現(xiàn)一個線程？
繼承 Thread 類
實(shí)現(xiàn) Runnable 接口
Callable接口和FutureTask類，需要實(shí)現(xiàn)的是 call() 方法
線程池創(chuàng)建線程。
61、如何停止一個正在運(yùn)行的線程？
1. 使用共享變量的方式
在這種方式中，之所以引入共享變量，是因?yàn)樵撟兞靠梢员欢鄠€執(zhí)行相同任務(wù)的線程用來作為是否中斷的信號，通知中斷線程的執(zhí)行。
2. 使用interrupt方法終止線程
如果一個線程由于等待某些事件的發(fā)生而被阻塞，又該怎樣停止該線程呢？這種情況經(jīng)常會發(fā)生，比如當(dāng)一個線程由于需要等候鍵盤輸入而被阻塞，或者調(diào)用Thread.join()方法，或者Thread.sleep()方法，在網(wǎng)絡(luò)中調(diào)用ServerSocket.accept()方法，或者調(diào)用了DatagramSocket.receive()方法時，都有可能導(dǎo)致線程阻塞，使線程處于處于不可運(yùn)行狀態(tài)時，即使主程序中將該線程的共享變量設(shè)置為true，但該線程此時根本無法檢查循環(huán)標(biāo)志，當(dāng)然也就無法立即中斷。
這里我們給出的建議是，不要使用stop()方法，而是使用Thread提供的interrupt()方法，因?yàn)樵摲椒m然不會中斷一個正在運(yùn)行的線程，但是它可以使一個被阻塞的線程拋出一個中斷異常，從而使線程提前結(jié)束阻塞狀態(tài)，退出堵塞代碼。
62、notify()和notifyAll()有什么區(qū)別？
當(dāng)一個線程進(jìn)入wait之后，就必須等其他線程notify/notifyall,使用notifyall,可以喚醒所有處于wait狀態(tài)的線程，使其重新進(jìn)入鎖的爭奪隊(duì)列中，而notify只能喚醒一個。
如果沒把握，建議notifyAll，防止notigy因?yàn)樾盘杹G失而造成程序異常。
63、什么是Daemon線程？它有什么意義？
所謂后臺(daemon)線程，是指在程序運(yùn)行的時候在后臺提供一種通用服務(wù)的線程，并且這個線程并不屬于程序中不可或缺的部分。
因此，當(dāng)所有的非后臺線程結(jié)束時，程序也就終止了，同時會殺死進(jìn)程中的所有后臺線程。反過來說， 只要有任何非后臺線程還在運(yùn)行，程序就不會終止。
必須在線程啟動之前調(diào)用setDaemon()方法，才能把它設(shè)置為后臺線程。注意：后臺進(jìn)程在不執(zhí)行finally子句的情況下就會終止其run()方法。
比如：JVM的垃圾回收線程就是Daemon線程，F(xiàn)inalizer也是守護(hù)線程。
64、java如何實(shí)現(xiàn)多線程之間的通訊和協(xié)作？
中斷 和 共享變量
65、什么是可重入鎖（ReentrantLock）？
舉例來說明鎖的可重入性
public class UnReentrant{
Lock lock = new Lock();
public void outer(){
lock.lock();
inner();
lock.unlock();
}
public void inner(){
lock.lock();
//do something
lock.unlock();
}
}
outer中調(diào)用了inner，outer先鎖住了lock，這樣inner就不能再獲取lock。其實(shí)調(diào)用outer的線程已經(jīng)獲取了lock鎖，但是不能在inner中重復(fù)利用已經(jīng)獲取的鎖資源，這種鎖即稱之為 不可重入可重入就意味著：線程可以進(jìn)入任何一個它已經(jīng)擁有的鎖所同步著的代碼塊。
synchronized、ReentrantLock都是可重入的鎖，可重入鎖相對來說簡化了并發(fā)編程的開發(fā)。
66、當(dāng)一個線程進(jìn)入某個對象的一個synchronized的實(shí)例方法后，其它線程是否可進(jìn)入此對象的其它方法？
如果其他方法沒有synchronized的話，其他線程是可以進(jìn)入的。
所以要開放一個線程安全的對象時，得保證每個方法都是線程安全的。
67、樂觀鎖和悲觀鎖的理解及如何實(shí)現(xiàn)，有哪些實(shí)現(xiàn)方式？
悲觀鎖：總是假設(shè)最壞的情況，每次去拿數(shù)據(jù)的時候都認(rèn)為別人會修改，所以每次在拿數(shù)據(jù)的時候都會上鎖，這樣別人想拿這個數(shù)據(jù)就會阻塞直到它拿到鎖。
傳統(tǒng)的關(guān)系型數(shù)據(jù)庫里邊就用到了很多這種鎖機(jī)制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。再比如Java里面的同步原語synchronized關(guān)鍵字的實(shí)現(xiàn)也是悲觀鎖。
樂觀鎖：顧名思義，就是很樂觀，每次去拿數(shù)據(jù)的時候都認(rèn)為別人不會修改，所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個數(shù)據(jù)，可以使用版本號等機(jī)制。
樂觀鎖適用于多讀的應(yīng)用類型，這樣可以提高吞吐量，像數(shù)據(jù)庫提供的類似于write_condition機(jī)制，其實(shí)都是提供的樂觀鎖。
在Java中java.util.concurrent.atomic包下面的原子變量類就是使用了樂觀鎖的一種實(shí)現(xiàn)方式CAS實(shí)現(xiàn)的。
樂觀鎖的實(shí)現(xiàn)方式：
1、使用版本標(biāo)識來確定讀到的數(shù)據(jù)與提交時的數(shù)據(jù)是否一致。提交后修改版本標(biāo)識，不一致時可以采取丟棄和再次嘗試的策略。
2、java中的Compare and Swap即CAS ，當(dāng)多個線程嘗試使用CAS同時更新同一個變量時，只有其中一個線程能更新變量的值，而其它線程都失敗，失敗的線程并不會被掛起，而是被告知這次競爭中失敗，并可以再次嘗試。 CAS 操作中包含三個操作數(shù) —— 需要讀寫的內(nèi)存位置（V）、進(jìn)行比較的預(yù)期原值（A）和擬寫入的新值(B)。如果內(nèi)存位置V的值與預(yù)期原值A(chǔ)相匹配，那么處理器會自動將該位置值更新為新值B。否則處理器不做任何操作。
CAS缺點(diǎn)：
ABA問題：比如說一個線程one從內(nèi)存位置V中取出A，這時候另一個線程two也從內(nèi)存中取出A，并且two進(jìn)行了一些操作變成了B，然后two又將V位置的數(shù)據(jù)變成A，這時候線程one進(jìn)行CAS操作發(fā)現(xiàn)內(nèi)存中仍然是A，然后one操作成功。盡管線程one的CAS操作成功，但可能存在潛藏的問題。從Java1.5開始JDK的atomic包里提供了一個類AtomicStampedReference來解決ABA問題。
循環(huán)時間長開銷大：對于資源競爭嚴(yán)重（線程沖突嚴(yán)重）的情況，CAS自旋的概率會比較大，從而浪費(fèi)更多的CPU資源，效率低于synchronized。
只能保證一個共享變量的原子操作：當(dāng)對一個共享變量執(zhí)行操作時，我們可以使用循環(huán)CAS的方式來保證原子操作，但是對多個共享變量操作時，循環(huán)CAS就無法保證操作的原子性，這個時候就可以用鎖。
68、SynchronizedMap和ConcurrentHashMap有什么區(qū)別？
SynchronizedMap一次鎖住整張表來保證線程安全，所以每次只能有一個線程來訪為map。ConcurrentHashMap使用分段鎖來保證在多線程下的性能。
ConcurrentHashMap中則是一次鎖住一個桶。ConcurrentHashMap默認(rèn)將hash表分為16個桶，諸如get,put,remove等常用操作只鎖當(dāng)前需要用到的桶。這樣，原來只能一個線程進(jìn)入，現(xiàn)在卻能同時有16個寫線程執(zhí)行，并發(fā)性能的提升是顯而易見的。
另外ConcurrentHashMap使用了一種不同的迭代方式。在這種迭代方式中，當(dāng)iterator被創(chuàng)建后集合再發(fā)生改變就不再是拋出
ConcurrentModificationException，取而代之的是在改變時new新的數(shù)據(jù)從而不影響原有的數(shù)據(jù) ，iterator完成后再將頭指針替換為新的數(shù)據(jù) ，這樣iterator線程可以使用原來老的數(shù)據(jù)，而寫線程也可以并發(fā)的完成改變。
69、CopyOnWriteArrayList可以用于什么應(yīng)用場景？
CopyOnWriteArrayList(免鎖容器)的好處之一是當(dāng)多個迭代器同時遍歷和修改這個列表時，不會拋出ConcurrentModificationException。在CopyOnWriteArrayList中，寫入將導(dǎo)致創(chuàng)建整個底層數(shù)組的副本，而源數(shù)組將保留在原地，使得復(fù)制的數(shù)組在被修改時，讀取操作可以安全地執(zhí)行。
1、由于寫操作的時候，需要拷貝數(shù)組，會消耗內(nèi)存，如果原數(shù)組的內(nèi)容比較多的情況下，可能導(dǎo)致young gc或者full gc；
2、不能用于實(shí)時讀的場景，像拷貝數(shù)組、新增元素都需要時間，所以調(diào)用一個set操作后，讀取到數(shù)據(jù)可能還是舊的,雖然CopyOnWriteArrayList 能做到最終一致性,但是還是沒法滿足實(shí)時性要求；
CopyOnWriteArrayList透露的思想
1、讀寫分離，讀和寫分開
2、最終一致性
3、使用另外開辟空間的思路，來解決并發(fā)沖突
70、什么叫線程安全？servlet是線程安全嗎?
線程安全是編程中的術(shù)語，指某個函數(shù)、函數(shù)庫在多線程環(huán)境中被調(diào)用時，能夠正確地處理多個線程之間的共享變量，使程序功能正確完成。
Servlet不是線程安全的，servlet是單實(shí)例多線程的，當(dāng)多個線程同時訪問同一個方法，是不能保證共享變量的線程安全性的。
Struts2的action是多實(shí)例多線程的，是線程安全的，每個請求過來都會new一個新的action分配給這個請求，請求完成后銷毀。
SpringMVC的Controller是線程安全的嗎？不是的，和Servlet類似的處理流程。
Struts2好處是不用考慮線程安全問題；Servlet和SpringMVC需要考慮線程安全問題，但是性能可以提升不用處理太多的gc，可以使用ThreadLocal來處理多線程的問題。
71、volatile有什么用？能否用一句話說明下volatile的應(yīng)用場景？
volatile保證內(nèi)存可見性和禁止指令重排。
volatile用于多線程環(huán)境下的單次操作(單次讀或者單次寫)。
72、為什么代碼會重排序？
在執(zhí)行程序時，為了提供性能，處理器和編譯器常常會對指令進(jìn)行重排序，但是不能隨意重排序，不是你想怎么排序就怎么排序，它需要滿足以下兩個條件：
在單線程環(huán)境下不能改變程序運(yùn)行的結(jié)果；存在數(shù)據(jù)依賴關(guān)系的不允許重排序需要注意的是：重排序不會影響單線程環(huán)境的執(zhí)行結(jié)果，但是會破壞多線程的執(zhí)行語義。
73、在java中wait和sleep方法的不同？
最大的不同是在等待時wait會釋放鎖，而sleep一直持有鎖。Wait通常被用于線程間交互，sleep通常被用于暫停執(zhí)行。
直接了解的深入一點(diǎn)吧， 在Java中線程的狀態(tài)一共被分成6種：
（1）初始態(tài)：NEW
創(chuàng)建一個Thread對象，但還未調(diào)用start()啟動線程時，線程處于初始態(tài)。
（2）運(yùn)行態(tài)：RUNNABLE
在Java中，運(yùn)行態(tài)包括就緒態(tài) 和 運(yùn)行態(tài)。就緒態(tài) 該狀態(tài)下的線程已經(jīng)獲得執(zhí)行所需的所有資源，只要CPU分配執(zhí)行權(quán)就能運(yùn)行。所有就緒態(tài)的線程存放在就緒隊(duì)列中。
運(yùn)行態(tài) 獲得CPU執(zhí)行權(quán)，正在執(zhí)行的線程。由于一個CPU同一時刻只能執(zhí)行一條線程，因此每個CPU每個時刻只有一條運(yùn)行態(tài)的線程。
（3）阻塞態(tài)
當(dāng)一條正在執(zhí)行的線程請求某一資源失敗時，就會進(jìn)入阻塞態(tài)。而在Java中，阻塞態(tài)專指請求鎖失敗時進(jìn)入的狀態(tài)。由一個阻塞隊(duì)列存放所有阻塞態(tài)的線程。處于阻塞態(tài)的線程會不斷請求資源，一旦請求成功，就會進(jìn)入就緒隊(duì)列，等待執(zhí)行。PS：鎖、IO、Socket等都資源。
（4）等待態(tài)
當(dāng)前線程中調(diào)用wait、join、park函數(shù)時，當(dāng)前線程就會進(jìn)入等待態(tài)。也有一個等待隊(duì)列存放所有等待態(tài)的線程。線程處于等待態(tài)表示它需要等待其他線程的指示才能繼續(xù)運(yùn)行。進(jìn)入等待態(tài)的線程會釋放CPU執(zhí)行權(quán)，并釋放資源（如：鎖）
（5）超時等待態(tài)
當(dāng)運(yùn)行中的線程調(diào)用sleep(time)、wait、join、parkNanos、parkUntil時，就會進(jìn)入該狀態(tài)；它和等待態(tài)一樣，并不是因?yàn)檎埱蟛坏劫Y源，而是主動進(jìn)入，并且進(jìn)入后需要其他線程喚醒；進(jìn)入該狀態(tài)后釋放CPU執(zhí)行權(quán) 和 占有的資源。與等待態(tài)的區(qū)別：到了超時時間后自動進(jìn)入阻塞隊(duì)列，開始競爭鎖。
（6）終止態(tài)
線程執(zhí)行結(jié)束后的狀態(tài)。
注意：
wait()方法會釋放CPU執(zhí)行權(quán) 和 占有的鎖。
sleep(long)方法僅釋放CPU使用權(quán)，鎖仍然占用；線程被放入超時等待隊(duì)列，與yield相比，它會使線程較長時間得不到運(yùn)行。
yield()方法僅釋放CPU執(zhí)行權(quán)，鎖仍然占用，線程會被放入就緒隊(duì)列，會在短時間內(nèi)再次執(zhí)行。
wait和notify必須配套使用，即必須使用同一把鎖調(diào)用；
wait和notify必須放在一個同步塊中調(diào)用wait和notify的對象必須是他們所處同步塊的鎖對象。
74、為什么wait和notify方法要在同步塊中調(diào)用？
Java API強(qiáng)制要求這樣做，如果你不這么做，你的代碼會拋出IllegalMonitorStateException異常。還有一個原因是為了避免wait和notify之間產(chǎn)生競態(tài)條件。
75、為什么你應(yīng)該在循環(huán)中檢查等待條件?
處于等待狀態(tài)的線程可能會收到錯誤警報和偽喚醒，如果不在循環(huán)中檢查等待條件，程序就會在沒有滿足結(jié)束條件的情況下退出。
76、Java中的同步集合與并發(fā)集合有什么區(qū)別？
同步集合與并發(fā)集合都為多線程和并發(fā)提供了合適的線程安全的集合，不過并發(fā)集合的可擴(kuò)展性更高。在Java1.5之前程序員們只有同步集合來用且在多線程并發(fā)的時候會導(dǎo)致爭用，阻礙了系統(tǒng)的擴(kuò)展性。Java5介紹了并發(fā)集合像ConcurrentHashMap，不僅提供線程安全還用鎖分離和內(nèi)部分區(qū)等現(xiàn)代技術(shù)提高了可擴(kuò)展性。
77、什么是線程池？為什么要使用它？
創(chuàng)建線程要花費(fèi)昂貴的資源和時間，如果任務(wù)來了才創(chuàng)建線程那么響應(yīng)時間會變長，而且一個進(jìn)程能創(chuàng)建的線程數(shù)有限。
為了避免這些問題，在程序啟動的時候就創(chuàng)建若干線程來響應(yīng)處理，它們被稱為線程池，里面的線程叫工作線程。從JDK1.5開始，Java API提供了Executor框架讓你可以創(chuàng)建不同的線程池。
78、怎么檢測一個線程是否擁有鎖？
在java.lang.Thread中有一個方法叫holdsLock()，它返回true如果當(dāng)且僅當(dāng)當(dāng)前線程擁有某個具體對象的鎖。
79、你如何在Java中獲取線程堆棧？
kill -3 [java pid]不會在當(dāng)前終端輸出，它會輸出到代碼執(zhí)行的或指定的地方去。比如，kill -3 tomcat pid, 輸出堆棧到log目錄下。Jstack [java pid]這個比較簡單，在當(dāng)前終端顯示，也可以重定向到指定文件中。-JvisualVM：Thread Dump不做說明，打開JvisualVM后，都是界面操作，過程還是很簡單的。
80、JVM中哪個參數(shù)是用來控制線程的棧堆棧小的?
-Xss 每個線程的棧大小
81、Thread類中的yield方法有什么作用？
使當(dāng)前線程從執(zhí)行狀態(tài)（運(yùn)行狀態(tài)）變?yōu)榭蓤?zhí)行態(tài)（就緒狀態(tài)）。
當(dāng)前線程到了就緒狀態(tài)，那么接下來哪個線程會從就緒狀態(tài)變成執(zhí)行狀態(tài)呢？可能是當(dāng)前線程，也可能是其他線程，看系統(tǒng)的分配了。
82、Java中ConcurrentHashMap的并發(fā)度是什么？
ConcurrentHashMap把實(shí)際map劃分成若干部分來實(shí)現(xiàn)它的可擴(kuò)展性和線程安全。這種劃分是使用并發(fā)度獲得的，它是ConcurrentHashMap類構(gòu)造函數(shù)的一個可選參數(shù)，默認(rèn)值為16，這樣在多線程情況下就能避免爭用。
在JDK8后，它摒棄了Segment（鎖段）的概念，而是啟用了一種全新的方式實(shí)現(xiàn),利用CAS算法。同時加入了更多的輔助變量來提高并發(fā)度，具體內(nèi)容還是查看源碼吧。
83、Java中Semaphore是什么？
Java中的Semaphore是一種新的同步類，它是一個計(jì)數(shù)信號。從概念上講，從概念上講，信號量維護(hù)了一個許可集合。如有必要，在許可可用前會阻塞每一個 acquire()，然后再獲取該許可。
每個 release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實(shí)際的許可對象，Semaphore只對可用許可的號碼進(jìn)行計(jì)數(shù)，并采取相應(yīng)的行動。信號量常常用于多線程的代碼中，比如數(shù)據(jù)庫連接池。
84、Java線程池中submit() 和 execute()方法有什么區(qū)別？
兩個方法都可以向線程池提交任務(wù)，execute()方法的返回類型是void，它定義在Executor接口中。
而submit()方法可以返回持有計(jì)算結(jié)果的Future對象，它定義在ExecutorService接口中，它擴(kuò)展了Executor接口，其它線程池類像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有這些方法。
85、什么是阻塞式方法？
阻塞式方法是指程序會一直等待該方法完成期間不做其他事情，ServerSocket的accept()方法就是一直等待客戶端連接。這里的阻塞是指調(diào)用結(jié)果返回之前，當(dāng)前線程會被掛起，直到得到結(jié)果之后才會返回。此外，還有異步和非阻塞式方法在任務(wù)完成前就返回。
86、Java中的ReadWriteLock是什么？
讀寫鎖是用來提升并發(fā)程序性能的鎖分離技術(shù)的成果。
87、volatile 變量和 atomic 變量有什么不同？
Volatile變量可以確保先行關(guān)系，即寫操作會發(fā)生在后續(xù)的讀操作之前, 但它并不能保證原子性。例如用volatile修飾count變量那么 count++ 操作就不是原子性的。
而AtomicInteger類提供的atomic方法可以讓這種操作具有原子性如getAndIncrement()方法會原子性的進(jìn)行增量操作把當(dāng)前值加一，其它數(shù)據(jù)類型和引用變量也可以進(jìn)行相似操作。
88、可以直接調(diào)用Thread類的run ()方法么？
當(dāng)然可以。但是如果我們調(diào)用了Thread的run()方法，它的行為就會和普通的方法一樣，會在當(dāng)前線程中執(zhí)行。為了在新的線程中執(zhí)行我們的代碼，必須使用Thread.start()方法。
89、如何讓正在運(yùn)行的線程暫停一段時間？
我們可以使用Thread類的Sleep()方法讓線程暫停一段時間。需要注意的是，這并不會讓線程終止，一旦從休眠中喚醒線程，線程的狀態(tài)將會被改變?yōu)镽unnable，并且根據(jù)線程調(diào)度，它將得到執(zhí)行。
90、你對線程優(yōu)先級的理解是什么？
每一個線程都是有優(yōu)先級的，一般來說，高優(yōu)先級的線程在運(yùn)行時會具有優(yōu)先權(quán)，但這依賴于線程調(diào)度的實(shí)現(xiàn)，這個實(shí)現(xiàn)是和操作系統(tǒng)相關(guān)的(OS dependent)。
我們可以定義線程的優(yōu)先級，但是這并不能保證高優(yōu)先級的線程會在低優(yōu)先級的線程前執(zhí)行。線程優(yōu)先級是一個int變量(從1-10)，1代表最低優(yōu)先級，10代表最高優(yōu)先級。
java的線程優(yōu)先級調(diào)度會委托給操作系統(tǒng)去處理，所以與具體的操作系統(tǒng)優(yōu)先級有關(guān)，如非特別需要，一般無需設(shè)置線程優(yōu)先級。
91、什么是線程調(diào)度器(Thread Scheduler)和時間分片(Time Slicing )？
線程調(diào)度器是一個操作系統(tǒng)服務(wù)，它負(fù)責(zé)為Runnable狀態(tài)的線程分配CPU時間。一旦我們創(chuàng)建一個線程并啟動它，它的執(zhí)行便依賴于線程調(diào)度器的實(shí)現(xiàn)。同上一個問題，線程調(diào)度并不受到Java虛擬機(jī)控制，所以由應(yīng)用程序來控制它是更好的選擇（也就是說不要讓你的程序依賴于線程的優(yōu)先級）。
時間分片是指將可用的CPU時間分配給可用的Runnable線程的過程。分配CPU時間可以基于線程優(yōu)先級或者線程等待的時間。
92、你如何確保main()方法所在的線程是Java 程序最后結(jié)束的線程？
我們可以使用Thread類的join()方法來確保所有程序創(chuàng)建的線程在main()方法退出前結(jié)束。
93、線程之間是如何通信的？
當(dāng)線程間是可以共享資源時，線程間通信是協(xié)調(diào)它們的重要的手段。Object類中wait()\notify()\notifyAll()方法可以用于線程間通信關(guān)于資源的鎖的狀態(tài)。
94、為什么線程通信的方法wait(), notify()和notifyAll()被定義在Object 類里？
Java的每個對象中都有一個鎖(monitor，也可以成為監(jiān)視器) 并且wait()，notify()等方法用于等待對象的鎖或者通知其他線程對象的監(jiān)視器可用。
在Java的線程中并沒有可供任何對象使用的鎖和同步器。這就是為什么這些方法是Object類的一部分，這樣Java的每一個類都有用于線程間通信的基本方法。
95、為什么wait(), notify()和notifyAll ()必須在同步方法或者同步塊中被調(diào)用？
當(dāng)一個線程需要調(diào)用對象的wait()方法的時候，這個線程必須擁有該對象的鎖，接著它就會釋放這個對象鎖并進(jìn)入等待狀態(tài)直到其他線程調(diào)用這個對象上的notify()方法。
同樣的，當(dāng)一個線程需要調(diào)用對象的notify()方法時，它會釋放這個對象的鎖，以便其他在等待的線程就可以得到這個對象鎖。由于所有的這些方法都需要線程持有對象的鎖，這樣就只能通過同步來實(shí)現(xiàn)，所以他們只能在同步方法或者同步塊中被調(diào)用。
96、為什么Thread類的sleep()和yield ()方法是靜態(tài)的？
Thread類的sleep()和yield()方法將在當(dāng)前正在執(zhí)行的線程上運(yùn)行。所以在其他處于等待狀態(tài)的線程上調(diào)用這些方法是沒有意義的。這就是為什么這些方法是靜態(tài)的。它們可以在當(dāng)前正在執(zhí)行的線程中工作，并避免程序員錯誤的認(rèn)為可以在其他非運(yùn)行線程調(diào)用這些方法。
97、如何確保線程安全？
在Java中可以有很多方法來保證線程安全——同步，使用原子類(atomic concurrent classes)，實(shí)現(xiàn)并發(fā)鎖，使用volatile關(guān)鍵字，使用不變類和線程安全類。
98、同步方法和同步塊，哪個是更好的選擇？
同步塊是更好的選擇，因?yàn)樗粫i住整個對象（當(dāng)然你也可以讓它鎖住整個對象）。同步方法會鎖住整個對象，哪怕這個類中有多個不相關(guān)聯(lián)的同步塊，這通常會導(dǎo)致他們停止執(zhí)行并需要等待獲得這個對象上的鎖。
同步塊更要符合開放調(diào)用的原則，只在需要鎖住的代碼塊鎖住相應(yīng)的對象，這樣從側(cè)面來說也可以避免死鎖。
99、如何創(chuàng)建守護(hù)線程？
使用Thread類的setDaemon(true)方法可以將線程設(shè)置為守護(hù)線程，需要注意的是，需要在調(diào)用start()方法前調(diào)用這個方法，否則會拋出IllegalThreadStateException異常。
100、什么是Java Timer 類？如何創(chuàng)建一個有特定時間間隔的任務(wù)？
java.util.Timer是一個工具類，可以用于安排一個線程在未來的某個特定時間執(zhí)行。Timer類可以用安排一次性任務(wù)或者周期任務(wù)。
java.util.TimerTask是一個實(shí)現(xiàn)了Runnable接口的抽象類，我們需要去繼承這個類來創(chuàng)建我們自己的定時任務(wù)并使用Timer去安排它的執(zhí)行。目前有開源的Qurtz可以用來創(chuàng)建定時任務(wù)。
總結(jié)：
所有的面試題目都不是一成不變的，上面的面試題只是給大家一個借鑒作用，最主要的是給自己增加知識的儲備，有備無患。整理了一份Java面試寶典完整版PDF
