Java面試知識點總結③——多線程和併發

大綱

• [x] 1、Java基礎(語言、集合框架、OOP、設計模式等)
• [x] 2、Java高級(JavaEE、框架、服務器、工具等)
• [x] 3、多線程和併發
• [x] 4、Java虛擬機
• [x] 5、數據庫(Sql、MySQL、Redis等)
• [x] 6、算法與數據結構
• [x] 7、計算機網絡
• [x] 8、操做系統(OS基礎、Linux等)
• [x] 9、其餘

3、多線程和併發

0. Java 中的 volatile 變量是什麼

Java 語言提供了一種稍弱的同步機制,即volatile變量。可是volatile並不容易徹底被正確、完整的理解。通常來講，volatile具有2條語義，或者說2個特性。第一是保證volatile修飾的變量對全部線程的可見性，這裏的可見性是指當一條線程修改了該變量，新值對於其它線程來講是當即能夠得知的。而普通變量作不到這一點。

第二條語義是禁止指令重排序優化，這條語義在JDK1.5才被修復。

關於第一點：根據JMM，全部的變量存儲在主內存，而每一個線程還有本身的工做內存，線程的工做內存保存該線程使用到的變量的主內存副本拷貝，線程對變量的操做在工做內存中進行，不能直接讀寫主內存的變量。在volatile可見性這一點上，普通變量作不到的緣由正因如此。好比，線程A修改了一個普通變量的值，而後向主內存進行回寫，線程B在線程A回寫完成後再從主內存讀取，新變量才能對線程B可見。其實，按照虛擬機規範，volatile變量依然有工做內存的拷貝，要藉助主內存來實現可見性。但因爲volatile的特殊規則保證了新值能當即同步回主內存，以及每次使用從主內存刷新，以此保證了多線程操做volatile變量的可見性。

關於第二點：先說指令重排序，指令重排序是指CPU採用了容許將多條指令不按規定順序分開發送給相應的處理單元處理，但並非說任意重排，CPU須要正確處理指令依賴狀況確保最終的正確結果，指令重排序是機器級的優化操做。那麼爲何volatile要禁止指令重排序呢，又是如何去作的。舉例，DCL（雙重檢查加鎖）的單例模式。volatile修飾後，代碼中將會插入許多內存屏障指令保證處理器不發生亂序執行。同時因爲Happens-before規則的保證，在剛纔的例子中寫操做會發生在後續的讀操做以前。

除了以上2點，volatile還保證對於64位long和double的讀取是原子性的。由於在JMM中容許虛擬機對未被volatile修飾的64位的long和double讀寫操做分爲2次32位的操做來執行，這也就是所謂的long和double的非原子性協定。

基於以上幾點，咱們知道volatile雖然有這些語義和特性在併發的狀況下仍然不能保證線程安全。大部分狀況下仍然須要加鎖。

除非是如下2種狀況，1.運算結果不依賴變量的當前值，或者可以確保只有單一線程修改變量的值；2.變量不須要與其餘的狀態變量共同參與不變約束。

1. volatile簡述

Java 語言提供了一種稍弱的同步機制,即volatile變量.用來確保將變量的更新操做通知到其餘線程,保證了新值能當即同步到主內存,以及每次使用前當即從主內存刷新。 當把變量聲明爲volatile類型後,編譯器與運行時都會注意到這個變量是共享的。volatile修飾變量,每次被線程訪問時強迫其從主內存重讀該值,修改後再寫回。保證讀取的可見性,對其餘線程當即可見。volatile的另外一個語義是禁止指令重排序優化。可是volatile並不保證原子性，也就不能保證線程安全。

2. Java 中能建立 volatile 數組嗎？

能，Java 中能夠建立 volatile 類型數組，不過只是一個指向數組的引用，而不是整個數組。個人意思是，若是改變引用指向的數組，將會受到 volatile 的保護，可是若是多個線程同時改變數組的元素，volatile 就不能起到以前的保護做用了。

3. volatile 能使得一個非原子操做變成原子操做嗎？

一個典型的例子是在類中有一個 long 類型的成員變量。若是你知道該成員變量會被多個線程訪問，如計數器、價格等，你最好是將其設置爲 volatile。爲何？由於 Java 中讀取 long 類型變量不是原子的，須要分紅兩步，若是一個線程正在修改該 long 變量的值，另外一個線程可能只能看到該值的一半（前 32 位）。可是對一個 volatile 型的 long 或 double 變量的讀寫是原子。

