摘要：類加載過程共分為加載驗證準備解析初始化使用和卸載七個階段這些階段通常都是互相交叉的混合式進行的，通常會在一個階段執行的過程中調用或激活另外一個階段。

JVM類加載過程共分為加載、驗證、準備、解析、初始化、使用和卸載七個階段

這些階段通常都是互相交叉的混合式進行的，通常會在一個階段執行的過程中調用或激活另外一個階段。

加載過程是JVM類加載的第一步，如果JVM配置中打開-XX:+TraceClassLoading，我們可以在控制臺觀察到類似

[Loaded chapter7.SubClass from file:/E:/EclipseData-Mine/Jvm/build/classes/]

的輸出，這就是類加載過程的日志。
加載過程是作為程序猿最可控的一個階段，因為你可以隨意指定類加載器，甚至可以重寫loadClass方法，當然，在jdk1.2及以后的版本中，loadClass方法是包含雙親委派模型的邏輯代碼的，所以不建議重寫這個方法，而是鼓勵重寫findClass方法。
類加載的二進制字節碼文件可以來自jar包、網絡、數據庫以及各種語言的編譯器編譯而來的.class文件等各種來源。
加載過程主要完成如下三件工作：
1>通過類的全限定名（包名+類名）來獲取定義此類的二進制字節流
2>將字節流所代表的靜態存儲結構轉化為運行時數據結構存儲在方法區
3>為類生成java.lang.Class對象，并作為該類的唯一入口

這里涉及到一個概念就是類的唯一性，書上對該概念的解釋是：在類的加載過程中，一個類由類加載器和類本身唯一確定。也就是說，如果一個JVM虛擬機中有多個不同加載器，即使他們加載同一個類文件，那得到的java.lang.Class對象也是不同的。因此，只有在同一個加載器中，一個類才能被唯一標識，這叫做類加載器隔離。

驗證過程相對來說就有復雜一點了，不過驗證過程對JVM的安全還是至關重要的，畢竟你不知道比人的代碼究竟能干出些什么。
驗證過程主要包含四個驗證過程：
1>文件格式驗證
四個驗證過程中，只有格式驗證是建立在二進制字節流的基礎上的。格式驗證就是對文件是否是0xCAFEBABE開頭、class文件版本等信息進行驗證，確保其符合JVM虛擬機規范。
2>元數據驗證
元數據驗證是對源碼語義分析的過程，驗證的是子類繼承的父類是否是final類；如果這個類的父類是抽象類，是否實現了起父類或接口中要求實現的所有方法；子父類中的字段、方法是否產生沖突等，這個過程把類、字段和方法看做組成類的一個個元數據，然后根據JVM規范，對這些元數據之間的關系進行驗證。所以，元數據驗證階段并未深入到方法體內。
3>字節碼驗證
既然元數據驗證并未深入到方法體內部，那么到了字節碼驗證過程，這一步就不可避免了。字節碼主要是對方法體內部的代碼的前后邏輯、關系的校驗，例如：字節碼是否執行到了方法體以外、類型轉換是否合理等。
當然，這很復雜。
所以，即使是到了如今jdk1.8，也還是無法完全保證字節碼驗證準確無遺漏的。而且，如果在字節碼驗證浪費了大量的資源，似乎也有些得不償失。
4>符號引用驗證
符號引用的驗證其實是發生在符號引用向直接引用轉化的過程中，而這一過程發生在解析階段。
因為都是驗證，所以一并在這講。符號引用驗證做的工作主要是驗證字段、類方法以及接口方法的訪問權限、根據類的全限定名是否能定位到該類等。具體過程會在接下來的解析階段進行分析。
好了，驗證階段的工作基本就是以上四類，下面我們來看下一個階段。

相信經歷過艱辛的驗證階段的磨練，JVM和我們都倍感疲憊。所以，接下來的準備階段給我們提供了一個相對輕松的休息階段。
準備階段要做的工作很簡單，他瞄準了類變量這個元數據，把他放進了方法區并進行了初始化，這里的初始化并不是或者操作，準備階段只是將這些可愛的類變量置零。

這一部分我畫了幾個圖，內容有些多，放在另一篇文章里：解析

初始化階段是我們可以大搞實驗的一塊實驗田。首先，初始化階段做什么？這個階段就是執行方法。而方法是由編譯器按照源碼順序依次掃描類變量的賦值動作和static代碼塊得到的。
那么問題來了，啥時候才會觸發一個類的初始化的操作呢？答案有且只有五個：
1>在類沒有進行過初始化的前提下，當執行new、getStatic、setStatic、invokeStatic字節碼指令時，類會立即初始化。對應的java操作就是new一個對象、讀取/寫入一個類變量（非final類型）或者執行靜態方法。
2>在類沒有進行過初始化的前提下，當一個類的子類被初始化之前，該父類會立即初始化。
3>在類沒有進行過初始化的前提下，當包含main方法時，該類會第一個初始化。
4>在類沒有進行過初始化的前提下，當使用java.lang.reflect包的方法對類進行反射調用時，該類會立即初始化。
5>在類沒有進行過初始化的前提下，當使用JDK1.5支持時，如果一個java.langl.incoke.MethodHandle實例最后的解析結果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且這個方法句柄所對應的類沒有進行過初始化，則需要先觸發其初始化。
以上五種情況被稱作類的五種主動引用，除此之外的任何情況都被相應地叫做被動引用。以下是集中常見的且容易迷惑人心智的被動引用的示例：

