看了這篇你還不懂JVM中的類加載機制？

開門見山

首先引入一道面試題

class Single {
    private static Single single = new Single();
    public static int count1;
    public static int count2 = 0;
    private Single() {
        count1++;
        count2++;
    }
    public static Single getInstance() {
        return single;
    }
}
public class Test {
    public static void main(String[] args) {
        Single single = Single.getInstance();
        System.out.println("count1=" + single.count1);
        System.out.println("count2=" + single.count2);
    }
}
複製代碼

錯誤答案：count1=1;count2=1 正確答案：count1=1;count2=0

爲神馬？爲神馬？這要從java的類加載時機提及。

原本是準備把分析結果寫在最下面的可是怕你們沒有耐心看到最後我這邊先大概分析下，若是看不懂下面的分析。建議你們能看到最後，文章不算長。

1. Single single = Single.getInstance();調用了類的Single調用了類的靜態方法，觸發類的初始化
2. 類加載的時候在準備過程當中爲類的靜態變量分配內存並初始化默認值 single=null count1=0,count2=0
3. 類初始化化，爲類的靜態變量賦值和執行靜態代碼快。single賦值爲new Single()調用類的構造方法
4. 調用類的構造方法後count=1;count2=1
5. 繼續爲count1與count2賦值,此時count1沒有賦值操做,全部count1爲1,可是count2執行賦值操做就變爲0

類的加載時機

類從被加載到虛擬機內存中開始，直到卸載出內存爲止，它的整個生命週期包括了：加載、驗證、準備、解析、初始化、使用和卸載這7個階段。其中，驗證、準備和解析這三個部分統稱爲鏈接（linking）。

其中加載、驗證、準備、初始化和卸載五個步驟的順序都是肯定的，解析階段在某些狀況下有可能發生在初始化以後，這是爲了支持 Java 語言的運行期綁定的特性。

什麼時候開始類的初始化

什麼狀況下須要開始類加載過程的第一個階段:"加載"。虛擬機規範中並沒強行約束，這點能夠交給虛擬機的的具體實現自由把握，可是對於初始化階段虛擬機規範是嚴格規定了以下幾種狀況，若是類未初始化會對類進行初始化。

