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

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

這些階段通常都是互相交叉的混合式進(jìn)行的，通常會在一個階段執(zhí)行的過程中調(diào)用或激活另外一個階段。

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

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

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

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

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

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

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

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

/**
    通過子類引用父類的類變量不會觸發(fā)子類的初始化操作
*/
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
*/

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

/**
    引用類的final類型的類變量無法觸發(fā)類的初始化操作
*/  
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
*/ 

了解了什么時候出發(fā)初始化操作后，那么初始化操作的執(zhí)行順序是什么樣的？并發(fā)初始化情況下的運行機(jī)制又如何？
JVM虛擬機(jī)規(guī)定了幾條標(biāo)準(zhǔn)：

先父類后子類，（源碼中）先出現(xiàn)先執(zhí)行

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

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

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

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

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

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
*/