我們都知道 Java 源文件通過編譯器 javac 命令能夠編譯生成相應的 class 文件，即二進制字節碼文件。Java 虛擬機將描述類或接口的 class 文件（準確地說，應該是類的二進制字節流）加載到內存，對數據進行校驗、轉換解析和初始化，最終形成能夠被虛擬機直接使用的 Java 類型，真正能夠執行字節碼的操作才剛剛開始。這個過程就是虛擬機的類加載機制。
類的加載過程概述
按照 Java 虛擬機規範，一個 Java 文件（類或接口）從被加載到內存到被卸載出內存的整個生命過程，總共經歷 5 個大的階段：加載、連接（驗證+準備+解析）、初始化、使用、卸載。其中第二個階段“連接”可細分為 3 個階段：驗證、準備和解析。因此很多書籍上也將 Java 類的生命週期劃分為 7 個階段。
類的生命週期
Java 虛擬機動態地加載類和接口，整個加載過程包括加載、連接和初始化 3 個階段。
- 加載階段：根據特定名稱查找類或接口類型的二進制數據文件，就是 class 文件，並由此數據文件來創建類或接口的過程。
- 連接階段：為了讓類和接口可以被 Java 虛擬機執行，而將類或接口併入虛擬機運行時狀態的過程。這個階段做的工作比較多，還可以細分為下面三個階段：
- 驗證階段：主要是校驗類文件結構上的正確性，確保 class 中的數據信息符合當前虛擬機的約束要求。
- 準備階段：為類或接口的靜態變量分配內存，並且以初始化這些變量的默認值，這些變量需要使用的內存都在方法區中進行分配。
- 解析階段：虛擬機將類在常量池內的符號引用轉換為直接引用的過程。
- 初始化階段：初始化對於類或接口來說，就是執行它的初始化方法
(),真正開始執行類中定義的 Java 程序代碼，為類的靜態變量賦予正確的初始值。
加載、驗證、準備和初始化這 4 個階段發生的順序是確定的，而解析階段則不一定，它在某些情況下可以在初始化階段之後開始，這是為了支持 Java 語言的運行時綁定（也稱為動態綁定或後期綁定）。另外需要注意的是這裡的幾個階段是按順序開始，而不是按順序進行或完成，因為這些階段通常都是互相交叉地混合進行的，通常在一個階段執行的過程中調用或激活另一個階段。
這裡簡要說明下 Java 中的綁定：綁定指的是把一個方法的調用與方法所在的類（方法主體）關聯起來，綁定分為靜態綁定和動態綁定：
靜態綁定：即前期綁定。在程序執行前方法已經被綁定，此時由編譯器或其它連接程序實現。針對 Java 來說，簡單的可以理解為程序編譯期的綁定。Java 當中的方法只有 final，static，private 和構造方法是前期綁定的。
動態綁定：即後期綁定，也叫運行時綁定。在運行時根據具體對象的類型進行綁定。在 Java 中，幾乎所有的方法都是後期綁定的。
類的主動引用與被動引用
在整個類加載的過程中，第一個階段“加載”在虛擬機規範中並沒強行約束，這點可以交給虛擬機的具體實現自由設計，但是對於初始化階段虛擬機規範是嚴格規定了如下幾種情況，如果類未初始化會對類進行初始化（當然加載、驗證和準備階段自然需要在此之前開始）。
1.在執行下列需要引用類或接口的 Java 虛擬機指令時：new、getstatic、putstatic或invokestatic，如果類沒有進行過初始化，則需要先觸發其初始化。生成這四條指令的常見 Java 代碼時機分別是：使用 new 關鍵字實例化對象的時候，讀取或者設置一個類的靜態變量（被 final 修飾的靜態變量即常量、已經在編譯器把結果放入常量池的靜態變量除外）的時候，或是調用類的靜態方法的時候。
讀取或設置類的靜態變量會觸發類初始化，示例如下：
public class Initialization {
static {
System.out.println("init!");
}
public static int x = 0;
}
public class Test {
public static void main(String[] args) {
System.out.println(Initialization.x);
}
}
輸出結果：
init!0
調用類的靜態方法會觸發類初始化，示例如下：
public class Initialization {
static {
System.out.println("init!");
}
public static void test() {
}
}
public class Test {
public static void main(String[] args) {
Initialization.test();
}
}
輸出結果：
init!
2.調用類庫 java.lang.reflect 包中某些方法對類進行反射調用的時候，如果類沒有進行過初始化，則需要先觸發其初始化。示例如下：
public class Initialization {
static {
System.out.println("init!");
}
}
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class.forName("jvm.init.demo.Initialization");
}
}
輸出結果：
init!
3.在對一個類的某個子類進行初始化的時候，如果發現該類沒有進行過初始化，則需要先觸發其初始化。
public class Parent {
static {
System.out.println("Parent init!");
}
}
public class Child extends Parent {
static {
System.out.println("Child init!");
}
}
public class Initialization {
static {
System.out.println("init!");
}
public static void main(String[] args) {
Child child = new Child();
}
}
輸出結果：
init!
Parent init!
Child init!
4.在類被選定為 Java 虛擬機啟動時的初始類時（包含 main() 的那個類），虛擬機會先初始化這個主類。如上示例所示，虛擬機會先初始化 Initialization 這個主類。
5.在使用 JDK1.7 的動態語言支持下，初次調用 java.lang.invoke.MethodHandle 實例後的解析結果是 REF_getStatic、REF_putStatic、REF_invokeStatic 的方法句柄，並且這個方法所對應的類沒有進行過初始化，則需要先觸發其初始化。
根據虛擬機規範，類或接口首次主動引用時才會對其初始化，且只有以上幾種對類主動引用的場景才會觸發類的初始化，除此之外，其餘的都稱為被動引用，且都不會觸發初始化。
關於類的主動引用和被動引用，下面舉幾個容易引起大家混淆的例子來說明什麼是被動引用。
- 定義某個類的數組時不會觸發該類的初始化，比如下面的例子：
public class Person {
static {
System.out.println("Person init!");
}
}
public class Test {
public static void main(String[] args) {
Person[] p = new Person[10];
System.out.println(p.length);
}
}
輸出結果：
10
從結果中並沒有看到輸出：Person init! 因此，新建 Person 數組並沒有觸發 Person 類的初始化，是被動引用。
- 子類引用父類的靜態字段，不會導致子類初始化，如下例子：
public class Parent {
static {
System.out.println("Parent init!");
}
public static String s = "hello";
}
public class Child extends Parent {
static {
System.out.println("Child init!");
}
}
public class Test {
public static void main(String[] args) {
System.out.println(Child.s);
}
}
輸出結果：
Parent init!
hello
從結果中沒有看到輸出：Child init! 因此，並沒有觸發子類的初始化，屬於被動引用。
- 引用類的靜態常量不會導致類的初始化，看下面例子：
public class Constants {
static {
System.out.println("Constants init!");
}
public static final String HELLO = "hello";
}
public class Test {
public static void main(String[] args) {
System.out.println(Constants.HELLO);
}
}
輸出結果：
hello
從結果中沒有看到輸出：Constants init!常量在編譯階段會存入調用類的常量池中，其實並沒有直接引用到定義常量的類，因此沒有觸發定義常量的類的初始化。
類的加載過程詳解
在詳細講解 Java 虛擬機中類加載的各個階段前，我們先看下面的這段單例程序，思考下程序的輸出結果：
public class Singleton {
// ①
private static int a = 0;
private static int b;
private static Singleton instance = new Singleton(); // ②
private Singleton() {
a++;
b++;
}
public static Singleton getInstance() {
return instance;
}
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
System.out.println("a = " + instance.a);
System.out.println("b = " + instance.b);
}
}
運行上面的程序結果輸出為：
a = 1
b = 1
將 ② 這行代碼上移到註釋 ① 的位置，再次運行結果輸出為：
a = 0
b = 1
輸出不一樣的結果，這是為什麼呢？通過下面的學習，我們在後面詳細解釋這個現象。
類的加載（Loading）階段
“加載”是整個“類加載”過程的第一個階段，簡單來說，類的加載就是將 class 文件中的二進制數據讀取到內存中，將這個字節流所代表的靜態存儲結構轉化為方法區的運行時數據結構，並且在內存中生成一個代表這個類的 java.lang.Class 對象，作為訪問方法區數據結構的入口。
Java 虛擬機規範定義類的加載是通過全限定名（包名+類名）來獲取二進制數據流，但並沒有強行約束必須通過某種方式獲取或者從某個地方獲取，通過以下幾種常見的形式來獲取描述類的二進制數據流：
- 通過讀取 zip 文件獲取，比如 jar、war。
- 運行時動態生成，通過動態代理 java.lang.Proxy 生成代理類的二進制字節流，或者使用 ASM 包生成 class。
- 通過網絡獲取，如 Applet 小程序、RMI 動態調用發佈。
- 將類的二進制數據存儲在數據庫的 BLOB 字段中，從數據庫中獲取。
在某個類經歷加載階段後，虛擬機首先會將二進制字節流按照虛擬機所需的格式存儲在方法區中，虛擬機規範沒有規定方法區中的具體數據結構，該區域中的數據存儲格式由虛擬機實現自行定義。隨後在內存中實例化一個 java.lang.Class 對象，以便後面程序可通過該對象去訪問方法區中的這些類型數據。在類加載的整個生命週期中，加載階段是可以與連接階段的部門內容交叉進行的，比如連接階段驗證字節碼文件格式，但是加載階段肯定還是在連接階段之前開始的。
類的連接（Linking）階段
類的連接階段可細分為 3 個小的過程：驗證、準備和解析。
1.驗證
驗證是連接階段的第一步，驗證是為了確保 Class 文件的字節流中包含的信息符合當前虛擬機的要求，並且不會危害虛擬機自身的安全。
不同的虛擬機，對類驗證的實現可能有所不同，但大致都會完成下面四個階段的驗證：文件格式驗證、元數據驗證、字節碼驗證和符號引用驗證。
1.文件格式驗證，驗證字節流是否符合 Class 文件格式的規範，並且能被當前版本的虛擬機處理。
如驗證魔數是否 0xCAFEBABE；
主、次版本號是否正在當前虛擬機處理範圍之內；
常量池的常量中是否有不被支持的常量類型等等。
該驗證階段的主要目的是保證輸入的字節流能正確地解析並存儲於方法區中，經過這個階段的驗證後，字節流才會進入內存的方法區中存儲，所以後面的三個驗證階段都是基於方法區的存儲結構進行的。
2.元數據驗證，是對字節碼描述的信息進行語義分析，以保證其描述的信息符合Java語言規範的要求。可能包括的驗證如：
這個類是否有父類；
這個類的父類是否繼承了不允許被繼承的類；
如果這個類不是抽象類，是否實現了其父類或接口中要求實現的所有方法等等。
3.字節碼驗證，主要工作是進行數據流和控制流分析，保證被校驗類的方法在運行時不會做出危害虛擬機安全的行為。
如果一個類方法體的字節碼沒有通過字節碼驗證，那肯定是有問題的；
但如果一個方法體通過了字節碼驗證，也不能說明其一定就是安全的。
4.符號引用驗證，發生在虛擬機將符號引用轉化為直接引用的時候，這個轉化動作將在“解析階段”中發生。
驗證符號引用中通過字符串描述的權限定名是否能找到對應的類；
在指定類中是否存在符合方法字段的描述符及簡單名稱所描述的方法和字段；
符號引用中的類、字段和方法的訪問性(private、protected、public、default)是否可被當前類訪問。
驗證階段對於虛擬機的類加載機制來說，不一定是必要的階段。如果所運行的全部代碼確認是安全的，可以使用-Xverify：none參數來關閉大部分的類驗證措施，以縮短虛擬機加載類的時間。
2.準備
準備階段是為類的靜態變量分配內存並將其初始化為默認值，這些內存都將在方法區中進行分配。準備階段不分配類中的實例變量的內存，實例變量將會在對象實例化時隨著對象一起分配在Java堆中。
//在準備階段 value 初始值為 0，在初始化階段才會賦值為 100
public static int value = 100;
3.解析
解析階段是虛擬機將常量池內的符號引用替換為直接引用的過程。
符號引用（Symbolic Reference）：符號引用以一組符號來描述所引用的目標，符號可以是任何形式的字面量，只要使用時能無歧義地定位到目標即可。符號引用與虛擬機實現的內存佈局無關，引用的目標並不一定已經加載到內存中。
直接引用（Direct Reference）：直接引用可以是直接指向目標的指針、相對偏移量或是一個能間接定位到目標的句柄。直接引用是與虛擬機實現的內存佈局相關的，如果有了直接引用，那麼引用的目標必定已經存在於內存中。
類的初始化（Initialization）階段
類初始化是類加載過程的最後一步，前面的類加載過程，除了在加載階段用戶應用程序可以通過自定義類加載器參與之外，其餘動作完全由虛擬機主導和控制。到了初始化階段，才真正開始執行類中定義的 Java 程序代碼。
初始化階段是執行類構造器
程序結果分析
結合類加載過程的詳細說明，最後分析一下之前給出的程序片段：
public class Singleton {
// ①
private static int a = 0;
private static int b;
private static Singleton instance = new Singleton(); // ②
private Singleton() {
a++;
b++;
}
public static Singleton getInstance() {
return instance;
}
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
System.out.println("a = " + instance.a);
System.out.println("b = " + instance.b);
}
}
分析說明如下：
1.Singleton instance = Singleton.getInstance(); Singleton 調用了類的靜態方法，觸發類的初始化；
2.類加載的時候在準備過程中為類的靜態變量分配內存並初始化默認值 instance = null, a = 0, b = 0；
3.類開始初始化，為類的靜態變量賦值和執行靜態代碼塊，此時被賦值 a = 0，此時 b 沒有賦值操作 b = 0， instance 被賦值為 new Singleton() 調用類的構造方法；
4.調用類的構造方法後 a = 1;b = 1。
若將 ② 這行代碼上移到註釋 ① 的位置：
1.Singleton instance = Singleton.getInstance(); Singleton 調用了類的靜態方法，觸發類的初始化；
2.類加載的時候在準備過程中為類的靜態變量分配內存並初始化默認值 instance = null, a = 0, b=0；
3.類開始初始化，為類的靜態變量賦值和執行靜態代碼塊，instance 被賦值為 new Singleton() 調用類的構造方法；
4.調用類的構造方法後 a = 1; b = 1；
5.繼續為 a 和 b 賦值，此時 b 沒有賦值操作，所以 b 為 1，但是 a 執行賦值操作就被賦值為 0.
關注、轉發、評論頭條號每天分享java 知識，私信回覆“555”贈送一些Dubbo、Redis、Netty、zookeeper、Spring cloud、分佈式資料
閱讀更多 來一杯82年的Java 的文章
