1. 什么是線程？

　　線程是操作系統能夠進行運算調度的最小單位，它被包含在進程之中，是進程中的實際運作單位。程序員可以通過它進行多處理器編程，你可以使用多線程對運算密集型任務提速。比如，如果一個線程完成一個任務要100毫秒，那么用十個線程完成改任務只需10毫秒。

2. 線程和進程有什么區別？

　　線程是進程的子集，一個進程可以有很多線程，每條線程并行執行不同的任務。不同的進程使用不同的內存空間，而所有的線程共享一片相同的內存空間。別把它和棧內存搞混，每個線程都擁有單獨的棧內存用來存儲本地數據。

3、多線程有幾種實現方法?同步有幾種實現方法?  

　 通常使用繼承Thread類或實現Runnable接口，還可以通過Callable接口實現。

     同步的實現方法有兩種，分別是synchronized,wait與notify

     wait():使一個線程處于等待狀態，并且釋放所持有的對象的lock。

     sleep():使一個正在運行的線程處于睡眠狀態，是一個靜態方法，調用此方法要捕捉InterruptedException異常。

     notify():喚醒一個處于等待狀態的線程，注意的是在調用此方法的時候，并不能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且不是按優先級。

     notityAll():喚醒所有處入等待狀態的線程，注意并不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。

用Runnable還是Thread？

　　這個問題是上題的后續，大家都知道我們可以通過繼承Thread類或者調用Runnable接口來實現線程，問題是，那個方法更好呢？什么情況下使用它？這個問題很容易回答，如果你知道Java不支持類的多重繼承，但允許你調用多個接口。所以如果你要繼承其他類，當然是調用Runnable接口好了。

Java中Runnable和Callable有什么不同？

　　Runnable和Callable都代表那些要在不同的線程中執行的任務。Runnable從JDK1.0開始就有了，Callable是在JDK1.5增加的。它們的主要區別是Callable的 call() 方法可以返回值和拋出異常，而Runnable的run()方法沒有這些功能。Callable可以返回裝載有計算結果的Future對象。

4. Thread 類中的start() 和 run() 方法有什么區別？

　　這個問題經常被問到，但還是能從此區分出面試者對Java線程模型的理解程度。start()方法被用來啟動新創建的線程，而且start()內部調用了run()方法，這和直接調用run()方法的效果不一樣。當你調用run()方法的時候，只會是在原來的線程中調用，沒有新的線程啟動，start()方法才會啟動新線程。

5. 線程的狀態轉換

　　狀態：就緒，運行，synchronize阻塞，wait和sleep掛起，結束。wait必須在synchronized內部調用。

     調用線程的start方法后線程進入就緒狀態，線程調度系統將就緒狀態的線程轉為運行狀態，遇到synchronized語句時，由運行狀態轉為阻塞，當synchronized獲得鎖后，由阻塞轉為運行，在這種情況可以調用wait方法轉為掛起狀態，當線程關聯的代碼執行完后，線程變為結束狀態。

6. 如何停止一個線程 

Java提供了很豐富的API但沒有為停止線程提供API。JDK 1.0本來有一些像stop(), suspend() 和 resume()的控制方法但是由于潛在的死鎖威脅因此在后續的JDK版本中他們被棄用了，之后Java API的設計者就沒有提供一個兼容且線程安全的方法來停止一個線程。當run() 或者 call() 方法執行完的時候線程會自動結束,如果要手動結束一個線程，你可以用volatile 布爾變量來退出run()方法的循環或者是取消任務來中斷線程

所以停止一個線程的方法有：

1、run方法代碼執行完成

2、線程運行時拋出一個未捕獲的異常，跳出線程

3、通過標志位跳出線程

4、interrupt() 方法向需要中斷的線程發送停止指令；isInterrupted()方法線程檢查自己的中斷標志位；Thread.interrupted() 將中斷標志位復位為false；

7. 什么是線程安全

多個線程同時訪問某個代碼塊時輸出的結果和變量的值都是和預期的一樣的就叫線程安全

