Java面試題（1）見：https://blog.csdn.net/Number_oneEngineer/article/details/83412521

相關概念

面向物件的三個特徵

封裝，繼承，多型，這個應該是人人皆知，有時候也會加上抽象。

多型的好處

允許不同類物件對同一訊息做出響應，即同一訊息可以根據傳送物件的不同而採用多種不同的行為方式(傳送訊息就是函式呼叫)。主要有以下優點：

1. 可替換性：多型對已存在程式碼具有可替換性
2. 可擴充性：增加新的子類不影響已經存在的類結構
3. 介面性：多型是超類通過方法簽名,向子類提供一個公共介面,由子類來完善或者重寫它來實現的。
4. 靈活性
5. 簡化性

程式碼中如何實現多型

實現多型主要有以下三種方式：

1. 介面實現
2. 繼承父類重寫方法
3. 同一類中進行方法過載

虛擬機器是如何實現多型的

動態繫結技術(dynamic binding)，執行期間判斷所引用物件的實際型別，根據實際型別呼叫對應的方法。

介面的意義

介面的意義用三個詞就可以概括：規範，擴充套件，回撥。

抽象類的意義

抽象類的意義可以用三句話來概括：

1. 為其他子類提供一個公共的型別
2. 封裝子類中重複定義的內容
3. 定義抽象方法,子類雖然有不同的實現，但是定義時一致的

介面和抽象類的區別

父類的靜態方法能否被子類重寫

不能。重寫只適用於例項方法,不能用於靜態方法，而子類當中含有和父類相同簽名的靜態方法，我們一般稱之為隱藏。

什麼是不可變物件？

不可變物件指物件一旦被建立，狀態就不能再改變。任何修改都會建立一個新的物件，如 String、Integer及其它包裝類。

靜態變數和例項變數的區別?

靜態變數儲存在方法區，屬於類所有。例項變數儲存在堆當中，其引用存在當前執行緒棧。

能否建立一個包含可變物件的不可變物件?

當然可以建立一個包含可變物件的不可變物件的，你只需要謹慎一點，不要共享可變物件的引用就可以了，如果需要變化時，就返回原物件的一個拷貝。最常見的例子就是物件中包含一個日期物件的引用。

java 建立物件的幾種方式

1. 採用new
2. 通過反射
3. 採用clone
4. 通過序列化機制

前2者都需要顯式地呼叫構造方法。造成耦合性最高的恰好是第一種，因此你發現無論什麼框架，只要涉及到解耦必先減少new的使用。

switch中能否使用string做引數

在idk 1.7之前，switch只能支援byte, short, char, int或者其對應的封裝類以及Enum型別。從idk 1.7之後switch開始支援String。

switch能否作用在byte, long上?

可以用在byte上，但是不能用在long上。

String s1=”ab”, String s2=”a”+”b”, String s3=”a”, String s4=”b”, s5=s3+s4請問s5==s2返回什麼？

返回false。在編譯過程中，編譯器會將s2直接優化為”ab”，會將其放置在常量池當中，s5則是被建立在堆區，相當於s5=new String(“ab”);

你對String物件的intern()熟悉麼?

intern()方法會首先從常量池中查詢是否存在該常量值，如果常量池中不存在則現在常量池中建立，如果已經存在則直接返回。
比如

String s1=”aa”; 
String s2=s1.intern(); 
System.out.print(s1==s2);//返回true

Object中有哪些公共方法?

1. equals()
2. clone()
3. getClass()
4. notify(),notifyAll(),wait()
5. toString

java當中的四種引用

• 強引用，軟引用，弱引用，虛引用。不同的引用型別主要體現在GC上:
  強引用：如果一個物件具有強引用，它就不會被垃圾回收器回收。即使當前記憶體空間不足，JVM也不會回收它，而是丟擲 OutOfMemoryError 錯誤，使程式異常終止。如果想中斷強引用和某個物件之間的關聯，可以顯式地將引用賦值為null，這樣一來的話，JVM在合適的時間就會回收該物件。
• 軟引用：在使用軟引用時，如果記憶體的空間足夠，軟引用就能繼續被使用，而不會被垃圾回收器回收，只有在記憶體不足時，軟引用才會被垃圾回收器回收。
• 弱引用：具有弱引用的物件擁有的生命週期更短暫。因為當 JVM 進行垃圾回收，一旦發現弱引用物件，無論當前記憶體空間是否充足，都會將弱引用回收。不過由於垃圾回收器是一個優先順序較低的執行緒，所以並不一定能迅速發現弱引用物件。
• 虛引用：顧名思義，就是形同虛設，如果一個物件僅持有虛引用，那麼它相當於沒有引用，在任何時候都可能被垃圾回收器回收。

更多瞭解參見深入物件引用：
http://blog.csdn.net/dd864140130/article/details/49885811

WeakReference與SoftReference的區別?

這點在四種引用型別中已經做了解釋,這裡簡單說明一下即可:
雖然 WeakReference 與 SoftReference 都有利於提高 GC 和 記憶體的效率，但是 WeakReference ，一旦失去最後一個強引用，就會被 GC 回收，而軟引用雖然不能阻止被回收，但是可以延遲到 JVM 記憶體不足的時候。

為什麼要有不同的引用型別

不像C語言，我們可以控制記憶體的申請和釋放，在Java中有時候我們需要適當的控制物件被回收的時機，因此就誕生了不同的引用型別，可以說不同的引用型別實則是對GC回收時機不可控的妥協。有以下幾個使用場景可以充分的說明：

• 1.利用軟引用和弱引用解決OOM問題：用一個HashMap來儲存圖片的路徑和相應圖片物件關聯的軟引用之間的對映關係，在記憶體不足時，JVM會自動回收這些快取圖片物件所佔用的空間，從而有效地避免了OOM的問題.
• 2.通過軟引用實現Java物件的快取記憶體:比如我們建立了一Person的類，如果每次需要查詢一個人的資訊,哪怕是幾秒中之前剛剛查詢過的，都要重新構建一個例項，這將引起大量Person物件的消耗，並且由於這些物件的生命週期相對較短，會引起多次GC影響效能。此時，通過軟引用和 HashMap 的結合可以構建快取記憶體，提供效能。

