引言

        最近有位細心的朋友在閱讀筆者的文章時，對java類的生命週期問題有一些疑惑，筆者開啟百度搜了一下相關的問題，看到網上的資料很少有把這個問題講明白的，主要是因為目前國內java方面的教材大多隻是告訴你“怎樣做”，但至於“為什麼這樣做”卻不多說，所以造成大家在基礎和原理方面的知識比較匱乏，所以筆者今天就斗膽來講一下這個問題，權當拋磚引玉，希望對在這個問題上有疑惑的朋友有所幫助，文中有說的不對的地方，也希望各路高手前來指正。

        首先來了解一下jvm（java虛擬機器）中的幾個比較重要的記憶體區域，這幾個區域在java類的生命週期中扮演著比較重要的角色：

• 方法區：
  在java的虛擬機器中有一塊專門用來存放已經載入的類資訊、常量、靜態變數以及方法程式碼的記憶體區域，叫做方法區。
• 常量池：常量池是方法區的一部分，主要用來存放常量和類中的符號引用等資訊。
• 堆區：用於存放類的物件例項。
• 棧區：也叫java虛擬機器棧，是由一個一個的棧幀組成的後進先出的棧式結構，棧楨中存放方法執行時產生的區域性變數、方法出口等資訊。當呼叫一個方法時，虛擬機器棧中就會建立一個棧幀存放這些資料，當方法呼叫完成時，棧幀消失，如果方法中呼叫了其他方法，則繼續在棧頂建立新的棧楨。

        除了以上四個記憶體區域之外，jvm中的執行時記憶體區域還包括本地方法棧和程式計數器，這兩個區域與java類的生命週期關係不是很大，在這裡就不說了，感興趣的朋友可以自己百度一下。

類的生命週期

        當我們編寫一個java的原始檔後，經過編譯會生成一個字尾名為class的檔案，這種檔案叫做位元組碼檔案，只有這種位元組碼檔案才能夠在java虛擬機器中執行，java類的生命週期就是指一個class檔案從載入到解除安裝的全過程。

        一個java類的完整的生命週期會經歷載入、連線、初始化、使用、和解除安裝五個階段，當然也有在載入或者連線之後沒有被初始化就直接被使用的情況，如圖所示：

下面我們就依次來說一說這五個階段。

載入

       在java中，我們經常會接觸到一個詞——類載入，它和這裡的載入並不是一回事，通常我們說類載入指的是類的生命週期中載入、連線、初始化三個階段。在載入階段，java虛擬機器會做什麼工作呢？其實很簡單，就是找到需要載入的類並把類的資訊載入到jvm的方法區中，然後在堆區中例項化一個java.lang.Class物件，作為方法區中這個類的資訊的入口。

       類的載入方式比較靈活，我們最常用的載入方式有兩種，一種是根據類的全路徑名找到相應的class檔案，然後從class檔案中讀取檔案內容；另一種是從jar檔案中讀取。另外，還有下面幾種方式也比較常用：

• 從網路中獲取：比如10年前十分流行的Applet。
• 根據一定的規則實時生成，比如設計模式中的動態代理模式，就是根據相應的類自動生成它的代理類。
• 從非class檔案中獲取，其實這與直接從class檔案中獲取的方式本質上是一樣的，這些非class檔案在jvm中執行之前會被轉換為可被jvm所識別的位元組碼檔案。

       對於載入的時機，各個虛擬機器的做法並不一樣，但是有一個原則，就是當jvm“預期”到一個類將要被使用時，就會在使用它之前對這個類進行載入。比如說，在一段程式碼中出現了一個類的名字，jvm在執行這段程式碼之前並不能確定這個類是否會被使用到，於是，有些jvm會在執行前就載入這個類，而有些則在真正需要用的時候才會去載入它，這取決於具體的jvm實現。我們常用的hotspot虛擬機器是採用的後者，就是說當真正用到一個類的時候才對它進行載入。

       載入階段是類的生命週期中的第一個階段，載入階段之後，是連線階段。有一點需要注意，就是有時連線階段並不會等載入階段完全完成之後才開始，而是交叉進行，可能一個類只加載了一部分之後，連線階段就已經開始了。但是這兩個階段總的開始時間和完成時間總是固定的：載入階段總是在連線階段之前開始，連線階段總是在載入階段完成之後完成。

連線

       連線階段比較複雜，一般會跟載入階段和初始化階段交叉進行，這個階段的主要任務就是做一些載入後的驗證工作以及一些初始化前的準備工作，可以細分為三個步驟：驗證、準備和解析。