8. synchronized如何使用

synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。

 synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：  

public synchronized void accessVal(int newVal);

synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：  
synchronized(syncObject) {  
//允許訪問控制的代碼  
}  

9. synchronized 和 ReentrantLock 有什么不同？

Java在過去很長一段時間只能通過synchronized關鍵字來實現互斥，它有一些缺點。比如你不能擴展鎖之外的方法或者塊邊界，嘗試獲取鎖時不能中途取消等。Java 5 通過Lock接口提供了更復雜的控制來解決這些問題。 ReentrantLock 類實現了 Lock，它擁有與 synchronized 相同的并發性和內存語義且它還具有可擴展性

10. wait() 和 sleep()方法有什么不同？

相同點：wait 和 sleep都會造成某種形式的暫停，它們可以滿足不同的需要。

不同點：

1、sleep()是線程Thread的方法，而wait()是Object對象的方法。

2、sleep()不會釋放對象鎖、wait()會釋放對象鎖

3、sleep()可以在任何地方調用，wait()方法只可以在同步方法或同步塊中使用。

11. java中有幾種方法可以實現一個線程？用什么關鍵字修飾同步方法? stop()和suspend()方法為何不推薦使用？

java5以前，有如下兩種：

第一種：

     new Thread(){}.start();這表示調用Thread子類對象的run方法，new Thread(){}表示一個Thread的匿名子類的實例對象，子類加上run方法后的代碼如下：

1 new Thread() {
2 
3             public void run() {
4 
5             }
6 
7         }.start();

第二種：

     new Thread(new Runnable(){}).start();這表示調用Thread對象接受的Runnable對象的run方法，new Runnable(){}表示一個Runnable的匿名子類的實例對象,runnable的子類加上run方法后的代碼如下：

1 new Thread(new Runnable() {
2 
3             public void run() {
4 
5             }
6 
7         }
8 
9         ).start();

從java5開始，還有如下一些線程池創建多線程的方式：

 1 ExecutorService pool = Executors.newFixedThreadPool(3);
 2 
 3         for (int i = 0; i < 10; i++)
 4 
 5         {
 6 
 7             pool.execute(new Runable() {
 8                 public void run() {
 9                 }
10             });
11 
12         }
13 
14         Executors.newCachedThreadPool().execute(new Runable() {
15             public void run() {
16             }
17         });
18 
19         Executors.newSingleThreadExecutor().execute(new Runable() {
20             public void run() {
21             }
22         }
23 
24         );

用synchronized關鍵字修飾同步方法

Stop() 立刻停止線程，但不會釋放線程運行所應用的資源

Suspend() 立刻掛起線程，但不會釋放線程運行所應用的資源，容易造成死鎖

suspend()方法容易發生死鎖。調用suspend()的時候，目標線程會停下來，但卻仍然持有在這之前獲得的鎖定。此時，其他任何線程都不能訪問鎖定的資源，除非被"掛起"的線程恢復運行。對任何線程來說，如果它們想恢復目標線程，同時又試圖使用任何一個鎖定的資源，就會造成死鎖。所以不應該使用suspend()，而應在自己的Thread類中置入一個標志，指出線程應該活動還是掛起。若標志指出線程應該掛起，便用wait()命其進入等待狀態。若標志指出線程應當恢復，則用一個notify()重新啟動線程。

12. 同步和異步有何異同，在什么情況下分別使用他們？舉例說明。

同步：用戶觸發IO操作，你發起了請求就得等著對方給你返回結果，你不能走，針對調用方的，你發起了請求你等

異步：用戶觸發了IO操作，即發起了請求以后可以做自己的事，等處理完以后會給你返回處理完成的標志，針對調用方的，你發起了請求你不等

13. 啟動一個線程是用run()還是start()?  

啟動一個線程是調用start()方法，使線程就緒狀態，以后可以被調度為運行狀態，一個線程必須關聯一些具體的執行代碼，run()方法是該線程所關聯的執行代碼。

14. 當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法?