/**
    通過子類引用父類的類變量不會觸發子類的初始化操作
*/
public class SuperClass {
    
    public static String value = "superClass value";
    
    static {
        System.out.println("SuperClass init!");
    }
}

public class SubClass extends SuperClass implements SuperInter{

    static {
        System.out.println("SubClass init!");
    }
}

public class InitTest {
    
    static {
        System.out.println("InitTest init!");//main第一個初始化
    }

    public static void main(String[] args) {
        System.out.println(SubClass.value);
    }
}

/**
output:
InitTest init!
SuperClass init!
superClass value
*/

/**
    通過定義對象數組的方式是不能觸發對象初始化的
*/
    public static void main(String[] args) {
        SubClass[] superArr = new SubClass[10];
    }
/**
output:
InitTest init!
*/   

/**
    引用類的final類型的類變量無法觸發類的初始化操作
*/  
public class SuperClass {
    public static final String CONSTANT_STRING = "constant";
    
    static {
        System.out.println("SuperClass init!");
    }
}

public class InitTest {
    static {
        System.out.println("InitTest init!");//main
    }

    public static void main(String[] args) {
        System.out.println(SuperClass.CONSTANT_STRING);//getStatic
    }
}
/**
output:
InitTest init!
constant
*/ 

了解了什么時候出發初始化操作后，那么初始化操作的執行順序是什么樣的？并發初始化情況下的運行機制又如何？
JVM虛擬機規定了幾條標準：

先父類后子類，（源碼中）先出現先執行

向前引用：一個類變量在定義前可以賦值，但是不能訪問。

非必須：如果一個類或接口沒有類變量的賦值動作和static代碼塊，那就不生成方法.

執行接口的方法不需要先執行父接口的方法。只有當父接口中定義的變量被使用時，父接口才會被初始化。另外，接口的實現類在初始化時也一樣不會執行接口的方法。

同步性：方法的執行具有同步性，并且只執行一次。但當一個線程執行該類的方法時，其他的初始化線程需阻塞等待。

我們通過一個實例來驗證線程的阻塞問題：

public class SuperClass {    
    static {
        System.out.println("SuperClass init!");
        System.out.println("Thread.currentThread(): " + Thread.currentThread() + " excuting...");
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class InitTest {
    
    static {
        System.out.println("InitTest init!");//main
    }

    public static void main(String[] args) throws ClassNotFoundException, InterruptedException {
        currentInitTest();
    }
    
    public static void currentInitTest() throws InterruptedException {
        Runnable run = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread.currentThread(): " + Thread.currentThread() + " start");
                new SuperClass();
                System.out.println("Thread.currentThread(): " + Thread.currentThread() + " end");
            }
        };
        
        Thread[] threadArr = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArr[i] = new Thread(run);
        }
        
        for (Thread thread : threadArr) {
            thread.start();
        }    
    }
}

/**
output:
InitTest init!
Thread.currentThread(): Thread[Thread-0,5,main] start
Thread.currentThread(): Thread[Thread-1,5,main] start
Thread.currentThread(): Thread[Thread-2,5,main] start
Thread.currentThread(): Thread[Thread-7,5,main] start
Thread.currentThread(): Thread[Thread-6,5,main] start
Thread.currentThread(): Thread[Thread-3,5,main] start
Thread.currentThread(): Thread[Thread-5,5,main] start
Thread.currentThread(): Thread[Thread-9,5,main] start
Thread.currentThread(): Thread[Thread-4,5,main] start
Thread.currentThread(): Thread[Thread-8,5,main] start
SuperClass init!
Thread.currentThread(): Thread[Thread-0,5,main] excuting...
Thread.currentThread(): Thread[Thread-9,5,main] end
Thread.currentThread(): Thread[Thread-3,5,main] end
Thread.currentThread(): Thread[Thread-6,5,main] end
Thread.currentThread(): Thread[Thread-7,5,main] end
Thread.currentThread(): Thread[Thread-0,5,main] end
Thread.currentThread(): Thread[Thread-5,5,main] end
Thread.currentThread(): Thread[Thread-4,5,main] end
Thread.currentThread(): Thread[Thread-8,5,main] end
Thread.currentThread(): Thread[Thread-1,5,main] end
Thread.currentThread(): Thread[Thread-2,5,main] end
*/