4. volatile 禁止指令重排序的底層原理指令重排序，是指CPU容許多條指令不按程序規定的順序分開發送給相應電路單元處理。但並非說任意重排，CPU須要能正確處理指令依賴狀況以正確的執行結果。volatile禁止指令重排序是經過內存屏障實現的，指令重排序不能把後面的指令重排序到內存屏障以前。由內存屏障保證一致性。注：該條語義在JDK1.5才得以修復，這點也是JDK1.5以前沒法經過雙重檢查加鎖來實現單例模式的緣由。

5. volatile 類型變量提供什麼保證？

volatile 變量提供有序性和可見性保證，例如，JVM 或者 JIT爲了得到更好的性能會對語句重排序，可是 volatile 類型變量即便在沒有同步塊的狀況下賦值也不會與其餘語句重排序。 volatile 提供 happens-before 的保證，確保一個線程的修改能對其餘線程是可見的。某些狀況下，volatile 還能提供原子性，如讀 64 位數據類型，像 long 和 double 都不是原子的，但 volatile 類型的 double 和 long 就是原子的。

volatile的使用場景：

1. 運算結果不依賴變量的當前值，或者可以確保只有單一的線程修改該值
2. 變量不須要與其餘狀態變量共同參與不變約束

6. volatile的性能

volatile變量的讀操做性能消耗和普通變量差很少，可是寫操做可能相對慢一些，由於它須要在本地代碼中插入許多內存屏障指令以確保處理器不發生亂序執行。大多數狀況下，volatile總開銷比鎖低，但咱們要注意volatile的語義可否知足使用場景。

7. 10 個線程和 2 個線程的同步代碼，哪一個更容易寫？

從寫代碼的角度來講，二者的複雜度是相同的，由於同步代碼與線程數量是相互獨立的。可是同步策略的選擇依賴於線程的數量，由於越多的線程意味着更大的競爭，因此你須要利用同步技術，如鎖分離，這要求更復雜的代碼和專業知識。

8. 你是如何調用 wait（）方法的？使用 if 塊仍是循環？爲何？

wait() 方法應該在循環調用，由於當線程獲取到 CPU 開始執行的時候，其餘條件可能尚未知足，因此在處理前，循環檢測條件是否知足會更好。下面是一段標準的使用 wait 和 notify 方法的代碼：

// The standard idiom for using the wait method
synchronized (obj) {
while (condition does not hold)
obj.wait(); // (Releases lock, and reacquires on wakeup)
... // Perform action appropriate to condition
}
複製代碼

參見 Effective Java 第 69 條，獲取更多關於爲何應該在循環中來調用 wait 方法的內容。

9. 什麼是多線程環境下的僞共享（false sharing）？

僞共享是多線程系統（每一個處理器有本身的局部緩存）中一個衆所周知的性能問題。僞共享發生在不一樣處理器的上的線程對變量的修改依賴於相同的緩存行，以下圖所示：

僞共享問題很難被發現，由於線程可能訪問徹底不一樣的全局變量，內存中卻碰巧在很相近的位置上。如其餘諸多的併發問題，避免僞共享的最基本方式是仔細審查代碼，根據緩存行來調整你的數據結構。

10. 線程的run方法和start方法

• run方法

只是thread類的一個普通方法，若直接調用程序中依然只有主線程這一個線程，還要順序執行，依然要等待run方法體執行完畢纔可執行下面的代碼。

• start方法

用start方法來啓動線程,是真正實現了多線程。調用thread類的start方法來啓動一個線程，此時線程處於就緒狀態，一旦獲得cpu時間片，就開始執行run方法。

11. ReadWriteLock(讀寫鎖)

寫寫互斥 讀寫互斥 讀讀併發, 在讀多寫少的狀況下能夠提升效率。

12. resume(繼續掛起的線程)和suspend(掛起線程)一塊兒用

13. wait與notify、notifyall一塊兒用

14. sleep與wait的異同點

• sleep是Thread類的靜態方法, wait來自object類
• sleep方法短暫停頓不釋放鎖, wait方法條件等待要釋放鎖，由於只有這樣，其餘等待的線程才能在知足條件時獲取到該鎖。
• wait, notify, notifyall必須在同步代碼塊中使用, sleep能夠在任何地方使用
• 均可以拋出InterruptedException

15. 讓一個線程中止執行

異常 - 中止執行休眠 - 中止執行阻塞 - 中止執行

16. ThreadLocal簡介

16.1 ThreadLocal解決了變量併發訪問的衝突問題