分幾種情況：

     1.其他方法前是否加了synchronized關鍵字，如果沒加，則能。

     2.如果這個方法內部調用了wait，則可以進入其他synchronized方法。

     3.如果其他個方法都加了synchronized關鍵字，并且內部沒有調用wait，則不能。

15. 簡述synchronized和java.util.concurrent.locks.Lock的異同？

主要相同點：Lock能完成synchronized所實現的所有功能

主要不同點：Lock有比synchronized更精確的線程語義和更好的性能。synchronized會自動釋放鎖，而Lock一定要求程序員手工釋放，并且必須在finally從句中釋放。Lock還有更強大的功能，例如，它的tryLock方法可以非阻塞方式去拿鎖。

synchronized是一個Java的關鍵字，Lock是一個接口；

synchronized代碼塊執行完或線程拋出異常時結束線程，Lock必須顯示調用釋放鎖的方法:unlock()；

synchronized修飾的鎖其他線程在等待獲取鎖的階段，會一直阻塞等待直到得到鎖為止（不可中斷鎖）；Lock有多種方式可以獲取鎖，不一定一直阻塞等待（可中斷鎖）。

synchronized無法判斷鎖的狀態，Lock可以判斷；

synchronized是非公平鎖，而Lock可以設置為公平鎖；

Lock用法：

lock()（阻塞線程等待獲取鎖）

lockInterruptibly():可中斷（阻塞線程等待獲取鎖，會響應中斷）

tryLock():嘗試非阻塞的獲取鎖（非阻塞方式嘗試獲取鎖，無法獲取則返回false）

unlock()

公平鎖與非公平鎖：

公平鎖，先對鎖發出獲取請求的一定先獲得鎖。非公平鎖則反之（性能更高）。

ReentrantLock(boolean)可選擇公平鎖或非公平鎖，默認使用非公平鎖。

鎖的可重入：

遞歸的時候發生鎖的重入

synchronized隱式支持鎖的重入

ReentrantLock的lock()支持鎖的重入

排它鎖：同一時刻只有一個線程獲取鎖；

讀寫鎖：同一時刻運行多個讀線程訪問，但是只允許一個寫線程，寫鎖會阻塞所有鎖。（ReentrantReadWriteLock，相比synchronized速度更快）

Condition接口有何作用？

Condition接口與Lock配合，來實現等待通知機制。

16. volatile關鍵字

在多個線程之間，訪問同一個被volatile修飾的對象時，所有線程共享這個對象的值。

但是volatile不是線程安全的（多個線程同時修改這個變量時，最終結果不一定是最后修改的那個值；可以保證線程的可見性，不可以保證操作的原子性）

17. synchronized如何使用

加鎖

可以修飾方法或代碼塊以同步的方式執行（同一時間只會有一個線程執行）

類鎖與實例鎖本質上是兩把鎖，類鎖鎖的是每一個類的class對象。

18. 死鎖、活鎖

死鎖：

當一個鎖未被釋放，其他線程無法獲取鎖的時候，程序產生死鎖情況。

死鎖的兩種情況：

1、線程thread1先獲取鎖locka，然后在同步塊里嵌套競爭鎖lockb。而線程thread2先獲取鎖lockb，然后在同步塊里嵌套競爭鎖locka。

2、Lock.unlock()方法的錯誤使用，導致死鎖。

活鎖：

線程A和線程B分別拿到了鎖A和鎖B，同時線程A和線程B分別需要鎖B和鎖A，線程A和線程B發現對方需要自己持有的鎖就釋放自己持有的鎖，這樣循環處于拿鎖和獲取鎖的情況就叫做活鎖

如何避免死鎖？

     Java多線程中的死鎖 死鎖是指兩個或兩個以上的進程在執行過程中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去。這是一個嚴重的問題，因為死鎖會讓你的程序掛起無法完成任務，死鎖的發生必須滿足以下四個條件：

• 互斥條件：一個資源每次只能被一個進程使用。
• 請求與保持條件：一個進程因請求資源而阻塞時，對已獲得的資源保持不放。
• 不剝奪條件：進程已獲得的資源，在末使用完之前，不能強行剝奪。
• 循環等待條件：若干進程之間形成一種頭尾相接的循環等待資源關系。

