本文轉自：公衆号JAVA https://mp.weixin.qq.com/s/EZPc2tO8WX6fV2iag70how
10個最棘手的Java面試問題清單。這些問題主要來自 Java 核心部分 ,不涉及 Java EE 相關問題。你可能知道這些棘手的 Java 問題的答案，或者覺得這些不足以挑戰你的 Java 知識，但這些問題都是容易在各種 Java 面試中被問到的。
1.為什麼等待和通知是在 Object 類而不是 Thread 中聲明的？
為什麼 wait，notify 和 notifyAll 是在 Object 類中定義的而不是在 Thread 類中定義
這是有名的 Java 面試問題，招2~4年經驗的到進階 Java 開發人員面試都可能碰到。
這個問題的好在它能反映了面試者對等待通知機制的了解, 以及他對此主題的了解是否明确。就像為什麼 Java 中不支援多繼承或者為什麼 String 在 Java 中是 final 的問題一樣，這個問題也可能有多個答案。
為什麼在 Object 類中定義 wait 和 notify 方法，每個人都能說出一些理由。從我的面試經驗來看, wait 和 nofity 仍然是大多數Java 程式員最困惑的，特别是2到3年的開發人員，如果他們要求使用 wait 和 notify, 他們會很困惑。是以，如果你去參加 Java 面試，請確定對 wait 和 notify 機制有充分的了解，并且可以輕松地使用 wait 來編寫代碼，并通過生産者-消費者問題或實作阻塞隊列等了解通知的機制。
為什麼等待和通知需要從同步塊或方法中調用, 以及 Java 中的 wait，sleep 和 yield 方法之間的差異，如果你還沒有讀過，你會覺得有趣。為何 wait，notify 和 notifyAll 屬于 Object 類? 為什麼它們不應該在 Thread 類中? 以下是我認為有意義的一些想法：
1) wait 和 notify 不僅僅是普通方法或同步工具，更重要的是它們是 Java 中兩個線程之間的通信機制。對語言設計者而言, 如果不能通過 Java 關鍵字(例如 synchronized)實作通信此機制，同時又要確定這個機制對每個對象可用, 那麼 Object 類則是的正确聲明位置。記住同步和等待通知是兩個不同的領域，不要把它們看成是相同的或相關的。同步是提供互斥并確定 Java 類的線程安全，而 wait 和 notify 是兩個線程之間的通信機制。
2) 每個對象都可上鎖，這是在 Object 類而不是 Thread 類中聲明 wait 和 notify 的另一個原因。
3) 在 Java 中為了進入代碼的臨界區，線程需要鎖定并等待鎖定，他們不知道哪些線程持有鎖，而隻是知道鎖被某個線程持有， 并且他們應該等待取得鎖, 而不是去了解哪個線程在同步塊内，并請求它們釋放鎖定。
4) Java 是基于 Hoare 的螢幕的思想。在Java中，所有對象都有一個螢幕。
線程在螢幕上等待，為執行等待，我們需要2個參數：
一個線程
一個螢幕(任何對象)
在 Java 設計中，線程不能被指定，它總是運作目前代碼的線程。但是，我們可以指定螢幕(這是我們稱之為等待的對象)。這是一個很好的設計，因為如果我們可以讓任何其他線程在所需的螢幕上等待，這将導緻“入侵”，導緻在設計并發程式時會遇到困難。請記住，在 Java 中，所有在另一個線程的執行中侵入的操作都被棄用了(例如 stop 方法)。
2.為什麼Java中不支援多重繼承？
這個 Java 核心問題很難回答，因為你的答案可能不會讓面試官滿意，在大多數情況下，面試官正在尋找答案中的關鍵點，如果你提到這些關鍵點，面試官會很高興。在 Java 中回答這種棘手問題的關鍵是準備好相關主題, 以應對後續的各種可能的問題。
這是非常經典的問題，與為什麼 String 在 Java 中是不可變的很類似; 這兩個問題之間的相似之處在于它們主要是由 Java 創作者的設計決策使然。
為什麼Java不支援多重繼承, 可以考慮以下兩點:
1)第一個原因是圍繞鑽石形繼承問題産生的歧義，考慮一個類 A 有 foo() 方法, 然後 B 和 C 派生自 A, 并且有自己的 foo() 實作，現在 D 類使用多個繼承派生自 B 和C，如果我們隻引用 foo(), 編譯器将無法決定它應該調用哪個 foo()。這也稱為 Diamond 問題，因為這個繼承方案的結構類似于菱形，見下面代碼：
A foo()
/
/
foo() B C foo()
/
/
D foo() 即使我們删除鑽石的頂部 A 類并允許多重繼承，我們也将看到這個問題含糊性的一面。如果你把這個理由告訴面試官，他會問為什麼 C++ 可以支援多重繼承而 Java不行。嗯，在這種情況下，我會試着向他解釋我下面給出的第二個原因，它不是因為技術難度, 而是更多的可維護和更清晰的設計是驅動因素, 雖然這隻能由 Java 言語設計師确認，我們隻是推測。維基百科連結有一些很好的解釋，說明在使用多重繼承時，由于鑽石問題，不同的語言位址問題是如何産生的。
2)對我來說第二個也是更有說服力的理由是，多重繼承确實使設計複雜化并在轉換、構造函數連結等過程中産生問題。假設你需要多重繼承的情況并不多，簡單起見，明智的決定是省略它。此外，Java 可以通過使用接口支援單繼承來避免這種歧義。由于接口隻有方法聲明而且沒有提供任何實作，是以隻有一個特定方法的實作，是以不會有任何歧義。
3.為什麼Java不支援運算符重載？
為什麼 C++ 支援運算符重載而 Java 不支援? 有人可能會說+運算符在 Java 中已被重載用于字元串連接配接，不要被這些論據所欺騙。
與 C++ 不同，Java 不支援運算符重載。Java 不能為程式員提供自由的标準算術運算符重載，例如+， - ，*和/等。如果你以前用過 C++，那麼 Java 與 C++ 相比少了很多功能，例如 Java 不支援多重繼承，Java中沒有指針，Java中沒有引用傳遞。另一個類似的問題是關于 Java 通過引用傳遞，這主要表現為 Java 是通過值還是引用傳參。雖然我不知道背後的真正原因，但我認為以下說法有些道理，為什麼 Java 不支援運算符重載。
1)簡單性和清晰性。清晰性是Java設計者的目标之一。設計者不是隻想複制語言，而是希望擁有一種清晰，真正面向對象的語言。添加運算符重載比沒有它肯定會使設計更複雜，并且它可能導緻更複雜的編譯器, 或減慢 JVM，因為它需要做額外的工作來識别運算符的實際含義，并減少優化的機會, 以保證 Java 中運算符的行為。
2)避免程式設計錯誤。Java 不允許使用者定義的運算符重載，因為如果允許程式員進行運算符重載，将為同一運算符賦予多種含義，這将使任何開發人員的學習曲線變得陡峭，事情變得更加混亂。據觀察，當語言支援運算符重載時，程式設計錯誤會增加，進而增加了開發和傳遞時間。由于 Java 和 JVM 已經承擔了大多數開發人員的責任，如在通過提供垃圾收集器進行記憶體管理時，因為這個功能增加污染代碼的機會, 成為程式設計錯誤之源, 是以沒有多大意義。
3)JVM複雜性。從JVM的角度來看，支援運算符重載使問題變得更加困難。通過更直覺，更幹淨的方式使用方法重載也能實作同樣的事情，是以不支援 Java 中的運算符重載是有意義的。與相對簡單的 JVM 相比，複雜的 JVM 可能導緻 JVM 更慢，并為保證在 Java 中運算符行為的确定性進而減少了優化代碼的機會。
4)讓開發工具處理更容易。這是在 Java 中不支援運算符重載的另一個好處。省略運算符重載使語言更容易處理，這反過來又更容易開發處理語言的工具，例如 IDE 或重構工具。Java 中的重構工具遠勝于 C++。
4.為什麼 String 在 Java 中是不可變的？
一些面試者也常問這個問題，為什麼 String 在 Java 中是 final 的。
字元串在 Java 中是不可變的，因為 String 對象緩存在 String 池中。由于緩存的字元串在多個客戶之間共享，是以始終存在風險，其中一個客戶的操作會影響所有其他客戶。例如，如果一段代碼将 String “Test” 的值更改為 “TEST”，則所有其他客戶也将看到該值。由于 String 對象的緩存性能是很重要的一方面，是以通過使 String 類不可變來避免這種風險。
同時，String 是 final 的，是以沒有人可以通過擴充和覆寫行為來破壞 String 類的不變性、緩存、散列值的計算等。String 類不可變的另一個原因可能是由于 HashMap。
由于把字元串作為 HashMap 鍵很受歡迎。對于鍵值來說，重要的是它們是不可變的，以便用它們檢索存儲在 HashMap 中的值對象。由于 HashMap 的工作原理是散列，是以需要具有相同的值才能正常運作。如果在插入後修改了 String 的内容，可變的 String将在插入和檢索時生成兩個不同的哈希碼，可能會丢失 Map 中的值對象。
如果你是印度闆球迷，你可能能夠與我的下一句話聯系起來。字元串是Java的 VVS Laxman，即非常特殊的類。我還沒有看到一個沒有使用 String 編寫的 Java 程式。這就是為什麼對 String 的充分了解對于 Java 開發人員來說非常重要。
String 作為資料類型，傳輸對象和中間人角色的重要性和流行性也使這個問題在 Java 面試中很常見。
為什麼 String 在 Java 中是不可變的是 Java 中最常被問到的字元串通路問題之一，它首先讨論了什麼是 String，Java 中的 String 如何與 C 和 C++ 中的 String 不同，然後轉向在Java中什麼是不可變對象，不可變對象有什麼好處，為什麼要使用它們以及應該使用哪些場景。
這個問題有時也會問：“為什麼 String 在 Java 中是 final 的”。在類似的說明中，如果你正在準備Java 面試，我建議你看看《Java程式員面試寶典(第4版) 》，這是進階和中級Java程式員的優秀資源。它包含來自所有重要 Java 主題的問題，包括多線程，集合，GC，JVM内部以及 Spring和 Hibernate 架構等。
正如我所說，這個問題可能有很多可能的答案，而 String 類的唯一設計者可以放心地回答它。我在 Joshua Bloch 的 Effective Java 書中期待一些線索，但他也沒有提到它。我認為以下幾點解釋了為什麼 String 類在 Java 中是不可變的或 final 的：
1)想象字元串池沒有使字元串不可變，它根本不可能，因為在字元串池的情況下，一個字元串對象/文字，例如 “Test” 已被許多參考變量引用，是以如果其中任何一個更改了值，其他參數将自動受到影響，即假設
String A="Test";
String B="Test"; 現在字元串 B 調用 "Test".toUpperCase(), 将同一個對象改為“TEST”，是以 A 也是 “TEST”，這不是期望的結果。
下圖顯示了如何在堆記憶體和字元串池中建立字元串。
2)字元串已被廣泛用作許多 Java 類的參數，例如，為了打開網絡連接配接，你可以将主機名和端口号作為字元串傳遞，你可以将資料庫 URL 作為字元串傳遞, 以打開資料庫連接配接，你可以通過将檔案名作為參數傳遞給 File I/O 類來打開 Java 中的任何檔案。如果 String 不是不可變的，這将導緻嚴重的安全威脅，我的意思是有人可以通路他有權授權的任何檔案，然後可以故意或意外地更改檔案名并獲得對該檔案的通路權限。由于不變性，你無需擔心這種威脅。這個原因也說明了，為什麼 String 在 Java 中是最終的，通過使 java.lang.String final，Java設計者確定沒有人覆寫 String 類的任何行為。
3)由于 String 是不可變的，它可以安全地共享許多線程，這對于多線程程式設計非常重要. 并且避免了 Java 中的同步問題，不變性也使得String 執行個體在 Java 中是線程安全的，這意味着你不需要從外部同步 String 操作。關于 String 的另一個要點是由截取字元串 SubString 引起的記憶體洩漏，這不是與線程相關的問題，但也是需要注意的。
4)為什麼 String 在 Java 中是不可變的另一個原因是允許 String 緩存其哈希碼，Java 中的不可變 String 緩存其哈希碼，并且不會在每次調用 String 的 hashcode 方法時重新計算，這使得它在 Java 中的 HashMap 中使用的 HashMap 鍵非常快。簡而言之，因為 String 是不可變的，是以沒有人可以在建立後更改其内容，這保證了 String 的 hashCode 在多次調用時是相同的。
5)String 不可變的絕對最重要的原因是它被類加載機制使用，是以具有深刻和基本的安全考慮。如果 String 是可變的，加載“java.io.Writer” 的請求可能已被更改為加載 “mil.vogoon.DiskErasingWriter”. 安全性和字元串池是使字元串不可變的主要原因。順便說一句，上面的理由很好回答另一個Java面試問題: “為什麼String在Java中是最終的”。要想是不可變的，你必須是最終的，這樣你的子類不會破壞不變性。你怎麼看？
5.為什麼 char 數組比 Java 中的 String 更适合存儲密碼？
一個基于 String 的棘手 Java 問題，相信我隻有很少的 Java 程式員可以正确回答這個問題。這是一個真正艱難的核心Java面試問題，并且需要對 String 的紮實知識才能回答這個問題。
這是最近在 Java 面試中向我的一位朋友詢問的問題。他正在接受技術主管職位的面試，并且有超過6年的經驗。如果你還沒有遇到過這種情況，那麼字元數組和字元串可以用來存儲文本資料，但是選擇一個而不是另一個很難。但正如我的朋友所說，任何與 String 相關的問題都必須對字元串的特殊屬性有一些線索，比如不變性，他用它來說服訪提問的人。在這裡，我們将探讨為什麼你應該使用char[]存儲密碼而不是String的一些原因。
字元串：
1)由于字元串在 Java 中是不可變的，如果你将密碼存儲為純文字，它将在記憶體中可用，直到垃圾收集器清除它. 并且為了可重用性，會存在 String 在字元串池中, 它很可能會保留在記憶體中持續很長時間，進而構成安全威脅。
由于任何有權通路記憶體轉儲的人都可以以明文形式找到密碼，這是另一個原因，你應該始終使用加密密碼而不是純文字。由于字元串是不可變的，是以不能更改字元串的内容，因為任何更改都會産生新的字元串，而如果你使用char[]，你就可以将所有元素設定為空白或零。是以，在字元數組中存儲密碼可以明顯降低竊取密碼的安全風險。
2)Java 本身建議使用 JPasswordField 的 getPassword() 方法，該方法傳回一個 char[] 和不推薦使用的getTex() 方法，該方法以明文形式傳回密碼，由于安全原因。應遵循 Java 團隊的建議, 堅持标準而不是反對它。
3)使用 String 時，總是存在在日志檔案或控制台中列印純文字的風險，但如果使用 Array，則不會列印數組的内容而是列印其記憶體位置。雖然不是一個真正的原因，但仍然有道理。
String strPassword =“Unknown”;
char [] charPassword = new char [] {'U'，'n'，'k'，'w'，'o'，'n'};
System.out.println(“字元密碼：”+ strPassword);
System.out.println(“字元密碼：”+ charPassword); 輸出
字元串密碼：Unknown
字元密碼：[C @110b053 我還建議使用散列或加密的密碼而不是純文字，并在驗證完成後立即從記憶體中清除它。是以,在Java中,用字元數組用存儲密碼比字元串是更好的選擇。雖然僅使用char[]還不夠，還你需要擦除内容才能更安全。
6.如何使用雙重檢查鎖定在 Java 中建立線程安全的單例？
這個 Java 問題也常被問: 什麼是線程安全的單例，你怎麼建立它。好吧，在Java 5之前的版本, 使用雙重檢查鎖定建立單例 Singleton 時，如果多個線程試圖同時建立 Singleton 執行個體，則可能有多個 Singleton 執行個體被建立。從 Java 5 開始，使用 Enum 建立線程安全的Singleton很容易。但如果面試官堅持雙重檢查鎖定，那麼你必須為他們編寫代碼。記得使用volatile變量。
為什麼枚舉單例在 Java 中更好
枚舉單例是使用一個執行個體在 Java 中實作單例模式的新方法。雖然Java中的單例模式存在很長時間,但枚舉單例是相對較新的概念,在引入Enum作為關鍵字和功能之後,從Java5開始在實踐中。本文與之前關于 Singleton 的内容有些相關, 其中讨論了有關 Singleton 模式的面試中的常見問題, 以及 10 個 Java 枚舉示例, 其中我們看到了如何通用枚舉可以。這篇文章是關于為什麼我們應該使用Eeame作為Java中的單例,它比傳統的單例方法相比有什麼好處等等。
Java 枚舉和單例模式
Java 中的枚舉單例模式是使用枚舉在 Java 中實作單例模式。單例模式在 Java 中早有應用, 但使用枚舉類型建立單例模式時間卻不長. 如果感興趣, 你可以了解下建構者設計模式和裝飾器設計模式。
1) 枚舉單例易于書寫
這是迄今為止最大的優勢,如果你在Java 5之前一直在編寫單例, 你知道, 即使雙檢查鎖定, 你仍可以有多個執行個體。雖然這個問題通過 Java 記憶體模型的改進已經解決了, 從 Java 5 開始的 volatile 類型變量提供了保證, 但是對于許多初學者來說, 編寫起來仍然很棘手。與同步雙檢查鎖定相比,枚舉單例實在是太簡單了。如果你不相信, 那就比較一下下面的傳統雙檢查鎖定單例和枚舉單例的代碼:
在 Java 中使用枚舉的單例
這是我們通常聲明枚舉的單例的方式,它可能包含執行個體變量和執行個體方法,但為了簡單起見,我沒有使用任何執行個體方法,隻是要注意,如果你使用的執行個體方法且該方法能改變對象的狀态的話, 則需要確定該方法的線程安全。預設情況下,建立枚舉執行個體是線程安全的,但 Enum 上的任何其他方法是否線程安全都是程式員的責任。
/**
* 使用 Java 枚舉的單例模式示例
*/
public enum EasySingleton{
INSTANCE;
} 你可以通過EasySingleton.INSTANCE來處理它,這比在單例上調用getInstance()方法容易得多。
具有雙檢查鎖定的單例示例
下面的代碼是單例模式中雙重檢查鎖定的示例,此處的 getInstance() 方法檢查兩次,以檢視 INSTANCE 是否為空,這就是為什麼它被稱為雙檢查鎖定模式,請記住,雙檢查鎖定是代理之前Java 5,但Java5記憶體模型中易失變量的幹擾,它應該工作完美。
/**
* 單例模式示例,雙重鎖定檢查
*/
public class DoubleCheckedLockingSingleton{
private volatile DoubleCheckedLockingSingleton INSTANCE;
private DoubleCheckedLockingSingleton(){}
public DoubleCheckedLockingSingleton getInstance(){
if(INSTANCE == null){
synchronized(DoubleCheckedLockingSingleton.class){
//double checking Singleton instance
if(INSTANCE == null){
INSTANCE = new DoubleCheckedLockingSingleton();
}
}
}
return INSTANCE;
}
} 你可以調用DoubleCheckedLockingSingleton.getInstance() 來擷取此單例類的通路權限。
現在,隻需檢視建立延遲加載的線程安全的 Singleton 所需的代碼量。使用枚舉單例模式, 你可以在一行中具有該模式, 因為建立枚舉執行個體是線程安全的, 并且由 JVM 進行。
人們可能會争辯說,有更好的方法來編寫 Singleton 而不是雙檢查鎖定方法, 但每種方法都有自己的優點和缺點, 就像我最喜歡在類加載時建立的靜态字段 Singleton, 如下面所示, 但請記住, 這不是一個延遲加載單例:
單例模式用靜态工廠方法
這是我最喜歡的在 Java 中影響 Singleton 模式的方法之一,因為 Singleton 執行個體是靜态的,并且最後一個變量在類首次加載到記憶體時初始化,是以執行個體的建立本質上是線程安全的。
/**
* 單例模式示例與靜态工廠方法
*/
public class Singleton{
//initailzed during class loading
private static final Singleton INSTANCE = new Singleton();
//to prevent creating another instance of Singleton
private Singleton(){}
public static Singleton getSingleton(){
return INSTANCE;
}
} 你可以調用 Singleton.getSingleton() 來擷取此類的通路權限。
2) 枚舉單例自行處理序列化
傳統單例的另一個問題是,一旦實作可序列化接口,它們就不再是 Singleton, 因為 readObject() 方法總是傳回一個新執行個體, 就像 Java 中的構造函數一樣。通過使用 readResolve() 方法, 通過在以下示例中替換 Singeton 來避免這種情況:
//readResolve to prevent another instance of Singleton
private Object readResolve(){
return INSTANCE;
} 如果 Singleton 類保持内部狀态, 這将變得更加複雜, 因為你需要标記為 transient(不被序列化),但使用枚舉單例, 序列化由 JVM 進行。
3) 建立枚舉執行個體是線程安全的
如第 1 點所述,因為 Enum 執行個體的建立在預設情況下是線程安全的, 你無需擔心是否要做雙重檢查鎖定。
總之, 在保證序列化和線程安全的情況下,使用兩行代碼枚舉單例模式是在 Java 5 以後的世界中建立 Singleton 的最佳方式。
7. 編寫 Java 程式時, 如何在 Java 中建立死鎖并修複它？
經典但核心Java面試問題之一。
如果你沒有參與過多線程并發 Java 應用程式的編碼，你可能會失敗。
如何避免 Java 線程死鎖？
如何避免 Java 中的死鎖？是 Java 面試的熱門問題之一, 也是多線程的程式設計中的重口味之一, 主要在招進階程式員時容易被問到, 且有很多後續問題。盡管問題看起來非常基本, 但大多數 Java 開發人員一旦你開始深入, 就會陷入困境。
面試問題總是以“什麼是死鎖？”開始
當兩個或多個線程在等待彼此釋放所需的資源(鎖定)并陷入無限等待即是死鎖。它僅在多任務或多線程的情況下發生。
如何檢測 Java 中的死鎖？
雖然這可以有很多答案, 但我的版本是首先我會看看代碼, 如果我看到一個嵌套的同步塊，或從一個同步的方法調用其他同步方法, 或試圖在不同的對象上擷取鎖, 如果開發人員不是非常小心，就很容易造成死鎖。
另一種方法是在運作應用程式時實際鎖定時找到它, 嘗試采取線程轉儲,在 Linux 中,你可以通過kill -3指令執行此操作, 這将列印應用程式日志檔案中所有線程的狀态, 并且你可以看到哪個線程被鎖定在哪個線程對象上。
你可以使用 fastthread.io 網站等工具分析該線程轉儲, 這些工具允許你上載線程轉儲并對其進行分析。
另一種方法是使用 jConsole 或 VisualVM, 它将顯示哪些線程被鎖定以及哪些對象被鎖定。
如果你有興趣了解故障排除工具和分析線程轉儲的過程, 我建議你看看 Uriah Levy 在多元視覺(PluraIsight)上《分析 Java 線程轉儲》課程。旨在詳細了解 Java 線程轉儲, 并熟悉其他流行的進階故障排除工具。
編寫一個将導緻死鎖的Java程式？
一旦你回答了前面的問題,他們可能會要求你編寫代碼,這将導緻Java死鎖。
這是我的版本之一
/**
* Java 程式通過強制循環等待來建立死鎖。
*
*
*/
public class DeadLockDemo {
/*
* 此方法請求兩個鎖,第一個字元串,然後整數
*/
public void method1() {
synchronized (String.class) {
System.out.println("Aquired lock on String.class object");
synchronized (Integer.class) {
System.out.println("Aquired lock on Integer.class object");
}
}
}
/*
* 此方法也請求相同的兩個鎖,但完全
* 相反的順序,即首先整數,然後字元串。
* 如果一個線程持有字元串鎖,則這會産生潛在的死鎖
* 和其他持有整數鎖,他們等待對方,永遠。
*/
public void method2() {
synchronized (Integer.class) {
System.out.println("Aquired lock on Integer.class object");
synchronized (String.class) {
System.out.println("Aquired lock on String.class object");
}
}
}
} 如果 method1() 和 method2() 都由兩個或多個線程調用,則存在死鎖的可能性, 因為如果線程 1 在執行 method1() 時在 Sting 對象上擷取鎖, 線程 2 在執行 method2() 時在 Integer 對象上擷取鎖, 等待彼此釋放 Integer 和 String 上的鎖以繼續進行一步, 但這永遠不會發生。
此圖精确示範了我們的程式, 其中一個線程在一個對象上持有鎖, 并等待其他線程持有的其他對象鎖。
你可以看到, Thread1 需要 Thread2 持有的 Object2 上的鎖,而 Thread2 希望獲得 Thread1 持有的 Object1 上的鎖。由于沒有線程願意放棄, 是以存在死鎖, Java 程式被卡住。
其理念是, 你應該知道使用常見并發模式的正确方法, 如果你不熟悉這些模式,那麼 Jose Paumard 《應用于并發和多線程的常見 Java 模式》是學習的好起點。
如何避免Java中的死鎖？
現在面試官來到最後一部分, 在我看來, 最重要的部分之一; 如何修複代碼中的死鎖？或如何避免Java中的死鎖？
如果你仔細檢視了上面的代碼,那麼你可能已經發現死鎖的真正原因不是多個線程, 而是它們請求鎖的方式, 如果你提供有序通路, 則問題将得到解決。
下面是我的修複版本,它通過避免循環等待，而避免死鎖, 而不需要搶占, 這是需要死鎖的四個條件之一。
public class DeadLockFixed {
/**
* 兩種方法現在都以相同的順序請求鎖,首先采用整數,然後是 String。
* 你也可以做反向,例如,第一個字元串,然後整數,
* 隻要兩種方法都請求鎖定,兩者都能解決問題
* 順序一緻。
*/
public void method1() {
synchronized (Integer.class) {
System.out.println("Aquired lock on Integer.class object");
synchronized (String.class) {
System.out.println("Aquired lock on String.class object");
}
}
}
public void method2() {
synchronized (Integer.class) {
System.out.println("Aquired lock on Integer.class object");
synchronized (String.class) {
System.out.println("Aquired lock on String.class object");
}
}
}
} 現在沒有任何死鎖,因為兩種方法都按相同的順序通路 Integer 和 String 類文本上的鎖。是以,如果線程 A 在 Integer 對象上擷取鎖, 則線程 B 不會繼續, 直到線程 A 釋放 Integer 鎖, 即使線程 B 持有 String 鎖, 線程 A 也不會被阻止, 因為現線上程 B 不會期望線程 A 釋放 Integer 鎖以繼續。
8. 如果你的Serializable類包含一個不可序列化的成員，會發生什麼？你是如何解決的？
任何序列化該類的嘗試都會因NotSerializableException而失敗，但這可以通過在 Java中 為 static 設定瞬态(trancient)變量來輕松解決。
Java 序列化相關的常見問題
Java 序列化是一個重要概念, 但它很少用作持久性解決方案, 開發人員大多忽略了 Java 序列化 API。根據我的經驗, Java 序列化在任何 Java核心内容面試中都是一個相當重要的話題, 在幾乎所有的網面試中, 我都遇到過一兩個 Java 序列化問題, 我看過一次面試, 在問幾個關于序列化的問題之後候選人開始感到不自在, 因為缺乏這方面的經驗。
他們不知道如何在 Java 中序列化對象, 或者他們不熟悉任何 Java 示例來解釋序列化, 忘記了諸如序列化在 Java 中如何工作, 什麼是标記接口, 标記接口的目的是什麼, 瞬态變量和可變變量之間的差異, 可序列化接口具有多少種方法, 在 Java 中,Serializable 和 Externalizable 有什麼差別, 或者在引入注解之後, 為什麼不用 @Serializable 注解或替換 Serializalbe 接口。
大多數商業項目使用資料庫或記憶體映射檔案或隻是普通檔案, 來滿足持久性要求, 隻有很少的項目依賴于 Java 中的序列化過程。無論如何,這篇文章不是 Java 序列化教程或如何序列化在 Java 的對象, 但有關序列化機制和序列化 API 的面試問題, 這是值得去任何 Java 面試前先看看以免讓一些未知的内容驚到自己。
對于那些不熟悉 Java 序列化的人, Java 序列化是用來通過将對象的狀态存儲到帶有.ser擴充名的檔案來序列化 Java 中的對象的過程, 并且可以通過這個檔案恢複重建 Java對象狀态, 這個逆過程稱為 deserialization。
什麼是 Java 序列化
序列化是把對象改成可以存到磁盤或通過網絡發送到其他運作中的 Java 虛拟機的二進制格式的過程, 并可以通過反序列化恢複對象狀态. Java 序列化API給開發人員提供了一個标準機制, 通過 java.io.Serializable 和 java.io.Externalizable 接口, ObjectInputStream 及ObjectOutputStream 處理對象序列化. Java 程式員可自由選擇基于類結構的标準序列化或是他們自定義的二進制格式, 通常認為後者才是最佳實踐, 因為序列化的二進制檔案格式成為類輸出 API的一部分, 可能破壞 Java 中私有和包可見的屬性的封裝.
如何序列化
讓 Java 中的類可以序列化很簡單. 你的 Java 類隻需要實作 java.io.Serializable 接口, JVM 就會把 Object 對象按預設格式序列化. 讓一個類是可序列化的需要有意為之. 類可序列會可能為是一個長期代價, 可能會是以而限制你修改或改變其實作. 當你通過實作添加接口來更改類的結構時, 添加或删除任何字段可能會破壞預設序列化, 這可以通過自定義二進制格式使不相容的可能性最小化, 但仍需要大量的努力來確定向後相容性。序列化如何限制你更改類的能力的一個示例是 SerialVersionUID。
如果不顯式聲明 SerialVersionUID, 則 JVM 會根據類結構生成其結構, 該結構依賴于類實作接口和可能更改的其他幾個因素。假設你新版本的類檔案實作的另一個接口, JVM 将生成一個不同的 SerialVersionUID 的, 當你嘗試加載舊版本的程式序列化的舊對象時, 你将獲得無效類異常 InvalidClassException。
9. 為什麼Java中 wait 方法需要在 synchronized 的方法中調用？
另一個棘手的核心 Java 問題，wait 和 notify。它們是在有 synchronized 标記的方法或 synchronized 塊中調用的，因為 wait 和 modify 需要監視對其上調用 wait 或 notify-get 的 Object。
大多數Java開發人員都知道對象類的 wait()，notify() 和 notifyAll()方法必須在Java中的 synchronized 方法或 synchronized 塊中調用, 但是我們想過多少次, 為什麼在 Java 中 wait, notify 和 notifyAll 來自 synchronized 塊或方法?
最近這個問題在Java面試中被問到我的一位朋友，他思索了一下，并回答說: 如果我們不從同步上下文中調用 wait() 或 notify() 方法，我們将在 Java 中收到 IllegalMonitorStateException。
他的回答從實際效果上年是正确的，但面試官對這樣的答案不會完全滿意，并希望向他解釋這個問題。面試結束後 他和我讨論了同樣的問題，我認為他應該告訴面試官關于 Java 中 wait()和 notify()之間的競态條件，如果我們不在同步方法或塊中調用它們就可能存在。
讓我們看看競态條件如何在Java程式中發生。它也是流行的線程面試問題之一，并經常在電話和面對面的Java開發人員面試中出現。是以，如果你正在準備Java面試，那麼你應該準備這樣的問題，并且可以真正幫助你的一本書是《Java程式員面試公式書》的。這是一本罕見的書，涵蓋了Java訪談的幾乎所有重要主題，例如核心Java，多線程，IO 和 NIO 以及 Spring 和 Hibernate 等架構。
為什麼要等待來自 Java中的 synchronized 方法的 wait方法為什麼必須從 Java 中的 synchronized 塊或方法調用 ？我們主要使用 wait()，notify() 或 notifyAll() 方法用于 Java 中的線程間通信。一個線程在檢查條件後正在等待，例如，在經典的生産者 - 消費者問題中，如果緩沖區已滿，則生産者線程等待，并且消費者線程通過使用元素在緩沖區中建立空間後通知生産者線程。調用notify()或notifyAll()方法向單個或多個線程發出一個條件已更改的通知，并且一旦通知線程離開 synchronized 塊，正在等待的所有線程開始擷取正在等待的對象鎖定，幸運的線程在重新擷取鎖之後從 wait() 方法傳回并繼續進行。
讓我們将整個操作分成幾步，以檢視Java中wait()和notify()方法之間的競争條件的可能性，我們将使用Produce Consumer 線程示例更好地了解方案：
Producer 線程測試條件(緩沖區是是否完整)并确認必須等待(找到緩沖區已滿)。
Consumer 線程在使用緩沖區中的元素後設定條件。
Consumer 線程調用 notify() 方法; 這是不會被聽到的，因為 Producer 線程還沒有等待。
Producer 線程調用 wait() 方法并進入等待狀态。
是以，由于競态條件，我們可能會丢失通知，如果我們使用緩沖區或隻使用一個元素，生産線程将永遠等待，你的程式将挂起。“在java同步中等待 notify 和 notifyall 現在讓我們考慮如何解決這個潛在的競态條件？
這個競态條件通過使用 Java 提供的 synchronized 關鍵字和鎖定來解決。為了調用 wait()，notify() 或 notifyAll(), 在Java中，我們必須獲得對我們調用方法的對象的鎖定。由于 Java 中的 wait() 方法在等待之前釋放鎖定并在從 wait() 傳回之前重新擷取鎖定方法，我們必須使用這個鎖來確定檢查條件(緩沖區是否已滿)和設定條件(從緩沖區擷取元素)是原子的，這可以通過在 Java 中使用 synchronized 方法或塊來實作。
我不确定這是否是面試官實際期待的，但這個我認為至少有意義，請糾正我如果我錯了，請告訴我們是否還有其他令人信服的理由調用 wait()，notify() 或 Java 中的 notifyAll() 方法。
總結一下，我們用 Java 中的 synchronized 方法或 synchronized 塊調用 Java 中的 wait()，notify() 或 notifyAll() 方法來避免：
1) Java 會抛出 IllegalMonitorStateException，如果我們不調用來自同步上下文的wait()，notify()或者notifyAll()方法。
2) Javac 中 wait 和 notify 方法之間的任何潛在競争條件。
10.你能用Java覆寫靜态方法嗎？如果我在子類中建立相同的方法是編譯時錯誤？
不，你不能在Java中覆寫靜态方法，但在子類中聲明一個完全相同的方法不是編譯時錯誤，這稱為隐藏在Java中的方法。
你不能覆寫Java中的靜态方法，因為方法覆寫基于運作時的動态綁定，靜态方法在編譯時使用靜态綁定進行綁定。雖然可以在子類中聲明一個具有相同名稱和方法簽名的方法，看起來可以在Java中覆寫靜态方法，但實際上這是方法隐藏。Java不會在運作時解析方法調用，并且根據用于調用靜态方法的 Object 類型，将調用相應的方法。這意味着如果你使用父類的類型來調用靜态方法，那麼原始靜态将從父類中調用，另一方面如果你使用子類的類型來調用靜态方法，則會調用來自子類的方法。簡而言之，你無法在Java中覆寫靜态方法。如果你使用像Eclipse或Netbeans這樣的Java IDE，它們将顯示警告靜态方法應該使用類名而不是使用對象來調用，因為靜态方法不能在Java中重寫。
/**
*
* Java program which demonstrate that we can not override static method in Java.
* Had Static method can be overridden, with Super class type and sub class object
* static method from sub class would be called in our example, which is not the case.
*/
public class CanWeOverrideStaticMethod {
public static void main(String args[]) {
Screen scrn = new ColorScreen();
//if we can override static , this should call method from Child class
scrn.show(); //IDE will show warning, static method should be called from classname
}
}
class Screen{
/*
* public static method which can not be overridden in Java
*/
public static void show(){
System.out.printf("Static method from parent class");
}
}
class ColorScreen extends Screen{
/*
* static method of same name and method signature as existed in super
* class, this is not method overriding instead this is called
* method hiding in Java
*/
public static void show(){
System.err.println("Overridden static method in Child Class in Java");
}
} 輸出:
Static method from parent class 此輸出确認你無法覆寫Java中的靜态方法，并且靜态方法基于類型資訊而不是基于Object進行綁定。如果要覆寫靜态mehtod，則會調用子類或 ColorScreen 中的方法。這一切都在讨論中我們可以覆寫Java中的靜态方法。我們已經确認沒有，我們不能覆寫靜态方法，我們隻能在Java中隐藏靜态方法。建立具有相同名稱和mehtod簽名的靜态方法稱為Java隐藏方法。IDE将顯示警告："靜态方法應該使用類名而不是使用對象來調用", 因為靜态方法不能在Java中重寫。
想要擷取更多技術幹貨，釘釘掃碼，關注阿裡雲開發者社群