當使用ThreadLocal維護變量時,ThreadLocal爲每一個使用該變量的線程提供獨立的變量副本,每一個線程均可以獨立地改變本身的副本,而不會影響其它線程所對應的副本，是線程隔離的。線程隔離的祕密在於ThreadLocalMap類(ThreadLocal的靜態內部類)

16.2 與synchronized同步機制的比較

首先，它們都是爲了解決多線程中相同變量訪問衝突問題。不過，在同步機制中，要經過對象的鎖機制保證同一時間只有一個線程訪問該變量。該變量是線程共享的, 使用同步機制要求程序縝密地分析何時對該變量讀寫，何時須要鎖定某個對象， 何時釋放對象鎖等複雜的問題，程序設計編寫難度較大, 是一種「以時間換空間」的方式。而ThreadLocal採用了以「以空間換時間」的方式。

17. 線程局部變量原理

當使用ThreadLocal維護變量時，ThreadLocal爲每一個使用該變量的線程提供獨立的變量副本，每一個線程均可以獨立地改變本身的副本，而不會影響其它線程所對應的副本，是線程隔離的。線程隔離的祕密在於ThreadLocalMap類(ThreadLocal的靜態內部類)

線程局部變量是侷限於線程內部的變量，屬於線程自身全部，不在多個線程間共享。Java 提供 ThreadLocal 類來支持線程局部變量，是一種實現線程安全的方式。可是在管理環境下（如 web 服務器）使用線程局部變量的時候要特別當心，在這種狀況下，工做線程的生命週期比任何應用變量的生命週期都要長。任何線程局部變量一旦在工做完成後沒有釋放，Java 應用就存在內存泄露的風險。

ThreadLocal的方法：void set(T value)、T get()以及T initialValue()。

ThreadLocal是如何爲每一個線程建立變量的副本的：

首先，在每一個線程Thread內部有一個ThreadLocal.ThreadLocalMap類型的成員變量threadLocals，這個threadLocals就是用來存儲實際的變量副本的，鍵值爲當前ThreadLocal變量，value爲變量副本（即T類型的變量）。初始時，在Thread裏面，threadLocals爲空，當經過ThreadLocal變量調用get()方法或者set()方法，就會對Thread類中的threadLocals進行初始化，而且以當前ThreadLocal變量爲鍵值，以ThreadLocal要保存的副本變量爲value，存到threadLocals。而後在當前線程裏面，若是要使用副本變量，就能夠經過get方法在threadLocals裏面查找。

總結：

1. 實際的經過ThreadLocal建立的副本是存儲在每一個線程本身的threadLocals中的
2. 爲什麼threadLocals的類型ThreadLocalMap的鍵值爲ThreadLocal對象，由於每一個線程中可有多個threadLocal變量，就像上面代碼中的longLocal和stringLocal；
3. 在進行get以前，必須先set，不然會報空指針異常；若是想在get以前不須要調用set就能正常訪問的話，必須重寫initialValue()方法

18. JDK提供的用於併發編程的同步器

1. Semaphore Java併發庫的Semaphore能夠很輕鬆完成信號量控制，Semaphore能夠控制某個資源可被同時訪問的個數，經過 acquire() 獲取一個許可，若是沒有就等待，而 release() 釋放一個許可。
2. CyclicBarrier 主要的方法就是一個：await()。await()方法每被調用一次，計數加一，並阻塞住當前線程。當計數等於定義的大小時，阻塞解除，全部在此CyclicBarrier上面阻塞的線程開始運行而且計數重置爲0。
3. CountDownLatch 直譯過來就是倒計數(CountDown)門閂(Latch)。倒計數不用說，門閂的意思顧名思義就是阻止前進。在這裏就是指 CountDownLatch.await() 方法在倒計數爲0以前會阻塞當前線程。

19. 什麼是 Busy spin？咱們爲何要使用它？

Busy spin 是一種在不釋放 CPU 的基礎上等待事件的技術。它常常用於避免丟失 CPU 緩存中的數據（若是線程先暫停，以後在其餘CPU上運行就會丟失）。因此，若是你的工做要求低延遲，而且你的線程目前沒有任何順序，這樣你就能夠經過循環檢測隊列中的新消息來代替調用 sleep() 或 wait() 方法。它惟一的好處就是你只需等待很短的時間，如幾微秒或幾納秒。LMAX 分佈式框架是一個高性能線程間通訊的庫，該庫有一個 BusySpinWaitStrategy 類就是基於這個概念實現的，使用 busy spin 循環 EventProcessors 等待屏障。

20. Java 中怎麼獲取一份線程 dump 文件？