避免死鎖最簡單的方法就是阻止循環等待條件，將系統中所有的資源設置標志位、排序，規定所有的進程申請資源必須以一定的順序（升序或降序）做操作來避免死鎖。

 19. 怎么檢測一個線程是否擁有鎖？

　　在java.lang.Thread中有一個方法叫holdsLock()，它返回true如果當且僅當當前線程擁有某個具體對象的鎖。

20. 你如何在Java中獲取線程堆棧？

　　對于不同的操作系統，有多種方法來獲得Java進程的線程堆棧。當你獲取線程堆棧時，JVM會把所有線程的狀態存到日志文件或者輸出到控制臺。

　　在Windows你可以使用Ctrl + Break組合鍵來獲取線程堆棧，Linux下用kill -3命令。你也可以用jstack這個工具來獲取，它對線程id進行操作，你可以用jps這個工具找到id。

21. JVM中哪個參數是用來控制線程的棧堆棧小的

　　 -Xss參數用來控制線程的堆棧大小。

22. Java線程池

什么是線程池？用于管理線程的一個工具。

線程池的作用？限制系統中執行線程的數量；降低資源的消耗、提高響應速度、提高線程的可管理性。

Java常見的線程池：

Executors.newSingleThreadExecutor：單個線程的線程池；

Executors.newFixedThreadExecutor：固定線程數量的線程池；

Executors.newCacheThreadExecutor：可緩存線程；

Executors.newScheduledThreadPool：創建一個定長線程池，支持定時和周期性的執行線程；

23. 并發工具類和并發容器類

常用的并發工具類：

閉鎖：CountDownLatch

柵欄：CyclicBarrier

信號量：Semaphore

交換者：Exchanger

CountDownLatch 閉鎖允許一個線程或多個線程等待特定情況，同步完成線程中其他任務。

CyclicBarrier和CountDownLatch都可以協同多個線程，讓指定數量的線程等待期他所有的線程都滿足某些條件之后才繼續執行。CyclicBarrier可以重復使用(reset)，而CountDownLatch只能夠使用一次，如果還需要使用，必須重新new一個CountDownLatch對象。

構造方法CyclicBarrier(int, Runnable) 所有線程達到屏障后，執行Runnable。

Semaphore 信號量用來控制同時訪問特定資源的線程數量。

Java中Semaphore是什么？

　　Java中的Semaphore是一種新的同步類，它是一個計數信號。從概念上講，從概念上講，信號量維護了一個許可集合。如有必要，在許可可用前會阻塞每一個 acquire()，然后再獲取該許可。每個 release()添加一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實際的許可對象，Semaphore只對可用許可的號碼進行計數，并采取相應的行動。信號量常常用于多線程的代碼中，比如數據庫連接池。

Exchanger 交換者用于在兩個線程之間傳輸數據，被調用后等待另一個線程達到交換點，然后相互交換數據。

常用的并發容器：

ConcurrentHashMap：JDK1.7實現：分段鎖；JDK1.8實現：元素(key)鎖+鏈表+紅黑樹

SkipList：跳表自動隨機維護一套索引，用于高效的索引List中的有序數據。

ConcurrentSkipListMap：TreeMap的并發實現

ConcurrentSkipListSet：TreeSet的并發實現

ConcurrentLinkedQueue：LinkedList的并發實現

CopyOnWriteArrayList：寫時復制，在添加元素是，復制一個新的容器，在新容器中新增元素；讀數據都在Old容器中操作，進行讀寫分離。數據一致性較弱，適合讀多寫少的場景。

CopyOnWriteArraySet：同上

24. Java中什么是競態條件？ 舉個例子說明。