1. 驗證：當一個類被載入之後，必須要驗證一下這個類是否合法，比如這個類是不是符合位元組碼的格式、變數與方法是不是有重複、資料型別是不是有效、繼承與實現是否合乎標準等等。總之，這個階段的目的就是保證載入的類是能夠被jvm所執行。
2. 準備：準備階段的工作就是為類的靜態變數分配記憶體並設為jvm預設的初值，對於非靜態的變數，則不會為它們分配記憶體。有一點需要注意，這時候，靜態變數的初值為jvm預設的初值，而不是我們在程式中設定的初值。jvm預設的初值是這樣的： 解析：這一階段的任務就是把常量池中的符號引用轉換為直接引用。那麼什麼是符號引用，什麼又是直接引用呢？我們來舉個例子：我們要找一個人，我們現有的資訊是這個人的身份證號是1234567890。只有這個資訊我們顯然找不到這個人，但是通過公安局的身份系統，我們輸入1234567890這個號之後，就會得到它的全部資訊：比如安徽省黃山市餘暇村18號張三，通過這個資訊我們就能找到這個人了。這裡，123456790就好比是一個符號引用，而安徽省黃山市餘暇村18號張三就是直接引用。在記憶體中也是一樣，比如我們要在記憶體中找一個類裡面的一個叫做show的方法，顯然是找不到。但是在解析階段，jvm就會把show這個名字轉換為指向方法區的的一塊記憶體地址，比如c17164，通過c17164就可以找到show這個方法具體分配在記憶體的哪一個區域了。這裡show就是符號引用，而c17164就是直接引用。在解析階段，jvm會將所有的類或介面名、欄位名、方法名轉換為具體的記憶體地址。
   • 基本型別（int、long、short、char、byte、boolean、float、double）的預設值為0。
   • 引用型別的預設值為null。
   • 常量的預設值為我們程式中設定的值，比如我們在程式中定義final static int a = 100，則準備階段中a的初值就是100。

        連線階段完成之後會根據使用的情況（直接引用還是被動引用）來選擇是否對類進行初始化。

初始化

       如果一個類被直接引用，就會觸發類的初始化。在java中，直接引用的情況有：

• 通過new關鍵字例項化物件、讀取或設定類的靜態變數、呼叫類的靜態方法。
• 通過反射方式執行以上三種行為。
• 初始化子類的時候，會觸發父類的初始化。
• 作為程式入口直接執行時（也就是直接呼叫main方法）。

        除了以上四種情況，其他使用類的方式叫做被動引用，而被動引用不會觸發類的初始化。請看主動引用的示例程式碼：

1. import java.lang.reflect.Field;  
2. import java.lang.reflect.Method;  
3. class InitClass{  
4.     static {  
5.         System.out.println("初始化InitClass");  
6.     }  
7.     public static String a = null;  
8.     public static void method(){}  
9. }  
10. class SubInitClass extends InitClass{}  
11. public class Test1 {  
12.     /** 
13.      * 主動引用引起類的初始化的第四種情況就是執行Test1的main方法時 
14.      * 導致Test1初始化，這一點很好理解，就不特別演示了。 
15.      * 本程式碼演示了前三種情況，以下程式碼都會引起InitClass的初始化， 
16.      * 但由於初始化只會進行一次，執行時請將註解去掉，依次執行檢視結果。 
17.      * @param args 
18.      * @throws Exception 
19.      */  
20.     public static void main(String[] args) throws Exception{  
21.     //  主動引用引起類的初始化一: new物件、讀取或設定類的靜態變數、呼叫類的靜態方法。  
22.     //  new InitClass();  
23.     //  InitClass.a = "";  
24.     //  String a = InitClass.a;  
25.     //  InitClass.method();  
26.     //  主動引用引起類的初始化二：通過反射例項化物件、讀取或設定類的靜態變數、呼叫類的靜態方法。  
27.     //  Class cls = InitClass.class;  
28.     //  cls.newInstance();  
29.     //  Field f = cls.getDeclaredField("a");  
30.     //  f.get(null);  
31.     //  f.set(null, "s");  
32.     //  Method md = cls.getDeclaredMethod("method");  
33.     //  md.invoke(null, null);  
34.     //  主動引用引起類的初始化三：例項化子類，引起父類初始化。  
35.     //  new SubInitClass();  
36.     }  
37. }  

        上面的程式演示了主動引用觸發類的初始化的四種情況。

        類的初始化過程是這樣的：按照順序自上而下執行類中的變數賦值語句和靜態語句，如果有父類，則首先按照順序執行父類中的變數賦值語句和靜態語句。先看一個例子，首先建兩個類用來顯示賦值操作：