在 Linux 下，你能夠經過命令 kill -3 PID （Java 進程的進程 ID）來獲取 Java 應用的 dump 文件。在 Windows 下，你能夠按下 Ctrl + Break 來獲取。這樣 JVM 就會將線程的 dump 文件打印到標準輸出或錯誤文件中，它可能打印在控制檯或者日誌文件中，具體位置依賴應用的配置。

21. Swing 是線程安全的？

不是，Swing 不是線程安全的。你不能經過任何線程來更新 Swing 組件，如 JTable、JList 或 JPanel，事實上，它們只能經過 GUI 或 AWT 線程來更新。這就是爲何 Swing 提供 invokeAndWait() 和 invokeLater() 方法來獲取其餘線程的 GUI 更新請求。這些方法將更新請求放入 AWT 的線程隊列中，能夠一直等待，也能夠經過異步更新直接返回結果。

22. 用 wait-notify 寫一段代碼來解決生產者-消費者問題？

記住在同步塊中調用 wait() 和 notify()方法，若是阻塞，經過循環來測試等待條件。

23. 用 Java 寫一個線程安全的單例模式（Singleton）？

當咱們說線程安全時，意思是即便初始化是在多線程環境中，仍然能保證單個實例。Java 中，使用枚舉做爲單例類是最簡單的方式來建立線程安全單例模式的方式。參見我整理的單例的文章6種單例模式的實現以及double check的剖析

24. Java 中，編寫多線程程序的時候你會遵循哪些最佳實踐？

這是我在寫Java 併發程序的時候遵循的一些最佳實踐：

a）給線程命名，這樣能夠幫助調試。

b）最小化同步的範圍，而不是將整個方法同步，只對關鍵部分作同步。

c）若是能夠，更偏向於使用 volatile 而不是 synchronized。

d）使用更高層次的併發工具，而不是使用 wait() 和 notify() 來實現線程間通訊，如 BlockingQueue，CountDownLatch 及 Semeaphore。

e）優先使用併發集合，而不是對集合進行同步。併發集合提供更好的可擴展性。

25. 說出至少 5 點在 Java 中使用線程的最佳實踐。

這個問題與以前的問題相似，你可使用上面的答案。對線程來講，你應該：

a）對線程命名

b）將線程和任務分離，使用線程池執行器來執行 Runnable 或 Callable。

c）使用線程池

26. 在多線程環境下，SimpleDateFormat 是線程安全的嗎？

不是，很是不幸，DateFormat 的全部實現，包括 SimpleDateFormat 都不是線程安全的，所以你不該該在多線程序中使用，除非是在對外線程安全的環境中使用，如將 SimpleDateFormat 限制在 ThreadLocal 中。若是你不這麼作，在解析或者格式化日期的時候，可能會獲取到一個不正確的結果。所以，從日期、時間處理的全部實踐來講，我強力推薦 joda-time 庫。

27. Happens-Before規則

• 程序次序規則

按控制流順序前後發生

• 管程鎖定規則

一個unlock操做先行發生於後面對同一個鎖的lock操做

• volatile變量規則

對一個volatile變量的寫操做先行發生於後面對這個變量的讀操做

• 線程啓動規則

start方法先行發生於線程的每個動做

• 線程中斷規則

對線程的interrupt方法調用先行發生於被中斷線程的代碼檢測到中斷時間的發生

• 線程終止規則

線程內的全部操做都先行發生於對此線程的終止檢測

• 對象終結規則

一個對象的初始化完成先行發生於它的finalize方法的開始

• 傳遞性

若是A先行發生於操做B，B先行發生於操做C，則A先行發生於操做C

28. 什麼是線程

線程是操做系統可以進行運算調度的最小單位，它被包含在進程之中，是進程中的實際運做單位。程序員能夠經過它進行多處理器編程，可使用多線程對運算密集型任務提速。好比，若是一個線程完成一個任務要100 毫秒，那麼用十個線程完成改任務只需 10 毫秒。Java在語言層面對多線程提供了很好的支持。

29. 線程和進程有什麼區別

從概念上：

進程：一個程序對一個數據集的動態執行過程，是分配資源的基本單位。

線程：存在於進程內，是進程內的基本調度單位，共享進程的資源。

從執行過程當中來看：

進程：擁有獨立的內存單元，而多個線程共享內存，從而提升了應用程序的運行效率。

線程：每個獨立的線程，都有一個程序運行的入口、順序執行序列、和程序的出口。可是線程不可以獨立的執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。

從邏輯角度來看：（重要區別）