　　競態條件會導致程序在并發情況下出現一些bugs。多線程對一些資源的競爭的時候就會產生競態條件，如果首先要執行的程序競爭失敗排到后面執行了，那么整個程序就會出現一些不確定的bugs。這種bugs很難發現而且會重復出現，因為線程間的隨機競爭。一個例子就是無序處理。

       解決競態條件方法：使用線程的ThreadLocal變量

                                       ThreadLocal是Java里一種特殊的變量。每個線程都有一個ThreadLocal，就是每個線程都擁有了自己獨立的一個變量，競爭條件被徹底消除了

                                       本質是個map，map的鍵就是每個線程對象，值就是每個線程所擁有的值

25. 一個線程運行時發生異常會怎樣？

　　如果異常沒有被捕獲該線程將會停止執行。Thread.UncaughtExceptionHandler是用于處理未捕獲異常造成線程突然中斷情況的一個內嵌接口。當一個未捕獲異常將造成線程中斷的時候JVM會使用Thread.getUncaughtExceptionHandler()來查詢線程的UncaughtExceptionHandler并將線程和異常作為參數傳遞給handler的uncaughtException()方法進行處理。

26. 如何在兩個線程間共享數據？

　　可以通過共享對象來實現這個目的，或者是使用像阻塞隊列這樣并發的數據結構。

27. 為什么wait, notify 和 notifyAll這些方法不在thread類里面？

　　這是個設計相關的問題，它考察的是面試者對現有系統和一些普遍存在但看起來不合理的事物的看法。回答這些問題的時候，你要說明為什么把這些方法放在Object類里是有意義的，還有不把它放在Thread類里的原因。一個很明顯的原因是JAVA提供的鎖是對象級的而不是線程級的，每個對象都有鎖，通過線程獲得。如果線程需要等待某些鎖那么調用對象中的wait()方法就有意義了。如果wait()方法定義在Thread類中，線程正在等待的是哪個鎖就不明顯了。簡單的說，由于wait，notify和notifyAll都是鎖級別的操作，因為鎖屬于對象，所以把他們定義在Object類中。

28. 什么是ThreadLocal變量？

ThreadLocal是Java里一種特殊的變量。每個線程都有一個ThreadLocal，就是每個線程都擁有了自己獨立的一個變量，競爭條件被徹底消除了

本質是個map，map的鍵就是每個線程對象，值就是每個線程所擁有的值

常用方法：

initialValue()

get()

set()

remove()：將當前線程局部變量的值刪除，這個方法是JDK 5.0新增的方法。當線程結束后，對應該線程的局部變量將自動被垃圾回收，所以顯式調用該方法清除線程的局部變量并不是必須的操作，但它可以加快內存回收的速度。

ThreadLocal擁有的這個變量，在線程之間很獨立的，相互之間沒有聯系。內存占用相對來說比較大。

29. 什么是FutureTask？

　　在Java并發程序中FutureTask表示一個可以取消的異步運算。它有啟動和取消運算、查詢運算是否完成和取回運算結果等方法。只有當運算完成的時候結果才能取回，如果運算尚未完成get方法將會阻塞。一個FutureTask對象可以對調用了Callable和Runnable的對象進行包裝，由于FutureTask也是調用了Runnable接口所以它可以提交給Executor來執行。

30. Java中interrupted 和 isInterrupted方法的區別？

　　interrupted() 和 isInterrupted()的主要區別是前者會將中斷狀態清除而后者不會。Java多線程的中斷機制是用內部標識來實現的，調用Thread.interrupt()來中斷一個線程就會設置中斷標識為true。當中斷線程調用靜態方法Thread.interrupted()來檢查中斷狀態時，中斷狀態會被清零。而非靜態方法isInterrupted()用來查詢其它線程的中斷狀態且不會改變中斷狀態標識。簡單的說就是任何拋出InterruptedException異常的方法都會將中斷狀態清零。無論如何，一個線程的中斷狀態有有可能被其它線程調用中斷來改變。

interrupt() 向需要中斷的線程發送停止指令；isInterrupted() 線程檢查自己的中斷標志位；Thread.interrupted() 將中斷標志位復位為false；

31. 為什么wait和notify方法要在同步塊中調用？