java中==和eqauls()的區別,equals()和`hashcode的區別

= =是運算子，用於比較兩個變數是否相等，而equals是Object類的方法，用於比較兩個物件是否相等。預設Object類的equals方法是比較兩個物件的地址，此時和= =的結果一樣。換句話說：基本型別比較用 = = ，比較的是他們的值。預設下，物件用= =比較時，比較的是記憶體地址，如果需要比較物件內容，需要重寫equal方法。

equals()和hashcode()的聯絡

hashCode()是Object類的一個方法，返回一個雜湊值。如果兩個物件根據equal()方法比較相等，那麼呼叫這兩個物件中任意一個物件的hashCode()方法必須產生相同的雜湊值。
如果兩個物件根據eqaul()方法比較不相等，那麼產生的雜湊值不一定相等(碰撞的情況下還是會相等的。)

a.hashCode()有什麼用?與a.equals(b)有什麼關係

hashCode() 方法是相應物件整型的 hash 值。它常用於基於 hash 的集合類，如 Hashtable、HashMap、LinkedHashMap等等。它與 equals() 方法關係特別緊密。根據 Java 規範，使用 equal() 方法來判斷兩個相等的物件，必須具有相同的 hashcode。
將物件放入到集合中時，首先判斷要放入物件的hashcode是否已經在集合中存在，不存在則直接放入集合。如果hashcode相等，然後通過equal()方法判斷要放入物件與集合中的任意物件是否相等：如果equal()判斷不相等，直接將該元素放入集合中，否則不放入。

有沒有可能兩個不相等的物件有相同的hashcode

有可能，兩個不相等的物件可能會有相同的 hashcode 值，這就是為什麼在 hashmap 中會有衝突。如果兩個物件相等，必須有相同的hashcode 值，反之不成立。

可以在hashcode中使用隨機數字嗎?

不行，因為同一物件的 hashcode 值必須是相同的

a= =b與a.equals(b)有什麼區別

如果a 和b 都是物件，則 a= =b 是比較兩個物件的引用，只有當 a 和 b 指向的是堆中的同一個物件才會返回 true，而 a.equals(b) 是進行邏輯比較，所以通常需要重寫該方法來提供邏輯一致性的比較。例如，String 類重寫 equals() 方法，所以可以用於兩個不同物件，但是包含的字母相同的比較。

3*0.1==0.3返回值是什麼

false，因為有些浮點數不能完全精確的表示出來。

a=a+b與a+=b有什麼區別嗎?

+=操作符會進行隱式自動型別轉換，此處a+=b隱式的將加操作的結果型別強制轉換為持有結果的型別，而a=a+b則不會自動進行型別轉換。如：

byte a = 127; 
byte b = 127; 
b = a + b; // error : cannot convert from int to byte 
b += a; // ok 

（譯者注：這個地方應該表述的有誤，其實無論 a+b 的值為多少，編譯器都會報錯，因為 a+b 操作會將 a、b 提升為 int 型別，所以將 int 型別賦值給 byte 就會編譯出錯）

short s1= 1; s1 = s1 + 1; 該段程式碼是否有錯,有的話怎麼改？

有錯誤，short型別在進行運算時會自動提升為int型別，也就是說s1+1的運算結果是int型別。
#3 short s1= 1; s1 += 1; 該段程式碼是否有錯，有的話怎麼改？
+=操作符會自動對右邊的表示式結果強轉匹配左邊的資料型別，所以沒錯。

& 和 &&的區別

首先記住&是位操作，而&&是邏輯運算子。另外需要記住邏輯運算子具有短路特性，而&不具備短路特性。

public class Test{
   static String name;
 
   public static void main(String[] args){
       if(name!=null&userName.equals("")){
           System.out.println("ok");
       }else{
           System.out.println("erro");
       }
   }
}

以上程式碼將會丟擲空指標異常。

一個java檔案內部可以有類？(非內部類)

只能有一個public公共類，但是可以有多個default修飾的類。

如何正確的退出多層巢狀迴圈？

使用標號和break;
通過在外層迴圈中新增識別符號

內部類的作用

內部類可以有多個例項，每個例項都有自己的狀態資訊，並且與其他外圍物件的資訊相互獨立.在單個外圍類當中，可以讓多個內部類以不同的方式實現同一介面，或者繼承同一個類.建立內部類物件的時刻不依賴於外部類物件的建立。內部類並沒有令人疑惑的”is-a”管系，它就像是一個獨立的實體。
內部類提供了更好的封裝，除了該外圍類，其他類都不能訪問。

final, finalize和finally的不同之處

final 是一個修飾符，可以修飾變數、方法和類。如果 final 修飾變數，意味著該變數的值在初始化後不能被改變。finalize 方法是在物件被回收之前呼叫的方法，給物件自己最後一個復活的機會，但是什麼時候呼叫 finalize 沒有保證。finally 是一個關鍵字，與 try 和 catch 一起用於異常的處理。finally 塊一定會被執行，無論在 try 塊中是否有發生異常。

clone()是哪個類的方法?

java.lang.Cloneable 是一個標示性介面，不包含任何方法，clone 方法在 object 類中定義。並且需要知道 clone() 方法是一個本地方法，這意味著它是由 c 或 c++ 或 其他本地語言實現的。

深拷貝和淺拷貝的區別是什麼?

• 淺拷貝：被複制物件的所有變數都含有與原來的物件相同的值，而所有的對其他物件的引用仍然指向原來的物件。換言之，淺拷貝僅僅複製所考慮的物件，而不復制它所引用的物件。
• 深拷貝：被複制物件的所有變數都含有與原來的物件相同的值，而那些引用其他物件的變數將指向被複制過的新物件，而不再是原有的那些被引用的物件。換言之，深拷貝把要複製的物件所引用的物件都複製了一遍。

static都有哪些用法?

幾乎所有的人都知道static關鍵字這兩個基本的用法：靜態變數和靜態方法。也就是被static所修飾的變數/方法都屬於類的靜態資源，類例項所共享。
除了靜態變數和靜態方法之外，static也用於靜態塊，多用於初始化操作：

public calss PreCache{
   static{
       //執行相關操作
   }
}

此外static也多用於修飾內部類，此時稱之為靜態內部類。
最後一種用法就是靜態導包，即import static.import static是在JDK 1.5之後引入的新特性，可以用來指定匯入某個類中的靜態資源，並且不需要使用類名。資源名，可以直接使用資源名，比如：

import static java.lang.Math.*;
 
public class Test{
 
   public static void main(String[] args){
       //System.out.println(Math.sin(20));傳統做法
       System.out.println(sin(20));
   }
}

final有哪些用法

final也是很多面試喜歡問的地方，能回答下以下三點就不錯了：
1.被final修飾的類不可以被繼承
2.被final修飾的方法不可以被重寫
3.被final修飾的變數不可以被改變。如果修飾引用，那麼表示引用不可變，引用指向的內容可變。
4.被final修飾的方法，JVM會嘗試將其內聯，以提高執行效率
5.被final修飾的常量，在編譯階段會存入常量池中。

回答出編譯器對final域要遵守的兩個重排序規則更好：

1.在建構函式內對一個final域的寫入，與隨後把這個被構造物件的引用賦值給一個引用變數,這兩個操作之間不能重排序。
2.初次讀一個包含final域的物件的引用，與隨後初次讀這個final域,這兩個操作之間不能重排序。

資料型別相關

java中int char,long各佔多少位元組?

64位的JVM當中,int的長度是多少?

Java 中，int 型別變數的長度是一個固定值，與平臺無關，都是 32 位。意思就是說，在 32 位 和 64 位 的Java 虛擬機器中，int 型別的長度是相同的。

int和Integer的區別

Integer是int的包裝型別，在拆箱和裝箱中，二者自動轉換。int是基本型別，直接存數值，而integer是物件，用一個引用指向這個物件。

int 和Integer誰佔用的記憶體更多?

Integer 物件會佔用更多的記憶體。Integer是一個物件，需要儲存物件的元資料。但是 int 是一個原始型別的資料，所以佔用的空間更少。

String, StringBuffer和StringBuilder區別

String是字串常量，final修飾：StringBuffer字串變數(執行緒安全)；
StringBuilder 字串變數(執行緒不安全)。

String和StringBuffer

String和StringBuffer主要區別是效能：String是不可變物件，每次對String型別進行操作都等同於產生了一個新的String物件，然後指向新的String物件。所以儘量不在對String進行大量的拼接操作，否則會產生很多臨時物件，導致GC開始工作，影響系統性能。
StringBuffer是對物件本身操作，而不是產生新的物件，因此在有大量拼接的情況下，我們建議使用StringBuffer。
但是需要注意現在JVM會對String拼接做一定的優化：
String s=“This is only ”+”simple”+”test”會被虛擬機器直接優化成String s=“This is only simple test”，此時就不存在拼接過程。

StringBuffer和StringBuilder

StringBuffer是執行緒安全的可變字串，其內部實現是可變陣列。StringBuilder是jdk 1.5新增的，其功能和StringBuffer類似，但是非執行緒安全。因此，在沒有多執行緒問題的前提下，使用StringBuilder會取得更好的效能。

什麼是編譯器常量？使用它有什麼風險？

公共靜態不可變（public static final ）變數也就是我們所說的編譯期常量，這裡的 public 可選的。實際上這些變數在編譯時會被替換掉，因為編譯器知道這些變數的值，並且知道這些變數在執行時不能改變。這種方式存在的一個問題是你使用了一個內部的或第三方庫中的公有編譯時常量，但是這個值後面被其他人改變了，但是你的客戶端仍然在使用老的值，甚至你已經部署了一個新的jar。為了避免這種情況，當你在更新依賴 JAR 檔案時，確保重新編譯你的程式。

java當中使用什麼型別表示價格比較好?

如果不是特別關心記憶體和效能的話，使用BigDecimal，否則使用預定義精度的 double 型別。

如何將byte轉為String

可以使用 String 接收 byte[] 引數的構造器來進行轉換，需要注意的點是要使用的正確的編碼，否則會使用平臺預設編碼，這個編碼可能跟原來的編碼相同，也可能不同。
可以將int強轉為byte型別麼?會產生什麼問題?
我們可以做強制轉換，但是Java中int是32位的而byte是8 位的，所以,如果強制轉化int型別的高24位將會被丟棄，byte 型別的範圍是從-128到128

---

關於垃圾回收

你知道哪些垃圾回收演算法?

垃圾回收從理論上非常容易理解,具體的方法有以下幾種:

1. 標記-清除
2. 標記-複製
3. 標記-整理
4. 分代回收
   更詳細的內容參見深入理解垃圾回收演算法：
   http://blog.csdn.net/dd864140130/article/details/50084471

1.標記——清除演算法（Mark-Sweep）

標記——清除演算法是第一種使用和比較完善的垃圾回收演算法，演算法分為兩個過程：1、標記正所有需要回收的物件2、標記完成後清除被標記的物件。其標記的過程就是判斷物件有效性，執行可達性分析的過程。其執行流程圖大體如何下所示：

同樣，我們也藉助現實的場景進行描述。圖書管裡有好多人在看書，圖書管理員想要收集起沒有被看的書的時候，他決定讓所有正在看書的人站起來，然後詢問每個人：那一本書是不看的。詢問完所有的人之後，同學們做下繼續看書。這時候，圖書管理員開始尋找所有做過標記的書，把它們收集起來。

缺點：

1、每次進行垃圾回收時，會暫停當前使用者程式的執行（類似讓所有的同學站起來）
2、垃圾回收器需要間隔性的檢查，並且標記和清除的過程相對較慢。
3、在標記清除之後可能會產生大量記憶體碎片，導致一旦需要為大物件分配空間時，由於找不到足夠大的記憶體空間，而不得以引發另外一次GC過程。

2.標記——複製演算法（Mark——Copy）

標記——複製儲存演算法通過採用雙區域交替使用這種方式解決了標記——清除演算法中效率低下的問題。它將可可用記憶體劃分為兩個等量的區域（使用區和空閒區），每次只使用一塊。當正在使用的區域需要進行垃圾回收時，存活的物件將被複制到另外一塊區域。原先被使用的區域被重置，轉為空閒區。其執行流程大體如下所示：

圖書管理員為了更好的發現不看的書，將圖書室一分為二(A區和B區)，同一時刻只有一塊區域允許看書。開始時只允許在A區看書。當管理員想要回收A區不被看的書的時候，大喊一嗓子“正在看書的同學拿著你書到B區”。等所有人都到了B區後，圖書管理員只要把A區的書收集起來，就完成了任務。下一次收集的時候，則是要求同學帶著自己看的書從B區轉移到A區。如此迴圈往復即可。

缺點：

1、原有可用空間被縮小為1/2，空間利用率降低了。
2、過程中也會暫停當前應用的執行。

3.標記——整理演算法（Mark——Compat）

標記-複製演算法在物件存活率較高的情況下就要進行較多的複製操作，更重要的是該演算法浪費一般的記憶體空間，為了解決該問題，出現了標記——整理演算法：其標記的過程和“標記-清除”演算法一樣，而整理的過程則是讓所有存活的物件都想另外一端移動，然後直接清理掉端邊界以外的記憶體。其執行流程大體如下所示：

缺點：

1、暫停當前應用的執行，非實時性的回收。

4.分代收集演算法

分代收集演算法理論來源於統計學。IBM公司的專門研究發現，物件的生存週期總體可分為三種：新生代、老年代和永久代。因此可以根據各個年代的特點採用適當的垃圾回收演算法。比如新生代的物件在每次垃圾時都會有大量的物件死去，只有很少一部分存活，那就可以選擇標記-複製演算法。另外I，在新生代中每次死亡物件約佔98%，那麼在標記-複製演算法中就不需要按照1：1的比例來劃分記憶體區域，而是將新生代細分為了一塊較大的Eden和兩塊較小的Survivor區域，HotSpot中預設這兩塊區域的大小比例為8：2。每次新生代可用區域為Eden加上其中一塊Survivor區域，共90%的記憶體空間，這樣就只有10%的記憶體空間處在被閒置狀態。在進行垃圾回收時，存活的物件被轉移到原本處在“空閒的”Eden區域。如果某次垃圾回收後，存活物件所佔空間遠大於這10%的記憶體空間時，也就是Survivor空間不夠用時，需要額外的空間來擔保，通常是將這些物件轉移到老年代。對於老年代來說，大部分物件都處在存活狀態。同時，如果一個大物件要在該區域進行分配，而記憶體空間又不足，那麼在沒有外部記憶體空間擔保的情況下，就必須選用標記-清除或者標記-整理演算法來進行垃圾回收了。

總而言之，分代收集只是根據物件生存週期的不同來選擇不同的演算法，其本身並沒有任何新思想。

5.增量收集演算法

以上所述的演算法，都存在一個缺點：在進行垃圾回首時需要暫停當前應用的執行，也就是這時候的垃圾回收執行緒不能和應用執行緒同時執行。如果我們想做到“在不打斷同學們看書的情況下，圖書管理員就可以收集沒有被看的書”，這也是增量收集演算法的目標，即在不中斷應用執行緒的狀態下垃圾回收執行緒也能進行垃圾回收。但是這裡需要面對的問題是：垃圾回收執行緒在標記階段標記好了，還沒來的及清除時，當前應用執行緒進行記憶體操作，以至於清除階段無法正確開展，類似的情況是：圖書管理員剛標記了《JAVA核心技術》這本書已經沒有人看了，等標記完後，卻發現這本書已經有人在看了。

如何判斷一個物件是否應該被回收

這就是所謂的物件存活性判斷，常用的方法有兩種：1.引用計數法;　2.物件可達性分析。由於引用計數法存在互相引用導致無法進行GC的問題，所以目前JVM虛擬機器多使用物件可達性分析演算法。

簡單的解釋一下垃圾回收

Java 垃圾回收機制最基本的做法是分代回收。記憶體中的區域被劃分成不同的世代，物件根據其存活的時間被儲存在對應世代的區域中。一般的實現是劃分成3個世代：年輕、年老和永久。記憶體的分配是發生在年輕世代中的。當一個物件存活時間足夠長的時候，它就會被複制到年老世代中。對於不同的世代可以使用不同的垃圾回收演算法。進行世代劃分的出發點是對應用中物件存活時間進行研究之後得出的統計規律。一般來說，一個應用中的大部分物件的存活時間都很短。比如區域性變數的存活時間就只在方法的執行過程中。基於這一點，對於年輕世代的垃圾回收演算法就可以很有針對性。

呼叫System.gc()會發生什麼?

通知GC開始工作，但是GC真正開始的時間不確定。

---

程序,執行緒相關

說說程序，執行緒，協程之間的區別

簡而言之，程序是程式執行和資源分配的基本單位，一個程式至少有一個程序，一個程序至少有一個執行緒。程序在執行過程中擁有獨立的記憶體單元，而多個執行緒共享記憶體資源，減少切換次數，從而效率更高。執行緒是程序的一個實體，是cpu排程和分派的基本單位，是比程式更小的能獨立執行的基本單位。同一程序中的多個執行緒之間可以併發執行。

你瞭解守護執行緒嗎？它和非守護執行緒有什麼區別

程式執行完畢，jvm會等待非守護執行緒完成後關閉，但是jvm不會等待守護執行緒。守護執行緒最典型的例子就是GC執行緒。

什麼是多執行緒上下文切換

多執行緒的上下文切換是指CPU控制權由一個已經正在執行的執行緒切換到另外一個就緒並等待獲取CPU執行權的執行緒的過程。

建立兩種執行緒的方式?他們有什麼區別?

通過實現java.lang.Runnable或者通過擴充套件java.lang.Thread類。相比擴充套件Thread，實現Runnable介面可能更優.原因有二：

1. Java不支援多繼承。因此擴充套件Thread類就代表這個子類不能擴充套件其他類。而實現Runnable介面的類還可能擴充套件另一個類。
2. 類可能只要求可執行即可，因此繼承整個Thread類的開銷過大。

Thread類中的start()和run()方法有什麼區別?

start()方法被用來啟動新建立的執行緒，而且start()內部呼叫了run()方法，這和直接呼叫run()方法的效果不一樣。當你呼叫run()方法的時候，只會是在原來的執行緒中呼叫，沒有新的執行緒啟動，start()方法才會啟動新執行緒。

怎麼檢測一個執行緒是否持有物件監視器

Thread類提供了一個holdsLock(Object obj)方法，當且僅當物件obj的監視器被某條執行緒持有的時候才會返回true，注意這是一個static方法，這意味著”某條執行緒”指的是當前執行緒。

Runnable和Callable的區別

Runnable介面中的run()方法的返回值是void，它做的事情只是純粹地去執行run()方法中的程式碼而已；Callable介面中的call()方法是有返回值的，是一個泛型，和Future、FutureTask配合可以用來獲取非同步執行的結果。
這其實是很有用的一個特性，因為多執行緒相比單執行緒更難、更復雜的一個重要原因就是因為多執行緒充滿著未知性，某條執行緒是否執行了？某條執行緒執行了多久？某條執行緒執行的時候我們期望的資料是否已經賦值完畢？無法得知，我們能做的只是等待這條多執行緒的任務執行完畢而已。而Callable+Future/FutureTask卻可以方便獲取多執行緒執行的結果，可以在等待時間太長沒獲取到需要的資料的情況下取消該執行緒的任務。

什麼導致執行緒阻塞

wait(),notify()和suspend(),resume()之間的區別

初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，但是事實上它們是截然不同的。區別的核心在於，前面敘述的所有方法，阻塞時都不會釋放佔用的鎖（如果佔用了的話），而這一對方法則相反。上述的核心區別導致了一系列的細節上的區別。
首先，前面敘述的所有方法都隸屬於 Thread 類，但是這一對卻直接隸屬於 Object 類，也就是說，所有物件都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放佔用的鎖，而鎖是任何物件都具有的，呼叫任意物件的 wait() 方法導致執行緒阻塞，並且該物件上的鎖被釋放。而呼叫 任意物件的notify()方法則導致從呼叫該物件的 wait() 方法而阻塞的執行緒中隨機選擇的一個解除阻塞（但要等到獲得鎖後才真正可執行）。
其次，前面敘述的所有方法都可在任何位置呼叫，但是這一對方法卻必須在 synchronized 方法或塊中呼叫，理由也很簡單，只有在synchronized 方法或塊中當前執行緒才佔有鎖，才有鎖可以釋放。同樣的道理，呼叫這一對方法的物件上的鎖必須為當前執行緒所擁有，這樣才有鎖可以釋放。因此，這一對方法呼叫必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖物件就是呼叫這一對方法的物件。若不滿足這一條件，則程式雖然仍能編譯，但在執行時會出現IllegalMonitorStateException 異常。
wait() 和 notify() 方法的上述特性決定了它們經常和synchronized關鍵字一起使用，將它們和作業系統程序間通訊機制作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似於作業系統原語的功能，它們的執行不會受到多執行緒機制的干擾，而這一對方法則相當於 block 和wakeup 原語（這一對方法均宣告為 synchronized）。它們的結合使得我們可以實現作業系統上一系列精妙的程序間通訊的演算法（如訊號量演算法），並用於解決各種複雜的執行緒間通訊問題。

關於 wait() 和 notify() 方法最後再說明兩點：

• 第一：呼叫 notify() 方法導致解除阻塞的執行緒是從因呼叫該物件的 wait() 方法而阻塞的執行緒中隨機選取的，我們無法預料哪一個執行緒將會被選擇，所以程式設計時要特別小心，避免因這種不確定性而產生問題。
• 第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區別在於，呼叫 notifyAll() 方法將把因呼叫該物件的 wait() 方法而阻塞的所有執行緒一次性全部解除阻塞。當然，只有獲得鎖的那一個執行緒才能進入可執行狀態。
• 談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的呼叫都可能產生死鎖。遺憾的是，Java 並不在語言級別上支援死鎖的避免，我們在程式設計中必須小心地避免死鎖。
  以上我們對 Java 中實現執行緒阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify() 方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。

產生死鎖的條件

1. 互斥條件：一個資源每次只能被一個程序使用。
2. 請求與保持條件：一個程序因請求資源而阻塞時，對已獲得的資源保持不放。
3. 不剝奪條件:程序已獲得的資源，在末使用完之前，不能強行剝奪。
4. 迴圈等待條件:若干程序之間形成一種頭尾相接的迴圈等待資源關係。

為什麼wait()方法和notify()/notifyAll()方法要在同步塊中被呼叫

這是JDK強制的，wait()方法和notify()/notifyAll()方法在呼叫前都必須先獲得物件的鎖

wait()方法和notify()/notifyAll()方法在放棄物件監視器時有什麼區別

wait()方法和notify()/notifyAll()方法在放棄物件監視器的時候的區別在於：wait()方法立即釋放物件監視器，notify()/notifyAll()方法則會等待執行緒剩餘程式碼執行完畢才會放棄物件監視器。

wait()與sleep()的區別

關於這兩者已經在上面進行詳細的說明,這裡就做個概括好了:

• sleep()來自Thread類，和wait()來自Object類。呼叫sleep()方法的過程中，執行緒不會釋放物件鎖。而 呼叫 wait 方法執行緒會釋放物件鎖
• sleep()睡眠後不出讓系統資源，wait讓其他執行緒可以佔用CPU
• sleep(milliseconds)需要指定一個睡眠時間，時間一到會自動喚醒.而wait()需要配合notify()或者notifyAll()使用

為什麼wait, nofity和nofityAll這些方法不放在Thread類當中

一個很明顯的原因是JAVA提供的鎖是物件級的而不是執行緒級的，每個物件都有鎖，通過執行緒獲得。如果執行緒需要等待某些鎖那麼呼叫物件中的wait()方法就有意義了。如果wait()方法定義在Thread類中，執行緒正在等待的是哪個鎖就不明顯了。簡單的說，由於wait，notify和notifyAll都是鎖級別的操作，所以把他們定義在Object類中因為鎖屬於物件。

怎麼喚醒一個阻塞的執行緒

如果執行緒是因為呼叫了wait()、sleep()或者join()方法而導致的阻塞，可以中斷執行緒，並且通過丟擲InterruptedException來喚醒它；如果執行緒遇到了IO阻塞，無能為力，因為IO是作業系統實現的，Java程式碼並沒有辦法直接接觸到作業系統。

什麼是多執行緒的上下文切換

多執行緒的上下文切換是指CPU控制權由一個已經正在執行的執行緒切換到另外一個就緒並等待獲取CPU執行權的執行緒的過程。

synchronized和ReentrantLock的區別

synchronized是和if、else、for、while一樣的關鍵字，ReentrantLock是類，這是二者的本質區別。既然ReentrantLock是類，那麼它就提供了比synchronized更多更靈活的特性，可以被繼承、可以有方法、可以有各種各樣的類變數，ReentrantLock比synchronized的擴充套件性體現在幾點上：
（1）ReentrantLock可以對獲取鎖的等待時間進行設定，這樣就避免了死鎖
（2）ReentrantLock可以獲取各種鎖的資訊
（3）ReentrantLock可以靈活地實現多路通知
另外，二者的鎖機制其實也是不一樣的:ReentrantLock底層呼叫的是Unsafe的park方法加鎖，synchronized操作的應該是物件頭中mark word。

FutureTask是什麼

這個其實前面有提到過，FutureTask表示一個非同步運算的任務。FutureTask裡面可以傳入一個Callable的具體實現類，可以對這個非同步運算的任務的結果進行等待獲取、判斷是否已經完成、取消任務等操作。當然，由於FutureTask也是Runnable介面的實現類，所以FutureTask也可以放入執行緒池中。

一個執行緒如果出現了執行時異常怎麼辦?

如果這個異常沒有被捕獲的話，這個執行緒就停止執行了。另外重要的一點是：如果這個執行緒持有某個物件的監視器，那麼這個物件監視器會被立即釋放。

Java當中有哪幾種鎖

1. 自旋鎖: 自旋鎖在JDK1.6之後就預設開啟了。基於之前的觀察，共享資料的鎖定狀態只會持續很短的時間，為了這一小段時間而去掛起和恢復執行緒有點浪費，所以這裡就做了一個處理，讓後面請求鎖的那個執行緒在稍等一會，但是不放棄處理器的執行時間，看看持有鎖的執行緒能否快速釋放。為了讓執行緒等待，所以需要讓執行緒執行一個忙迴圈也就是自旋操作。在jdk6之後，引入了自適應的自旋鎖，也就是等待的時間不再固定了，而是由上一次在同一個鎖上的自旋時間及鎖的擁有者狀態來決定。
2. 偏向鎖: 在JDK1.之後引入的一項鎖優化，目的是消除資料在無競爭情況下的同步原語。進一步提升程式的執行效能。 偏向鎖就是偏心的偏，意思是這個鎖會偏向第一個獲得他的執行緒，如果接下來的執行過程中，改鎖沒有被其他執行緒獲取，則持有偏向鎖的執行緒將永遠不需要再進行同步。偏向鎖可以提高帶有同步但無競爭的程式效能，也就是說他並不一定總是對程式執行有利，如果程式中大多數的鎖都是被多個不同的執行緒訪問，那偏向模式就是多餘的，在具體問題具體分析的前提下，可以考慮是否使用偏向鎖。
3. 輕量級鎖: 為了減少獲得鎖和釋放鎖所帶來的效能消耗，引入了“偏向鎖”和“輕量級鎖”，所以在Java SE1.6裡鎖一共有四種狀態，無鎖狀態，偏向鎖狀態，輕量級鎖狀態和重量級鎖狀態，它會隨著競爭情況逐漸升級。鎖可以升級但不能降級，意味著偏向鎖升級成輕量級鎖後不能降級成偏向鎖。

如何在兩個執行緒間共享資料

通過線上程之間共享物件就可以了，然後通過wait/notify/notifyAll、await/signal/signalAll進行喚起和等待，比方說阻塞佇列BlockingQueue就是為執行緒之間共享資料而設計的。

如何正確的使用wait()？使用if還是while？

wait() 方法應該在迴圈呼叫，因為當執行緒獲取到 CPU 開始執行的時候，其他條件可能還沒有滿足，所以在處理前，迴圈檢測條件是否滿足會更好。下面是一段標準的使用 wait 和 notify 方法的程式碼：

synchronized (obj) {
   while (condition does not hold)
     obj.wait(); // (Releases lock, and reacquires on wakeup)
     ... // Perform action appropriate to condition
}

什麼是執行緒區域性變數ThreadLocal

執行緒區域性變數是侷限於執行緒內部的變數，屬於執行緒自身所有，不在多個執行緒間共享。Java提供ThreadLocal類來支援執行緒區域性變數，是一種實現執行緒安全的方式。但是在管理環境下（如 web 伺服器）使用執行緒區域性變數的時候要特別小心，在這種情況下，工作執行緒的生命週期比任何應用變數的生命週期都要長。任何執行緒區域性變數一旦在工作完成後沒有釋放，Java 應用就存在記憶體洩露的風險。

ThreadLoal的作用是什麼?

簡單說ThreadLocal就是一種以空間換時間的做法在每個Thread裡面維護了一個ThreadLocal.ThreadLocalMap把資料進行隔離，資料不共享，自然就沒有執行緒安全方面的問題了。

生產者消費者模型的作用是什麼?

（1）通過平衡生產者的生產能力和消費者的消費能力來提升整個系統的執行效率，這是生產者消費者模型最重要的作用。
（2）解耦，這是生產者消費者模型附帶的作用，解耦意味著生產者和消費者之間的聯絡少，聯絡越少越可以獨自發展而不需要收到相互的制約。

寫一個生產者-消費者佇列

可以通過阻塞佇列實現，也可以通過wait-notify來實現。
使用阻塞佇列來實現

//消費者
public class Producer implements Runnable{
   private final BlockingQueue<Integer> queue;
 
   public Producer(BlockingQueue q){
       this.queue=q;
   }
 
   @Override
   public void run() {
       try {
           while (true){
               Thread.sleep(1000);//模擬耗時
               queue.put(produce());
           }
       }catch (InterruptedException e){
 
       }
   }
 
   private int produce() {
       int n=new Random().nextInt(10000);
       System.out.println("Thread:" + Thread.currentThread().getId() + " produce:" + n);
       return n;
   }
}
//消費者
public class Consumer implements Runnable {
   private final BlockingQueue<Integer> queue;
 
   public Consumer(BlockingQueue q){
       this.queue=q;
   }
 
   @Override
   public void run() {
       while (true){
           try {
               Thread.sleep(2000);//模擬耗時
               consume(queue.take());
           }catch (InterruptedException e){
 
           }
 
       }
   }
 
   private void consume(Integer n) {
       System.out.println("Thread:" + Thread.currentThread().getId() + " consume:" + n);
 
   }
}
//測試
public class Main {
 
   public static void main(String[] args) {
       BlockingQueue<Integer> queue=new ArrayBlockingQueue<Integer>(100);
       Producer p=new Producer(queue);
       Consumer c1=new Consumer(queue);
       Consumer c2=new Consumer(queue);
 
       new Thread(p).start();
       new Thread(c1).start();
       new Thread(c2).start();
   }
}

使用wait-notify來實現

該種方式應該最經典，這裡就不做說明了。

如果你提交任務時，執行緒池佇列已滿，這時會發生什麼

如果你使用的LinkedBlockingQueue，也就是無界佇列的話，沒關係，繼續新增任務到阻塞佇列中等待執行，因為LinkedBlockingQueue可以近乎認為是一個無窮大的佇列，可以無限存放任務；如果你使用的是有界佇列比方說ArrayBlockingQueue的話，任務首先會被新增到ArrayBlockingQueue中，ArrayBlockingQueue滿了，則會使用拒絕策略RejectedExecutionHandler處理滿了的任務，預設是AbortPolicy。

為什麼要使用執行緒池

避免頻繁地建立和銷燬執行緒，達到執行緒物件的重用。另外，使用執行緒池還可以根據專案靈活地控制併發的數目。

java中用到的執行緒排程演算法是什麼

搶佔式。一個執行緒用完CPU之後，作業系統會根據執行緒優先順序、執行緒飢餓情況等資料算出一個總的優先順序並分配下一個時間片給某個執行緒執行。

Thread.sleep(0)的作用是什麼

由於Java採用搶佔式的執行緒排程演算法，因此可能會出現某條執行緒常常獲取到CPU控制權的情況，為了讓某些優先順序比較低的執行緒也能獲取到CPU控制權，可以使用Thread.sleep(0)手動觸發一次作業系統分配時間片的操作，這也是平衡CPU控制權的一種操作。

什麼是CAS

CAS，全稱為Compare and Swap，即比較-替換。假設有三個運算元：記憶體值V、舊的預期值A、要修改的值B，當且僅當預期值A和記憶體值V相同時，才會將記憶體值修改為B並返回true，否則什麼都不做並返回false。當然CAS一定要volatile變數配合，這樣才能保證每次拿到的變數是主記憶體中最新的那個值，否則舊的預期值A對某條執行緒來說，永遠是一個不會變的值A，只要某次CAS操作失敗，永遠都不可能成功。

什麼是樂觀鎖和悲觀鎖

1. 樂觀鎖：樂觀鎖認為競爭不總是會發生，因此它不需要持有鎖，將比較-替換這兩個動作作為一個原子操作嘗試去修改記憶體中的變數，如果失敗則表示發生衝突，那麼就應該有相應的重試邏輯。
2. 悲觀鎖：悲觀鎖認為競爭總是會發生，因此每次對某資源進行操作時，都會持有一個獨佔的鎖，就像synchronized，不管三七二十一，直接上了鎖就操作資源了。

ConcurrentHashMap的併發度是什麼?

ConcurrentHashMap的併發度就是segment的大小，預設為16，這意味著最多同時可以有16條執行緒操作ConcurrentHashMap，這也是ConcurrentHashMap對Hashtable的最大優勢，任何情況下，Hashtable能同時有兩條執行緒獲取Hashtable中的資料嗎？

ConcurrentHashMap的工作原理

ConcurrentHashMap在jdk 1.6和jdk 1.8實現原理是不同的。

jdk 1.6:

ConcurrentHashMap是執行緒安全的，但是與Hashtablea相比，實現執行緒安全的方式不同。Hashtable是通過對hash表結構進行鎖定，是阻塞式的，當一個執行緒佔有這個鎖時，其他執行緒必須阻塞等待其釋放鎖。ConcurrentHashMap是採用分離鎖的方式，它並沒有對整個hash表進行鎖定，而是區域性鎖定，也就是說當一個執行緒佔有這個區域性鎖時，不影響其他執行緒對hash表其他地方的訪問。
具體實現:ConcurrentHashMap內部有一個Segment.

jdk 1.8

在jdk 8中，ConcurrentHashMap不再使用Segment分離鎖，而是採用一種樂觀鎖CAS演算法來實現同步問題，但其底層還是“陣列+連結串列->紅黑樹”的實現。

CyclicBarrier和CountDownLatch區別

這兩個類非常類似，都在java.util.concurrent下，都可以用來表示程式碼執行到某個點上，二者的區別在於：

• CyclicBarrier的某個執行緒執行到某個點上之後，該執行緒即停止執行，直到所有的執行緒都到達了這個點，所有執行緒才重新執行；CountDownLatch則不是，某執行緒執行到某個點上之後，只是給某個數值-1而已，該執行緒繼續執行。
• CyclicBarrier只能喚起一個任務，CountDownLatch可以喚起多個任務
• CyclicBarrier可重用，CountDownLatch不可重用，計數值為0該CountDownLatch就不可再用了。

java中的++操作符執行緒安全麼?

不是執行緒安全的操作。它涉及到多個指令，如讀取變數值，增加，然後儲存回記憶體，這個過程可能會出現多個執行緒交差。

你有哪些多執行緒開發良好的實踐?

1. 給執行緒命名
2. 最小化同步範圍
3. 優先使用volatile
4. 儘可能使用更高層次的併發工具而非wait和notify()來實現執行緒通訊,如BlockingQueue,Semeaphore
5. 優先使用併發容器而非同步容器.
6. 考慮使用執行緒池

---

關於volatile關鍵字

可以建立Volatile陣列嗎?

Java 中可以建立 volatile型別陣列，不過只是一個指向陣列的引用，而不是整個陣列。如果改變引用指向的陣列，將會受到volatile 的保護，但是如果多個執行緒同時改變陣列的元素，volatile標示符就不能起到之前的保護作用了。

volatile能使得一個非原子操作變成原子操作嗎?

一個典型的例子是在類中有一個 long 型別的成員變數。如果你知道該成員變數會被多個執行緒訪問，如計數器、價格等，你最好是將其設定為 volatile。為什麼？因為 Java 中讀取 long 型別變數不是原子的，需要分成兩步，如果一個執行緒正在修改該 long 變數的值，另一個執行緒可能只能看到該值的一半（前 32 位）。但是對一個 volatile 型的 long 或 double 變數的讀寫是原子。
一種實踐是用 volatile 修飾 long 和 double 變數，使其能按原子型別來讀寫。double 和 long 都是64位寬，因此對這兩種型別的讀是分為兩部分的，第一次讀取第一個 32 位，然後再讀剩下的 32 位，這個過程不是原子的，但 Java 中 volatile 型的 long 或 double 變數的讀寫是原子的。volatile 修復符的另一個作用是提供記憶體屏障（memory barrier），例如在分散式框架中的應用。簡單的說，就是當你寫一個 volatile 變數之前，Java 記憶體模型會插入一個寫屏障（write barrier），讀一個 volatile 變數之前，會插入一個讀屏障（read barrier）。意思就是說，在你寫一個 volatile 域時，能保證任何執行緒都能看到你寫的值，同時，在寫之前，也能保證任何數值的更新對所有執行緒是可見的，因為記憶體屏障會將其他所有寫的值更新到快取。

volatile型別變數提供什麼保證?

volatile 主要有兩方面的作用:1.避免指令重排2.可見性保證.例如，JVM 或者 JIT為了獲得更好的效能會對語句重排序，但是 volatile 型別變數即使在沒有同步塊的情況下賦值也不會與其他語句重排序。 volatile 提供 happens-before 的保證，確保一個執行緒的修改能對其他執行緒是可見的。某些情況下，volatile 還能提供原子性，如讀 64 位資料型別，像 long 和 double 都不是原子的(低32位和高32位)，但 volatile 型別的 double 和 long 就是原子的。

---

關於集合

Java中的集合及其繼承關係

關於集合的體系是每個人都應該爛熟於心的,尤其是對我們經常使用的List,Map的原理更該如此.這裡我們看這張圖即可:
更多內容可見集合類總結：
http://write.blog.csdn.net/postedit/40826423

poll()方法和remove()方法區別？

poll() 和 remove() 都是從佇列中取出一個元素，但是 poll() 在獲取元素失敗的時候會返回空，但是 remove() 失敗的時候會丟擲異常。

LinkedHashMap和PriorityQueue的區別

PriorityQueue 是一個優先順序佇列,保證最高或者最低優先順序的的元素總是在佇列頭部，但是 LinkedHashMap 維持的順序是元素插入的順序。當遍歷一個 PriorityQueue 時，沒有任何順序保證，但是 LinkedHashMap 課保證遍歷順序是元素插入的順序。

WeakHashMap與HashMap的區別是什麼?

WeakHashMap 的工作與正常的 HashMap 類似，但是使用弱引用作為 key，意思就是當 key 物件沒有任何引用時，key/value 將會被回收。

ArrayList和LinkedList的區別?

最明顯的區別是 ArrrayList底層的資料結構是陣列，支援隨機訪問，而 LinkedList 的底層資料結構是雙向迴圈連結串列，不支援隨機訪問。使用下標訪問一個元素，ArrayList 的時間複雜度是 O(1)，而 LinkedList 是 O(n)。

ArrayList和Array有什麼區別?

1. Array可以容納基本型別和物件，而ArrayList只能容納物件。
2. Array是指定大小的，而ArrayList大小是固定的

ArrayList和HashMap預設大小?

在 Java 7 中，ArrayList 的預設大小是 10 個元素，HashMap 的預設大小是16個元素（必須是2的冪）。這就是 Java 7 中 ArrayList 和 HashMap 類的程式碼片段。

private static final int DEFAULT_CAPACITY = 10;
 
//from HashMap.java JDK 7
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

Comparator和Comparable的區別?

Comparable 介面用於定義物件的自然順序，而 comparator 通常用於定義使用者定製的順序。Comparable 總是隻有一個，但是可以有多個 comparator 來定義物件的順序。

如何實現集合排序?

你可以使用有序集合，如 TreeSet 或 TreeMap，你也可以使用有順序的的集合，如 list，然後通過 Collections.sort() 來排序。

如何列印陣列內容

你可以使用 Arrays.toString() 和 Arrays.deepToString() 方法來列印陣列。由於陣列沒有實現 toString() 方法，所以如果將陣列傳遞給 System.out.println() 方法，將無法打印出陣列的內容，但是 Arrays.toString() 可以列印每個元素。

LinkedList的是單向連結串列還是雙向?

雙向迴圈列表，具體實現自行查閱原始碼。

TreeMap是實現原理

採用紅黑樹實現，具體實現自行查閱原始碼。

遍歷ArrayList時如何正確移除一個元素

該問題的關鍵在於面試者使用的是 ArrayList 的 remove() 還是 Iterator 的 remove()方法。這有一段示例程式碼，是使用正確的方式來實現在遍歷的過程中移除元素，而不會出現 ConcurrentModificationException 異常的示例程式碼。

什麼是ArrayMap?它和HashMap有什麼區別?

ArrayMap是Android SDK中提供的，非Android開發者可以略過。
ArrayMap是用兩個陣列來模擬map，更少的記憶體佔用空間,更高的效率。
具體參考這篇文章：ArrayMap VS HashMap：http://lvable.com/?p=217]

HashMap的實現原理

1. HashMap概述： HashMap是基於雜湊表的Map介面的非同步實現。此實現提供所有可選的對映操作，並允許使用null值和null鍵。此類不保證對映的順序，特別是它不保證該順序恆久不變。
2. HashMap的資料結構： 在java程式語言中，最基本的結構就是兩種，一個是陣列，另外一個是模擬指標（引用），所有的資料結構都可以用這兩個基本結構來構造的，HashMap也不例外。HashMap實際上是一個“連結串列雜湊”的資料結構，即陣列和連結串列的結合體。
   當我們往Hashmap中put元素時,首先根據key的hashcode重新計算hash值,根絕hash值得到這個元素在陣列中的位置(下標),如果該陣列在該位置上已經存放了其他元素,那麼在這個位置上的元素將以連結串列的形式存放,新加入的放在鏈頭,最先加入的放入鏈尾.如果陣列中該位置沒有元素,就直接將該元素放到陣列的該位置上.
   需要注意Jdk 1.8中對HashMap的實現做了優化,當連結串列中的節點資料超過八個之後,該連結串列會轉為紅黑樹來提高查詢效率,從原來的O(n)到O(logn)

你瞭解Fail-Fast機制嗎？

Fail-Fast即我們常說的快速失敗，
更多內容參看fail-fast機制：http://blog.csdn.net/chenssy/article/details/38151189

Fail-fast和Fail-safe有什麼區別

Iterator的fail-fast屬性與當前的集合共同起作用，因此它不會受到集合中任何改動的影響。Java.util包中的所有集合類都被設計為fail->fast的，而java.util.concurrent中的集合類都為fail-safe的。當檢測到正在遍歷的集合的結構被改變時，Fail-fast迭代器丟擲ConcurrentModificationException，而fail-safe迭代器從不丟擲ConcurrentModificationException。

---

關於日期

SimpleDateFormat是執行緒安全的嗎?

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

如何格式化日期?

Java 中，可以使用 SimpleDateFormat 類或者 joda-time 庫來格式日期。DateFormat 類允許你使用多種流行的格式來格式化日期。參見答案中的示例程式碼，程式碼中演示了將日期格式化成不同的格式，如 dd-MM-yyyy 或 ddMMyyyy。

---

關於異常

簡單描述java異常體系

相比沒有人不瞭解異常體系,關於異常體系的更多資訊可以見
白話異常機制：http://blog.csdn.net/dd864140130/article/details/42504189

什麼是異常鏈

詳情直接參見上面的白話異常機制，不做解釋了。

throw和throws的區別

throw用於主動丟擲java.lang.Throwable 類的一個例項化物件，意思是說你可以通過關鍵字 throw 丟擲一個 Error 或者 一個Exception，如：throw new IllegalArgumentException(“size must be multiple of 2″),
而throws 的作用是作為方法宣告和簽名的一部分，方法被丟擲相應的異常以便呼叫者能處理。Java 中，任何未處理的受檢查異常強制在 throws 子句中宣告。

---

關於序列化

Java 中，Serializable 與 Externalizable 的區別

Serializable 介面是一個序列化 Java 類的介面，以便於它們可以在網路上傳輸或者可以將它們的狀態儲存在磁碟上，是 JVM 內嵌的預設序列化方式，成本高、脆弱而且不安全。Externalizable 允許你控制整個序列化過程，指定特定的二進位制格式，增加安全機制。

---

關於JVM

JVM特性

平臺無關性.
Java語言的一個非常重要的特點就是與平臺的無關性。而使用Java虛擬機器是實現這一特點的關鍵。一般的高階語言如果要在不同的平臺上執行，至少需要編譯成不同的目的碼。而引入Java語言虛擬機器後，Java語言在不同平臺上執行時不需要重新編譯。Java語言使用模式Java虛擬機器遮蔽了與具體平臺相關的資訊，使得Java語言編譯程式只需生成在Java虛擬機器上執行的目的碼（位元組碼），就可以在多種平臺上不加修改地執行。Java虛擬機器在執行位元組碼時，把位元組碼解釋成具體平臺上的機器指令執行。

簡單解釋一下類載入器

有關類載入器一般會問你四種類載入器的應用場景以及雙親委派模型,
更多的內容參看深入理解JVM載入器：
http://blog.csdn.net/dd864140130/article/details/49817357

簡述堆和棧的區別

VM 中堆和棧屬於不同的記憶體區域，使用目的也不同。棧常用於儲存方法幀和區域性變數，而物件總是在堆上分配。棧通常都比堆小，也不會在多個執行緒之間共享，而堆被整個 JVM 的所有執行緒共享。

簡述JVM記憶體分配

1. 基本資料型別比變數和物件的引用都是在棧分配的。
2. 堆記憶體用來存放由new建立的物件和陣列。
3. 類變數（static修飾的變數），程式在一載入的時候就在堆中為類變數分配記憶體，堆中的記憶體地址存放在棧中。
4. 例項變數：當你使用java關鍵字new的時候，系統在堆中開闢並不一定是連續的空間分配給變數，是根據零散的堆記憶體地址，通