多線程的意義在於一個應用程序中，有多個執行部分能夠同時執行。可是，操做系統並無將多個線程看作多個獨立的應用，來實現進程的調度和管理及資源分配。

簡言之，一個程序至少有一個進程,一個進程至少有一個線程。進程是資源分配的基本單位，線程共享進程的資源。

30. 用 Runnable 仍是 Thread

Java 不支持類的多重繼承，但容許你調用多個接口。因此若是你要繼承其餘類，固然是實現Runnable接口好了。

31. Java 中 Runnable 和 Callable 有什麼不一樣

Runnable和 Callable 都表明那些要在不一樣的線程中執行的任務。Runnable 從 JDK1.0 開始就有了，Callable 是在 JDK1.5 增長的。它們的主要區別是 Callable 的 call () 方法能夠返回值和拋出異常，而 Runnable 的 run ()方法沒有這些功能。

32. Java 中 CyclicBarrier 和 CountDownLatch 有什麼不一樣

它們都是JUC下的類，CyclicBarrier 和 CountDownLatch 均可以用來讓一組線程等待其它線程。區別在於CountdownLatch計數沒法被重置。若是須要重置計數，請考慮使用 CyclicBarrier。

33. Java 內存模型是什麼

Java 內存模型規定和指引 Java 程序在不一樣的內存架構、CPU 和操做系統間有肯定性地行爲。它在多線程的狀況下尤爲重要。Java內存模型對一個線程所作的變更能被其它線程可見提供了保證，它們之間是先行發生關係。這個關係定義了一些規則讓程序員在併發編程時思路更清晰。

線程內的代碼可以按前後順序執行，這被稱爲程序次序規則。

對於同一個鎖，一個解鎖操做必定要發生在時間上後發生的另外一個鎖定操做以前，也叫作管程鎖定規則。

前一個對volatile的寫操做在後一個volatile的讀操做以前，也叫volatile變量規則。

一個線程內的任何操做必需在這個線程的 start ()調用以後，也叫做線程啓動規則。

一個線程的全部操做都會在線程終止以前，線程終止規則。

一個對象的終結操做必需在這個對象構造完成以後，也叫對象終結規則。

a先行於b，b先行於c，傳遞性

34. 什麼是線程安全？Vector 是一個線程安全類嗎

若是你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。若是每次運行結果和單線程運行的結果是同樣的，並且其餘的變量的值也和預期的是同樣的，就是線程安全的。一個線程安全的計數器類的同一個實例對象在被多個線程使用的狀況下也不會出現計算失誤。很顯然你能夠將集合類分紅兩組，線程安全和非線程安全的。Vector 是用同步方法來實現線程安全的，而和它類似的 ArrayList 不是線程安全的。

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

競態條件會致使程序在併發狀況下出現一些 bugs。多線程對一些資源的競爭的時候就會產生競態條件，若是首先要執行的程序競爭失敗排到後面執行了，那麼整個程序就會出現一些不肯定的 bugs。這種 bugs 很難發現並且會重複出現，由於線程間的隨機競爭。幾類競態條件check-and-act、讀取-修改-寫入、put-if-absent。

36. Java 中如何中止一個線程

當 run () 或者 call () 方法執行完的時候線程會自動結束，若是要手動結束一個線程，你能夠用 volatile 布爾變量來退出 run ()方法的循環或者是取消任務來中斷線程。其餘情形：異常 - 中止執行 休眠 - 中止執行 阻塞 - 中止執行

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

簡單的說，若是異常沒有被捕獲該線程將會中止執行。Thread.UncaughtExceptionHandler 是用於處理未捕獲異常形成線程忽然中斷狀況的一個內嵌接口。當一個未捕獲異常將形成線程中斷的時候 JVM 會使用 Thread.getUncaughtExceptionHandler ()來查詢線程的 UncaughtExceptionHandler 並將線程和異常做爲參數傳遞給 handler 的 uncaughtException ()方法進行處理。

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

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

39. Java 中 notify 和 notifyAll 有什麼區別

notify ()方法不能喚醒某個具體的線程，因此只有一個線程在等待的時候它纔有用武之地。而 notifyAll ()喚醒全部線程並容許他們爭奪鎖確保了至少有一個線程能繼續運行。

40. 爲何 wait, notify 和 notifyAll 這些方法不在 thread 類裏面

一個很明顯的緣由是 JAVA 提供的鎖是對象級的而不是線程級的。若是線程須要等待某些鎖那麼調用對象中的 wait ()方法就有意義了。若是 wait ()方法定義在 Thread 類中，線程正在等待的是哪一個鎖就不明顯了。簡單的說，因爲 wait，notify 和 notifyAll 都是鎖級別的操做，因此把他們定義在 Object 類中由於鎖屬於對象。