　　主要是因為Java API強制要求這樣做，如果你不這么做，你的代碼會拋出IllegalMonitorStateException異常。還有一個原因是為了避免wait和notify之間產生競態條件。

32. 為什么你應該在循環中檢查等待條件?

　　處于等待狀態的線程可能會收到錯誤警報和偽喚醒，如果不在循環中檢查等待條件，程序就會在沒有滿足結束條件的情況下退出。在notify()方法調用之后和等待線程醒來之前這段時間它可能會改變。這就是在循環中使用wait()方法效果更好的原因。

33. Java中的同步集合與并發集合有什么區別？

　　同步集合與并發集合都為多線程和并發提供了合適的線程安全的集合，不過并發集合的可擴展性更高。

　　在Java1.5之前程序員們只有同步集合來用且在多線程并發的時候會導致爭用，阻礙了系統的擴展性。Java5介紹了并發集合像ConcurrentHashMap，不僅提供線程安全還用鎖分離和內部分區等現代技術提高了可擴展性。

34. Java中堆和棧有什么不同？

　　為什么把這個問題歸類在多線程和并發面試題里？

　　因為棧是一塊和線程緊密相關的內存區域。每個線程都有自己的棧內存，用于存儲本地變量，方法參數和棧調用，一個線程中存儲的變量對其它線程是不可見的。

　　而堆是所有線程共享的一片公用內存區域。對象都在堆里創建，為了提升效率線程會從堆中弄一個緩存到自己的棧，如果多個線程使用該變量就可能引發問題，這時volatile 變量就可以發揮作用了，它要求線程從主存中讀取變量的值。

35. 如何寫代碼來解決生產者消費者問題？

　　在現實中你解決的許多線程問題都屬于生產者消費者模型，就是一個線程生產任務供其它線程進行消費，你必須知道怎么進行線程間通信來解決這個問題。

       比較低級的辦法是用wait和notify來解決這個問題；比較贊的辦法是用Semaphore 或者 BlockingQueue來實現生產者消費者模型

36. 有三個線程T1，T2，T3，怎么確保它們按順序執行？

　　在多線程中有多種方法讓線程按特定順序執行，你可以用線程類的join()方法在一個線程中啟動另一個線程，另外一個線程完成該線程繼續執行。為了確保三個線程的順序你應該先啟動最后一個(T3調用T2，T2調用T1)，這樣T1就會先完成而T3最后完成。

37. Thread類中的yield方法有什么作用？

　　Yield方法可以暫停當前正在執行的線程對象，讓其它有相同優先級的線程執行。它是一個靜態方法而且只保證當前線程放棄CPU占用而不能保證使其它線程一定能占用CPU，執行yield()的線程有可能在進入到暫停狀態后馬上又被執行。

38. Java中ConcurrentHashMap的并發度是什么？

　　ConcurrentHashMap把實際map劃分成若干部分來實現它的可擴展性和線程安全。這種劃分是使用并發度獲得的。

　　并發度是ConcurrentHashMap類構造函數的一個可選參數，默認值為16。

　　并發度的作用：在多線程情況下就能避免爭用。

39. 如果你提交任務時，線程池隊列已滿時會發會生什么？

　　這個問題問得很狡猾，許多程序員會認為該任務會阻塞直到線程池隊列有空位。事實上如果一個任務不能被調度執行，那么ThreadPoolExecutor的submit()方法將會拋出一個拒絕執行異常RejectedExecutionException異常。

40. Java線程池中submit() 和 execute()方法有什么區別？

相同點：　　

　　1. 兩個方法都可以向線程池提交任務。

不同點：

　　1. execute()方法的返回類型是void，它定義在Executor接口中, 而submit()方法可以返回持有計算結果的Future對象，它定義在ExecutorService接口中，它擴展了Executor接口，其它線程池類像ScheduledThreadPoolExecutor都有 execute()和submit()方法。

41. 什么是阻塞式方法？

　　阻塞式方法是指程序會一直等待該方法完成期間不做其他事情。

　　ServerSocket的accept()方法就是一直等待客戶端連接。