1. 建立類的實例
2. 訪問類的靜態變量(除常量【被final修辭的靜態變量】緣由:常量一種特殊的變量，由於編譯器把他們看成值(value)而不是域(field)來對待。若是你的代碼中用到了常變量(constant variable)，編譯器並不會生成字節碼來從對象中載入域的值，而是直接把這個值插入到字節碼中。這是一種頗有用的優化，可是若是你須要改變final域的值那麼每一塊用到那個域的代碼都須要從新編譯。
3. 訪問類的靜態方法
4. 反射如(Class.forName("my.xyz.Test"))
5. 當初始化一個類時，發現其父類還未初始化，則先出發父類的初始化
6. 虛擬機啓動時，定義了main()方法的那個類先初始化

• 主動引用：上面這些種行爲稱爲對一個類的的主動引用，會觸發類的初始化
• 被動引用：除上面五種主動引用以外，其餘引用類的方式都不會觸發類的初始化，稱爲類的被動引用

接口的加載過程與類的加載過程稍有不一樣。接口中不能使用static{}塊。當一個接口在初始化時，並不要求其父接口所有都完成了初始化，只有真正在使用到父接口時（例如引用接口中定義的常量）纔會初始化。

被動引用例子

被動引用示例一

對於靜態字段，只有直接定義這個字段的類會被初始化，若是是經過子類引用父類的字段，父類會被初始化，子類不必定會被初始化，子類會不會被初始化 JVM 虛擬機規範並無明確規定，取決於虛擬機的具體實現

public class SuperClass {
    static {
        System.out.println("SuperClass init!");
    }
    public static int value = 1;
}
public class SubClass extends SuperClass {
    static {
        System.out.println("SubClass init!");
    }
}

public class Demo {
    public static void main(String[] args){
        System.out.println("The value is " + Subclass.value);
    }
}
複製代碼

上面代碼運行以後輸出結果以下所示

SuperClass init!
The value is 24
複製代碼

被動引用示例二

public class SubClass {
    static {
        System.out.println("SubClass init!");
    }
}
public class Demo {
    public static void main(String[] args){
        SubClass[] subClassArray = new SubClass[10];
    }
}
複製代碼

上面代碼運行以後，並不會輸出 "SubClass init!"，由於在上面Demo#main()方法中，並無初始化SubClass類，而是初始化了一個SubClass[]數組類，SubClass[]數組類表明了一個元素類型爲SubClass的一維數組，繼承自Object類，由newarray字節碼建立。

被動引用示例三

public class Constant {
    static {
        System.out.println("Constant init!");
    }
    public static final String VALUE = "Hello World!";
}
public class Demo {
    public static void main(String[] args){
        System.out.println(Constant.VALUE);
    }
}
複製代碼

上面代碼運行以後也並不會輸出"Constant init!"，由於這涉及到一個概念 ---- 「常量傳播優化」。雖然在代碼中Demo類引用了Constant類中的常量VALUE，可是在編譯階段，會將VALUE的實際值"Hello World!"放到Demo類中的常量池中，Demo類每次使用"Hello World!"常量的時候都會從本身的常量池中去找。Demo類不會持有Constant類的符號引用，因此Constant類也並不會被初始化。

類的加載過程

加載

在加載階段有三個步驟：

1. 經過一個類的全限定名獲取定義此類的二進制字節流
2. 將二進制字節流所表明的靜態存儲結構轉換爲方法區中的運行時數據結構
3. 在內存中生成一個表明此類的java.lang.Class的對象，做爲方法區這些數據的訪問入口 在這個階段，有兩點須要注意：
4. 並無規定從哪裏獲取二進制字節流。咱們能夠從.class靜態存儲文件中獲取，也能夠從zip、jar等包中讀取，能夠從數據庫中讀取，也能夠從網絡中獲取，甚至咱們本身能夠在運行時自動生成。
5. 在內存中實例化一個表明此類的java.lang.Class對象以後，並無規定此Class對象是方法Java堆中的，有些虛擬機就會將Class對象放到方法區中，好比HotSpot。

驗證

驗證是鏈接階段的第一個步驟，驗證的目的是爲了確保.class文件中的字節流所包含的信息是符合當前虛擬機的要求，而且不會危害到虛擬機自身的安全的。

Java語言自己是相對安全的語言，使用Java編碼是沒法作到如訪問數組邊界之外的數據、將一個對象轉型爲它並未實現的類型等，若是這樣作了，編譯器將拒絕編譯。可是，Class文件並不必定是由Java源碼編譯而來，可使用任何途徑，包括用十六進制編輯器(如UltraEdit)直接編寫。若是直接編寫了有害的「代碼」(字節流)，而虛擬機在加載該Class時不進行檢查的話，就有可能危害到虛擬機或程序的安全。

不一樣的虛擬機，對類驗證的實現可能有所不一樣，但大體都會完成下面四個階段的驗證：文件格式驗證、元數據驗證、字節碼驗證和符號引用驗證。

1. 文件格式驗證，是要驗證字節流是否符合Class文件格式的規範，而且能被當前版本的虛擬機處理。如驗證魔數是否0xCAFEBABE；主、次版本號是否正在當前虛擬機處理範圍以內；常量池的常量中是否有不被支持的常量類型……該驗證階段的主要目的是保證輸入的字節流能正確地解析並存儲於方法區中，通過這個階段的驗證後，字節流纔會進入內存的方法區中存儲，因此後面的三個驗證階段都是基於方法區的存儲結構進行的。
2. 元數據驗證，是對字節碼描述的信息進行語義分析，以保證其描述的信息符合Java語言規範的要求。可能包括的驗證如：這個類是否有父類；這個類的父類是否繼承了不容許被繼承的類；若是這個類不是抽象類，是否實現了其父類或接口中要求實現的全部方法……
3. 字節碼驗證，主要工做是進行數據流和控制流分析，保證被校驗類的方法在運行時不會作出危害虛擬機安全的行爲。若是一個類方法體的字節碼沒有經過字節碼驗證，那確定是有問題的；但若是一個方法體經過了字節碼驗證，也不能說明其必定就是安全的。
4. 符號引用驗證，發生在虛擬機將符號引用轉化爲直接引用的時候，這個轉化動做將在「解析階段」中發生。驗證符號引用中經過字符串描述的權限定名是否能找到對應的類；在指定類中是否存在符合方法字段的描述符及簡單名稱所描述的方法和字段；符號引用中的類、字段和方法的訪問性(private、protected、public、default)是否可被當前類訪問

驗證階段對於虛擬機的類加載機制來講，不必定是必要的階段。若是所運行的所有代碼確認是安全的，可使用-Xverify：none參數來關閉大部分的類驗證措施，以縮短虛擬機類加載時間。

準備

準備階段是爲類的靜態變量分配內存並將其初始化爲默認值，這些內存都將在方法區中進行分配。準備階段不分配類中的實例變量的內存，實例變量將會在對象實例化時隨着對象一塊兒分配在Java堆中。

有三點須要注意：

1. 在方法區中分配內存的只有類變量（被static修飾的變量），而不包括實例變量，實例變量將會跟隨着對象在 Java 堆中爲其分配內存
2. 初始化類變量的時候，是將類變量初始化爲其類型對應的0值，好比有以下類變量，在準備階段完成以後val的值是0而不是 123，爲 val複製爲123，是在後面要講的初始化階段以後

public static int val=123;//在準備階段value初始值爲0 。在初始化階段纔會變爲123 。
複製代碼

3. 對於常量，其對應的值會在編譯階段就存儲在字段表的ConstantValue屬性當中，因此在準備階段結束以後，常量的值就是ConstantValue所指定的值了，好比以下，在準備階段結束以後，val的值就是123了。

public static final int val = 123;
複製代碼

解析

解析階段是虛擬機將常量池內的符號引用替換爲直接引用的過程。 符號引用（Symbolic Reference）：符號引用以一組符號來描述所引用的目標，符號能夠是任何形式的字面量，只要使用時能無歧義地定位到目標便可。符號引用與虛擬機實現的內存佈局無關，引用的目標並不必定已經加載到內存中。 直接引用（Direct Reference）：直接引用能夠是直接指向目標的指針、相對偏移量或是一個能間接定位到目標的句柄。直接引用是與虛擬機實現的內存佈局相關的，若是有了直接引用，那麼引用的目標一定已經在內存中存在。

初始化

類的初始化階段纔是真正開始執行類中定義的 Java 程序代碼。初始化說白了就是調用類構造器<clinit>()的過程，在類的構造器中會爲類變量初始化定義的值，會執行靜態代碼塊中的內容。下面將介紹幾點和開發者關係較爲緊密的注意點

1. 類構造器<clinit>()是由編譯器自動收集類中出現的類變量、靜態代碼塊中的語句合併產生的，收集的順序是在源文件中出現的順序決定的，靜態代碼塊能夠訪問出如今靜態代碼塊以前的類變量，出現的靜態代碼塊以後的類變量，只能夠賦值，可是不能訪問，好比以下代碼

public class Demo {
    private static String before = "before";
    static {
            after = "after";                    // 賦值合法
            System.out.println(before);         // 訪問合法，由於出如今 static{} 以前
            System.out.println(after);          // 訪問不合法，由於出如今 static{} 以後
    }
    private static String after;
}
複製代碼

2. <clinit>()類構造器和<init>()實例構造器不一樣，類構造器不須要顯示的父類的類構造，在子類的類構造器調用以前，會自動的調用父類的類構造器。所以虛擬機中第一個被調用的<clinit>()方法是 java.lang.Object的類構造器
3. 因爲父類的類構造器優先於子類的類構造器執行，因此父類中的static{}代碼塊也優先於子類的static{}執行
4. 類構造器<clinit>()對於類來講並非必需的，若是一個類中沒有類變量，也沒有static{}，那這個類不會有類構造器<clinit>()
5. 接口中不能有static{}，可是接口中也能夠有類變量，因此接口中也能夠有類構造器 <clinit>{}，可是接口的類構造器和類的類構造器有所不一樣，接口在調用類構造器的時候，若是不須要，不用調用父接口的類構造器，除非用到了父接口中的類變量，接口的實現類在初始化的時候也不會調用接口的類構造器
6. 虛擬機會保證一個類的<clinit>()方法在多線程環境中被正確地加鎖、同步，若是多個線程同時去初始化一個類，那麼只有一個線程去執行這個類的類構造器<clinit>()，其餘線程會被阻塞，直到活動線程執行完類構造器<clinit>()方法

結束語

看到這裏不容易了，你們應該都理解類加載的流程了吧，但願之後遇到這樣的面試題能想起這篇文章

博主主頁

能夠和博主一塊兒交流：