41. 什麼是 FutureTask？

在 Java 併發程序中 FutureTask 表示一個能夠取消的異步運算。它有啓動和取消運算、查詢運算是否完成和取回運算結果等方法。只有當運算完成的時候結果才能取回，若是運算還沒有完成 get 方法將會阻塞。一個 FutureTask 對象能夠對調用了 Callable 和 Runnable 的對象進行包裝，因爲 FutureTask 也是調用了 Runnable 接口因此它能夠提交給 Executor 來執行。

42. Java 中 interrupted 和 isInterruptedd 方法的區別

interrupted是靜態方法，isInterruptedd是一個普通方法

若是當前線程被中斷（沒有拋出中斷異常，不然中斷狀態就會被清除），你調用interrupted方法，第一次會返回true。而後，當前線程的中斷狀態被方法內部清除了。第二次調用時就會返回false。若是你剛開始一直調用isInterrupted，則會一直返回true，除非中間線程的中斷狀態被其餘操做清除了。也就是說isInterrupted 只是簡單的查詢中斷狀態，不會對狀態進行修改。

43. 爲何 wait 和 notify 方法要在同步塊中調用

若是不這麼作，代碼會拋出 IllegalMonitorStateException異常。還有一個緣由是爲了不 wait 和 notify 之間產生競態條件。

44. 爲何你應該在循環中檢查等待條件？

處於等待狀態的線程可能會收到錯誤警報和僞喚醒，若是不在循環中檢查等待條件，程序就會在沒有知足結束條件的狀況下退出。所以，當一個等待線程醒來時，不能認爲它原來的等待狀態仍然是有效的，在 notify 方法調用以後和等待線程醒來以前這段時間它可能會改變。這就是在循環中使用 wait 方法效果更好的緣由。

45. Java 中的同步集合與併發集合有什麼區別

同步集合與併發集合都爲多線程和併發提供了合適的線程安全的集合，不過併發集合的可擴展性更高。在 Java1.5 以前程序員們只有同步集合來用且在多線程併發的時候會致使爭用，阻礙了系統的擴展性。Java1.5加入了併發集合像 ConcurrentHashMap，不只提供線程安全還用鎖分離和內部分區等現代技術提升了可擴展性。它們大部分位於JUC包下。

46. 什麼是線程池？ 爲何要使用它？

建立線程要花費昂貴的資源和時間，若是任務來了才建立線程那麼響應時間會變長，並且一個進程能建立的線程數有限。爲了不這些問題，在程序啓動的時候就建立若干線程來響應處理，它們被稱爲線程池，裏面的線程叫工做線程。從 JDK1.5 開始，Java API 提供了 Executor 框架讓你能夠建立不一樣的線程池。好比單線程池，每次處理一個任務；數目固定的線程池或者是緩存線程池（一個適合不少生存期短的任務的程序的可擴展線程池）。

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

在現實中你解決的許多線程問題都屬於生產者消費者模型，就是一個線程生產任務供其它線程進行消費，你必須知道怎麼進行線程間通訊來解決這個問題。比較低級的辦法是用 wait 和 notify 來解決這個問題，比較讚的辦法是用 Semaphore 或者 BlockingQueue 來實現生產者消費者模型。

48.如何避免死鎖？

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

互斥條件：一個資源每次只能被一個進程使用。

請求與保持條件：一個進程因請求資源而阻塞時，對已得到的資源保持不放。

不剝奪條件：進程已得到的資源，在末使用完以前，不能強行剝奪。

循環等待條件：若干進程之間造成一種頭尾相接的循環等待資源關係。

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

49. Java 中活鎖和死鎖有什麼區別？

活鎖和死鎖相似，不一樣之處在於處於活鎖的線程或進程的狀態是不斷改變的，活鎖能夠認爲是一種特殊的飢餓。一個現實的活鎖例子是兩我的在狹小的走廊碰到，兩我的都試着避讓對方好讓彼此經過，可是由於避讓的方向都同樣致使最後誰都不能經過走廊。簡單的說就是，活鎖和死鎖的主要區別是前者進程的狀態能夠改變可是卻不能繼續執行。

50. 怎麼檢測一個線程是否擁有鎖

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

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