　　這里的阻塞是指調用結果返回之前，當前線程會被掛起，直到得到結果之后才會返回。此外，還有異步和非阻塞式方法在任務完成前就返回。

42. Java中的讀寫鎖ReadWriteLock是什么？

讀寫鎖的概念：Java中的讀寫鎖ReadWriteLock是Java 5 中新增的一個接口，一個讀寫鎖ReadWriteLock維護一對關聯的鎖：讀鎖和寫鎖，一個用于只讀操作，一個用于寫。

　　                  在沒有寫線程的情況下一個讀鎖可能會同時被多個讀線程持有。寫鎖是獨占的，你可以使用JDK中的ReentrantReadWriteLock來實現這個規則，它最多支持65535個寫鎖和65535個讀鎖。

讀寫鎖的作用：讀寫鎖是用來提升并發程序性能的鎖分離技術的成果。

43. 多線程中的忙循環是什么?

　　忙循環的概念：忙循環就是程序員用循環讓一個線程等待，不像傳統方法wait(), sleep() 或 yield() 它們都放棄了CPU控制，而忙循環不會放棄CPU，它就是在運行一個空循環。

　　忙循環的作用：使用忙循環的目的是為了保留CPU緩存，在多核系統中，一個等待線程醒來的時候可能會在另一個內核運行，這樣會重建緩存。為了避免重建緩存和減少等待重建的時間就可以使用忙循環了。

44. volatile 變量和 atomic 變量有什么不同？

　　這是個有趣的問題。首先，volatile 變量和 atomic 變量看起來很像，但功能卻不一樣。

　　Volatile變量只能保證對象的可見性，單不能保證對象的線程安全。例如用volatile修飾count變量那么 count++ 操作就不是原子性的。

　　而AtomicInteger類提供的atomic方法可以讓這種操作具有原子性，如getAndIncrement()方法會原子性的進行增量操作把當前值加一，其它數據類型和引用變量也可以進行相似操作。

45. 如果同步塊內的線程拋出異常會發生什么？

同步塊內的線程拋出異常時，線程會釋放鎖。

這個問題坑了很多Java程序員，若你能想到鎖是否釋放這條線索來回答還有點希望答對。無論你的同步塊是正常還是異常退出的，里面的線程都會釋放鎖，所以對比鎖接口我更喜歡同步塊，因為它不用我花費精力去釋放鎖。

46. 單例模式的雙檢鎖是什么？

public class Singleton{  
  private static volatile Singleton single;    //聲明靜態的單例對象的變量  
  private Singleton(){}    //私有構造方法   
    
  public static Singleton getSingle(){    //外部通過此方法可以獲取對象    
    if(single == null){     
        synchronized (Singleton.class) {   //保證了同一時間只能只能有一個對象訪問此同步塊        
            if(single == null){      
                single = new Singleton();          
        }     
      }  
    }    
    return single;   //返回創建好的對象   
  }  
}  

思路很簡單，就是我們只需要同步（synchronize）初始化instance的那部分代碼從而使代碼既正確又很有效率。 
這就是所謂的“雙檢鎖”機制（顧名思義）。

47. 如何在Java中創建線程安全的Singleton？

這是上面那個問題的后續，如果你不喜歡雙檢鎖而面試官問了創建Singleton類的替代方法，你可以利用JVM的類加載和靜態變量初始化特征來創建Singleton實例，或者是利用枚舉類型來創建Singleton，我很喜歡用這種方法。

47.1 饑漢式——可用

饑漢式1——可用

package com.study.design.mode.service;

public class Singleton {
    private final static Singleton INSTANCE = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

 饑漢式2——可用

package com.study.design.mode.service;

public class Singleton {
    private static Singleton instance;
    static {
        instance = new Singleton();
    }

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

47.2 懶漢式