1. public class Field1{  
2.     public Field1(){  
3.         System.out.println("Field1構造方法");  
4.     }  
5. }  
6. public class Field2{  
7.     public Field2(){  
8.         System.out.println("Field2構造方法");  
9.     }  
10. }  

下面是演示初始化順序的程式碼：

1. class InitClass2{  
2.     static{  
3.         System.out.println("執行父類靜態程式碼");  
4.     }  
5.     public static Field1 f1 = new Field1();  
6.     public static Field1 f2;   
7. }  
8. class SubInitClass2 extends InitClass2{  
9.     static{  
10.         System.out.println("執行子類靜態程式碼");  
11.     }  
12.     public static Field2 f2 = new Field2();  
13. }  
14. public class Test2 {  
15.     public static void main(String[] args) throws ClassNotFoundException{  
16.         new SubInitClass2();  
17.     }  
18. }  

        上面的程式碼中，初始化的順序是：第03行，第05行，第11行，第13行。第04行是宣告操作，沒有賦值，所以不會被執行。而下面的程式碼：

1. class InitClass2{  
2.     public static Field1 f1 = new Field1();  
3.     public static Field1 f2;  
4.     static{  
5.         System.out.println("執行父類靜態程式碼");  
6.     }  
7. }  
8. class SubInitClass2 extends InitClass2{  
9.     public static Field2 f2 = new Field2();  
10.     static{  
11.         System.out.println("執行子類靜態程式碼");  
12.     }  
13. }  
14. public class Test2 {  
15.     public static void main(String[] args) throws ClassNotFoundException{  
16.         new SubInitClass2();  
17.     }  
18. }  

        初始化順序為：第02行、第05行、第10行、第12行，各位可以執行程式檢視結果。

       在類的初始化階段，只會初始化與類相關的靜態賦值語句和靜態語句，也就是有static關鍵字修飾的資訊，而沒有static修飾的賦值語句和執行語句在例項化物件的時候才會執行。

使用

       類的使用包括主動引用和被動引用，主動引用在初始化的章節中已經說過了，下面我們主要來說一下被動引用：

• 引用父類的靜態欄位，只會引起父類的初始化，而不會引起子類的初始化。
• 定義類陣列，不會引起類的初始化。
• 引用類的常量，不會引起類的初始化。

被動引用的示例程式碼：

1. class InitClass{  
2.     static {  
3.         System.out.println("初始化InitClass");  
4.     }  
5.     public static String a = null;  
6.     public final static String b = "b";  
7.     public static void method(){}  
8. }  
9. class SubInitClass extends InitClass{  
10.     static {  
11.         System.out.println("初始化SubInitClass");  
12.     }  
13. }  
14. public class Test4 {  
15.     public static void main(String[] args) throws Exception{  
16.     //  String a = SubInitClass.a;// 引用父類的靜態欄位，只會引起父類初始化，而不會引起子類的初始化  
17.     //  String b = InitClass.b;// 使用類的常量不會引起類的初始化  
18.         SubInitClass[] sc = new SubInitClass[10];// 定義類陣列不會引起類的初始化  
19.     }  
20. }  

        最後總結一下使用階段：使用階段包括主動引用和被動引用，主動飲用會引起類的初始化，而被動引用不會引起類的初始化。

        當使用階段完成之後，java類就進入了解除安裝階段。

解除安裝

       關於類的解除安裝，筆者在單例模式討論篇：單例模式與垃圾回收一文中有過描述，在類使用完之後，如果滿足下面的情況，類就會被解除安裝：

• 該類所有的例項都已經被回收，也就是java堆中不存在該類的任何例項。
• 載入該類的ClassLoader已經被回收。
• 該類對應的java.lang.Class物件沒有任何地方被引用，無法在任何地方通過反射訪問該類的方法。

        如果以上三個條件全部滿足，jvm就會在方法區垃圾回收的時候對類進行解除安裝，類的解除安裝過程其實就是在方法區中清空類資訊，java類的整個生命週期就結束了。

總結

        做java的朋友對於物件的生命週期可能都比較熟悉，物件基本上都是在jvm的堆區中建立，在建立物件之前，會觸發類載入（載入、連線、初始化），當類初始化完成後，根據類資訊在堆區中例項化類物件，初始化非靜態變數、非靜態程式碼以及預設構造方法，當物件使用完之後會在合適的時候被jvm垃圾收集器回收。讀完本文後我們知道，物件的生命週期只是類的生命週期中使用階段的主動引用的一種情況（即例項化類物件）。而類的整個生命週期則要比物件的生命週期長的多。