在 Linux 下，你能夠經過命令 kill -3 PID （Java 進程的進程 ID）來獲取 Java 應用的 dump 文件。在 Windows 下，你能夠按下 Ctrl + Break 來獲取。這樣 JVM 就會將線程的 dump 文件打印到標準輸出或錯誤文件中，它可能打印在控制檯或者日誌文件中，具體位置依賴應用的配置。

52.Java 中 synchronized 和 ReentrantLock 有什麼不一樣

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

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

能夠用線程類的 join ()方法。具體操做是在T3的run方法中調用t2.join()，讓t2執行完再執行t3；T2的run方法中調用t1.join()，讓t1執行完再執行t2。這樣就按T1，T2，T3的順序執行了

54.Thread 類中的 yield 方法有什麼做用

Yield 方法能夠暫停當前正在執行的線程對象，讓其它有相同優先級的線程執行。它是一個靜態方法並且只保證當前線程放棄 CPU 佔用而不能保證使其它線程必定能佔用 CPU，執行 yield的線程有可能在進入到暫停狀態後立刻又被執行。

55.Java 中 ConcurrentHashMap 的併發度是什麼

ConcurrentHashMap 把實際 map 劃分紅若干部分來實現它的可擴展性和線程安全。這種劃分是使用併發度得到的，它是 ConcurrentHashMap 類構造函數的一個可選參數，默認值爲 16，這樣在多線程狀況下就能避免爭用。

56.Java 中 Semaphore是什麼

JUC下的一種新的同步類，它是一個計數信號。從概念上講，Semaphore信號量維護了一個許可集合。acquire獲取許可，release釋放一個許可，從而可能釋放一個正在阻塞的獲取者。可是，不使用實際的許可對象，Semaphore 只對可用許可的號碼進行計數，並採起相應的行動。信號量經常用於多線程的代碼中，好比數據庫鏈接池。

57.若是你提交任務時，線程池隊列已滿。會發會生什麼？

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

58.Java 線程池中 submit () 和 execute ()方法有什麼區別

兩個方法均可以向線程池提交任務，execute ()方法的返回類型是 void，它定義在 Executor 接口中， 而 submit ()方法能夠返回持有計算結果的 Future 對象，它定義在 ExecutorService 接口中，它擴展了 Executor 接口，其它線程池類像 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 都有這些方法。

59.什麼是阻塞式方法？

阻塞式方法是指程序會一直等待該方法完成期間不作其餘事情，ServerSocket 的 accept ()方法就是一直等待客戶端鏈接。這裏的阻塞是指調用結果返回以前，當前線程會被掛起，直到獲得結果以後纔會返回。此外，還有異步和非阻塞式方法在任務完成前就返回。

60.Swing 是線程安全的嗎？

你能夠很確定的給出回答，Swing 不是線程安全的。你不能經過任何線程來更新 Swing 組件，如 JTable、JList 或 JPanel，事實上，它們只能經過 GUI 或 AWT 線程來更新。這就是爲何 Swing 提供 invokeAndWait() 和 invokeLater() 方法來獲取其餘線程的 GUI 更新請求。這些方法將更新請求放入 AWT 的線程隊列中，能夠一直等待，也能夠經過異步更新直接返回結果。

61.Java 中 invokeAndWait 和 invokeLater 有什麼區別

這兩個方法是 Swing API 提供給 Java 開發者用來從當前線程而不是事件派發線程更新 GUI 組件用的。InvokeAndWait ()同步更新 GUI 組件，好比一個進度條，一旦進度更新了，進度條也要作出相應改變。若是進度被多個線程跟蹤，那麼就調用 invokeAndWait ()方法請求事件派發線程對組件進行相應更新。而 invokeLater ()方法是異步調用更新組件的。

62.Swing API 中那些方法是線程安全的？

雖然Swing不是線程安全的可是有一些方法是能夠被多線程安全調用的。如repaint ()， revalidate ()。 JTextComponent 的 setText ()方法和 JTextArea 的 insert () 和 append () 方法也是線程安全的。

63.如何在 Java 中建立 Immutable 對象

Immutable 對象能夠在沒有同步的狀況下共享，下降了對該對象進行併發訪問時的同步化開銷。但是 Java 沒有@Immutable 這個註解符，要建立不可變類，要實現下面幾個步驟：經過構造方法初始化全部成員、對變量不要提供 setter 方法、將全部的成員聲明爲私有的，這樣就不容許直接訪問這些成員、在 getter 方法中，不要直接返回對象自己，而是克隆對象，並返回對象的拷貝。

64.Java 中的 ReadWriteLock 是什麼？