 懶漢式4——雙重檢查——推薦使用

package com.study.design.mode.service;

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

注意：volatile關鍵字修飾很關鍵，保證可見性，一個線程先創建了，其他線程就就會看到這個改變，不會再創建，如果沒有這個關鍵字還是不能保證單例。

優點：線程安全；延遲加載；效率較高

懶漢式5——靜態內部類方式——推薦使用

package com.study.design.mode.service;

public class Singleton {
    private Singleton() {
    }

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

優點：避免了線程不安全，延遲加載，效率高

原理：類的靜態屬性只會在第一次加載類的時候初始化。在這里，JVM的加載機制幫助我們保證了線程安全性，在類進行初始化時，別的線程是無法進入的

懶漢式6——用枚舉——推薦使用

package com.study.design.mode.service;

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

48. 寫出3條你遵循的多線程最佳實踐

　　這種問題我最喜歡了，我相信你在寫并發代碼來提升性能的時候也會遵循某些最佳實踐。以下三條最佳實踐我覺得大多數Java程序員都應該遵循：

• 給你的線程起個有意義的名字。 這樣可以方便找bug或追蹤。OrderProcessor, QuoteProcessor or TradeProcessor 這種名字比 Thread-1. Thread-2 and Thread-3 好多了，給線程起一個和它要完成的任務相關的名字，所有的主要框架甚至JDK都遵循這個最佳實踐。
• 避免鎖定和縮小同步的范圍。 因為鎖對于性能是有影響的，所以應盡量避免加鎖，能不加鎖的地方就不要加，不得不加的就要考慮在最小范圍內加，這樣才不會影響效率。因此相對于同步方法我更喜歡同步塊，它給我擁有對鎖的絕對控制權。
• 多用同步工具類少用wait 和 notify。 首先，CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 這些同步類簡化了編碼操作，而用wait和notify很難實現對復雜控制流的控制，寫得不好還容易出bug。其次，這些類是由最好的企業編寫和維護在后續的JDK中它們還會不斷優化和完善，使用這些更高等級的同步工具你的程序可以不費吹灰之力獲得優化。
• 多用并發集合少用同步集合。 這是另外一個容易遵循且受益巨大的最佳實踐，并發集合比同步集合的可擴展性更好，所以在并發編程時使用并發集合效果更好。如果下一次你需要用到map，你應該首先想到用ConcurrentHashMap。

49. 如何強制啟動一個線程？

　　這個問題就像是如何強制進行Java垃圾回收，目前還沒有好的方法，雖然你可以使用System.gc()來進行垃圾回收，但是不保證能成功。在Java里面沒有辦法強制啟動一個線程，它是被線程調度器控制著且Java沒有公布相關的API。

50. Java中的fork join框架是什么？

　　fork join框架：并行執行任務的框架，把大任務拆分成很多的小任務，匯總每個小任務的結果得到大任務的結果。它是專門為了那些可以遞歸劃分成許多子模塊設計的，目的是將所有可用的處理能力用來提升程序的性能。

       fork join框架一個巨大的優勢是它使用了工作竊取算法，可以完成更多任務的工作線程可以從其它線程中竊取任務來執行。

工作竊取算法

工作竊取（work-stealing）算法：某個線程從其他隊列里竊取任務來執行，執行完以后把結果放回去

那么，為什么需要使用工作竊取算法呢？假如我們需要做一個比較大的任務，可以把這個任務分割為若干互不依賴的子任務，為了減少線程間的競爭，把這些子任務分別放到不同的隊列里，并為每個隊列創建一個單獨的線程來執行隊列里的任務，線程和隊列一一對應。

比如A線程負責處理A隊列里的任務。但是，有的線程會先把自己隊列里的任務干完，而其他線程對應的隊列里還有任務等待處理。干完活的線程與其等著，不如去幫其他線程干活，于是它就去其他線程的隊列里竊取一個任務來執行。而在這時它們會訪問同一個隊列，所以為了減少竊取任務線程和被竊取任務線程之間的競爭，通常會使用雙端隊列，被竊取任務線程永遠從雙端隊列的頭部拿任務執行，而竊取任務的線程永遠從雙端隊列的尾部拿任務執行。

http://www.rzrgm.cn/leeSmall/p/8439263.html