通常而言，讀寫鎖是用來提高併發程序性能的鎖分離技術的成果。Java 中的 ReadWriteLock 是 Java 5 中新增的一個接口，一個 ReadWriteLock 維護一對關聯的鎖，一個用於只讀操做一個用於寫。在沒有寫線程的狀況下一個讀鎖可能會同時被多個讀線程持有。寫鎖是獨佔的，你可使用 JDK 中的 ReentrantReadWriteLock 來實現這個規則，它最多支持 65535 個寫鎖和 65535 個讀鎖。

65.多線程中的忙循環是什麼?

忙循環就是程序員用循環讓一個線程等待，不像傳統方法 wait ()， sleep () 或 yield () 它們都放棄了 CPU 控制，而忙循環不會放棄 CPU，它就是在運行一個空循環。這麼作的目的是爲了保留 CPU 緩存，在多核系統中，一個等待線程醒來的時候可能會在另外一個內核運行，這樣會重建緩存。爲了不重建緩存和減小等待重建的時間就可使用它了。

66.volatile 變量和 atomic 變量有什麼不一樣

volatile 變量和 atomic 變量看起來很像，但功能卻不同。volatile 變量能夠確保先行關係，即寫操做會發生在後續的讀操做以前， 但它並不能保證原子性。例如用 volatile 修飾 count 變量那麼 count++ 操做並非原子性的。而 AtomicInteger 類提供的 atomic 方法可讓這種操做具備原子性如 getAndIncrement ()方法會原子性的進行增量操做把當前值加一，其它數據類型和引用變量也能夠進行類似操做。

67.若是同步塊內的線程拋出異常會發生什麼？

不管你的同步塊是正常仍是異常退出的，裏面的線程都會釋放鎖，因此對比鎖接口我更喜歡同步塊，由於它不用我花費精力去釋放鎖，該功能能夠在 finally block 裏釋放鎖實現。

68.如何在 Java 中建立線程安全的 Singleton

5種，急加載，同步方法，雙檢鎖，靜態內部類，枚舉

69.如何強制啓動一個線程？

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

70.Java 中的 fork join 框架是什麼？

fork join 框架是 JDK7 中出現的一款高效的工具，Java 開發人員能夠經過它充分利用現代服務器上的多處理器。它是專門爲了那些能夠遞歸劃分紅許多子模塊設計的，目的是將全部可用的處理能力用來提高程序的性能。fork join 框架一個巨大的優點是它使用了工做竊取算法，能夠完成更多任務的工做線程能夠從其它線程中竊取任務來執行。

71.Java 多線程中調用 wait () 和 sleep ()方法有什麼不一樣？

Java 程序中 wait 和 sleep 都會形成某種形式的暫停，它們能夠知足不一樣的須要。wait ()方法意味着條件等待，若是等待條件爲真且其它線程被喚醒時它會釋放鎖，而 sleep ()方法僅僅釋放 CPU 資源或者讓當前線程短暫停頓，但不會釋放鎖。

72.可重入鎖

可重入鎖：若是當前線程已經得到了某個監視器對象所持有的鎖，那麼該線程在該方法中調用另一個同步方法也一樣持有該鎖。

public synchrnozied void test() {
    xxxxxx;
    test2();
}

public synchronized void test2() {
    yyyyy;
}複製代碼

在上面代碼段中，執行 test 方法須要得到當前對象做爲監視器的對象鎖，但方法中又調用了 test2 的同步方法。

若是鎖是具備可重入性的話，那麼該線程在調用 test2 時並不須要再次得到當前對象的鎖，能夠直接進入 test2 方法進行操做。

若是鎖是不具備可重入性的話，那麼該線程在調用test2前會等待當前對象鎖的釋放，實際上該對象鎖已被當前線程所持有，不可能再次得到。

若是鎖是不具備可重入性特色的話，那麼線程在調用同步方法、含有鎖的方法時就會產生死鎖。

73. 同步方法和同步代碼塊

同步方法默認用this或者當前類class對象做爲鎖；同步代碼塊能夠選擇以什麼來加鎖，比同步方法要更細顆粒度，咱們能夠選擇只同步會發生同步問題的部分代碼而不是整個方法。

【感謝您能看完，若是可以幫到您，麻煩點個贊~】

更多經驗技術歡迎前來共同窗習交流：一點課堂-爲夢想而奮鬥的在線學習平臺 http://www.yidiankt.com/

![關注公衆號，回覆「1」免費領取-【java核心知識點】]

QQ討論羣：616683098

QQ：3184402434

想要深刻學習的同窗們能夠加我QQ一塊兒學習討論~還有全套資源分享，經驗探討，等你哦!