【JVM類加載】類的初始化和類加載器雙親委托機(jī)制
作者：滬漂的陳同學(xué)
類被加載后,就進(jìn)入鏈接階段。鏈接就是將已經(jīng)讀入到內(nèi)存的類的二進(jìn)制數(shù)據(jù)合并到虛擬機(jī)的運(yùn)行時環(huán)境中去。
以此遞進(jìn)，先加載test9調(diào)用子類，先初始化父類，類的初始化7中之一。
有兩種類型的類加載器
java虛擬機(jī)自帶的加載器
- 根類加載器（Bootstrap）
- 擴(kuò)展類加載器（Extension）
- 系統(tǒng)（應(yīng)用）類加載器（System）（2，3都屬于Launcher類的內(nèi)部類）
用戶自定義的類加載器
- java.lang.ClassLoader的子類。
- 用戶可以定制類的加載方式。
- 包括自定義類加載器在構(gòu)造的時候在構(gòu)造方法中傳入了一個父類加載。
類的加載器并不需要等到某個類被“首次主動使用”時再加載它（個人理解 加載不一定初始化，初始化一定加載）。
類的加載
- jvm規(guī)范允許類加載器在預(yù)料某個類將要被使用時就預(yù)先加載他，如果在預(yù)先加載的過程中遇到了.class文件缺失或存在錯誤，類加載器必須在程序首次主動使用該類時才報告錯誤（LinkageError錯誤）。
- 如果這個類一直沒有被程序主動使用,那么類加載器就不會報告錯誤。
類被加載后,就進(jìn)入鏈接階段。鏈接就是將已經(jīng)讀入到內(nèi)存的類的二進(jìn)制數(shù)據(jù)合并到虛擬機(jī)的運(yùn)行時環(huán)境中去。
類的初始化類的初始化步驟
- 假如這個類還沒有被加載和連接，那就先進(jìn)行加載和連接。
- 假如類存在直接父類，并且這個父類還沒有被初始化，那就先初始化直接父類。
- 假如類中存在初始化語句，那就依次執(zhí)行這些初始化語句。
類的初始化時機(jī)
主動使用（7種，重要）除了七種情形，其他使用java類的方式都被看做是被動使用，不會導(dǎo)致類的初始化。
初始化時機(jī)
jdk1.8在之后首次調(diào)用接口的靜態(tài)方法和default方法也會導(dǎo)致接口初始化。
初始化時機(jī)
示例：
public class Test5 {
public static void main(String[] args) {
//驗證初始化一個類時,并不會先初始化它所實現(xiàn)的接口
// System.out.println(MyChild5.b);
//驗證初始化一個接口時,并不會初始化它所實現(xiàn)的接口
System.out.println(MyChild5_1.thread);
}
}
interface MyParcnt5{
public static Thread thread = new Thread(){
{
System.out.println("MyParcnt5 invoked");
}
};
public static final int a = 5;
}
//interface MyChild5 extends MyParcnt5{
//
// public static int b = new Random().nextInt(4);
//}
class MyChild5 implements MyParcnt5{
//此時MyChild5 被加載并沒有被初始化 （加載不一定初始化，初始化一定加載）
public static int b = 6;
}
interface MyParcnt5_1{
public static Thread thread = new Thread(){
{
System.out.println("MyParcnt5_1 invoked");
}
};
}
interface MyChild5_1 extends MyParcnt5_1 {
public static Thread thread = new Thread(){
{
System.out.println("MyChild5_1 invoked");
}
};
}類加載器雙親委托機(jī)制詳解
他們之間存在的是包含關(guān)系 不是繼承關(guān)系樹形結(jié)構(gòu)。
public abstract class ClassLoader {
private static native void registerNatives();
static {
registerNatives();
}
// The parent class loader for delegation
// Note: VM hardcoded the offset of this field, thus all new fields
// must be added *after* it.
private final ClassLoader parent;ClassLoader中有一個成員變量定義著雙親 因為除了根類加載器每個加載器都繼承于ClassLoder 所以每個ClassLoaderd都存在著對應(yīng)的雙親 所以他們之間存在的是包含關(guān)系 不是繼承關(guān)系樹形結(jié)構(gòu)。
加載過程
在雙親委托機(jī)制中,各個加載器按照父子關(guān)系形成了樹形結(jié)構(gòu),除了根類加載器之外,其余的類加載器都有且只有一個父加載器。
加載過程
每個類都需要類加載器去加載，如果有父類,先讓父類去加載，如此向上追溯，直到根類加載器，然后根類加載器嘗試去加載，加載成功賊結(jié)束，加載失敗，又往下，一層層的嘗試去加載，最終如果都沒有加載成功則報錯。
加載方式
回顧之前學(xué)的知識點。
public class Test7 {
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("java.lang.String");
System.out.println(clazz.getClassLoader());//獲取類加載器,如果是Bootstrap ClassLoader 根加載器加載可能會返回null
Class<?> clazs = Class.forName("com.example.demo.com.jvm.C");
System.out.println(clazs.getClassLoader());//sun.misc.Launcher$AppClassLoader@18b4aac2 基本上工程編寫的類都是由系統(tǒng)（應(yīng)用）加載器AppClassLoader加載的
}
}
class C {
}打印結(jié)果：
null
sun.misc.Launcher$AppClassLoader@18b4aac2class FinalTest {
public static final int x = 3;
// public static final int x = new Random().nextInt(3);
static {
System.out.println("FinalTest static block");
}
}
public class Test8 {
public static void main(String[] args) {
System.out.println(FinalTest.x);
}
}/*
public static final int x = 3; 時 此時在編譯階段 常量x 會被放進(jìn)Test8的常量池 直接拿來使用 FinalTest 并不會被初始化
3
*/
/*
public static final int x = new Random().nextInt(3);時 new Random().nextInt(3)生成隨機(jī)數(shù)實在運(yùn)行時生成的 所以 Test8和FinalTest 有聯(lián)系 此時FinalTest類會被加載
FinalTest static block
1
*/class Parent {
static int a = 3;
static {
System.out.println("Parent static block");
}
}
class Child extends Parent {
static int b = 4;
static {
System.out.println("Child static block");
}
}
public class Test9 {
static {
System.out.println("Test9 static block");
}
public static void main(String[] args) {
System.out.println(Child.b);
}
}以此遞進(jìn) 先加載test9 調(diào)用子類 先初始化父類 類的初始化7種之一。
/*
以此遞進(jìn) 先加載test9 調(diào)用子類 先初始化父類 類的初始化7中之一
Test9 static block
Parent static block
Child static block
4
*/class Parent1 {
static int a = 3;
static {
System.out.println("Parent static block");
}
}
class Child1 extends Parent1 {
static int b = 4;
static {
System.out.println("Child static block");
}
}
public class Test10 {
static {
System.out.println("Test10 static block");
}
public static void main(String[] args) {
Parent1 parent1;
System.out.println("===========");
parent1 = new Parent1();
System.out.println("===========");
System.out.println(parent1.a);
System.out.println("===========");
System.out.println(Child1.b);
}
}類只會首次加載才會初始化。
/*
類只會首次加載才會初始化
Test10 static block
===========
Parent static block
===========
3
===========
Child static block
4
*/class Parent3 {
static int a = 3;
static {
System.out.println("Parent3 static block");
}
static void doSomething() {
System.out.println("do doSomething");
}
}
class Child3 extends Parent3 {
static {
System.out.println("Child3 static block");
}
}
public class Test11 {
public static void main(String[] args) {
System.out.println(Child3.a); //類名.父類靜態(tài)變量和靜態(tài)方法 表示對父類的主動使用 此時子類并不初始化
System.out.println("---------------");
Child3.doSomething();
}
}類名.父類靜態(tài)變量和靜態(tài)方法 表示對父類的主動使用 此時子類并不初始化。
//調(diào)用ClassLoader類的loadClass方法加載一個類,并不是對類的主動使用,不會導(dǎo)致類的初始化
public class Test12 {
public static void main(String[] args) throws ClassNotFoundException {
ClassLoader loder = ClassLoader.getSystemClassLoader(); //獲取系統(tǒng)加載器
Class<?> aClass = loder.loadClass("com.example.demo.com.jvm.CL");//加載對應(yīng)類 除卻7種都是被動使用 不會初始化
System.out.println(aClass);
System.out.println("-----------------");
Class<?> aClass1 = Class.forName("com.example.demo.com.jvm.CL");//7種之一
System.out.println(aClass1);
}
}只有反射初始化CL了 調(diào)用ClassLoader類的loadClass方法加載一個類,并不是對類的主動使用,不會導(dǎo)致類的初始化。
/*
只有反射初始化CL了 調(diào)用ClassLoader類的loadClass方法加載一個類,并不是對類的主動使用,不會導(dǎo)致類的初始化
class com.example.demo.com.jvm.CL
-----------------
Class cl
class com.example.demo.com.jvm.CL
*/不同的類加載器作用與動作分析
隱式加載： 程序在運(yùn)行過程中碰到通過new等方式生成對象時，隱式調(diào)用類裝載器加載對應(yīng)的類到j(luò)vm中。
顯式裝載： 通過class.forname()等方法，顯示加載需要的類。
類加載的動態(tài)體現(xiàn)
- 一個應(yīng)用程序總是由n多個類組成，Java程序啟動時，并不是一次把所有的類全部加載后再運(yùn)行，它總是先把保證程序運(yùn)行的基礎(chǔ)類一次性加載到j(luò)vm中，其它類等到j(luò)vm用到的時候再加載，這樣的好處是節(jié)省了內(nèi)存的開銷，因為java最早就是為嵌入式系統(tǒng)而設(shè)計的，內(nèi)存寶貴，這是一種可以理解的機(jī)制，而用到時再加載這也是java動態(tài)性的一種體現(xiàn)。
- public static ClassLoader getSystemClassLoader();獲取系統(tǒng)類加載器。
返回用于委派的系統(tǒng)類加載器getParent() 返回父類加載器進(jìn)行委派。
public class Test13 {
public static void main(String[] args) {
ClassLoader classLoader = ClassLoader.getSystemClassLoader();//獲取系統(tǒng)類加載
System.out.println(classLoader);
while (null != classLoader) {
classLoader = classLoader.getParent(); //獲取父加載器 因為使用根加載器時 返回值是用null來表示 所以循環(huán)結(jié)束
System.out.println(classLoader);
}
}
}/*
jdk自帶 的三個類加載器
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1eb44e46
null 并沒有繼承classLoader
*/public class Test14 {
public static void main(String[] args) throws IOException {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();//獲取當(dāng)前線程的上下文類加載器 通常是獲取那個用于啟動應(yīng)用的類加載器
String res = "com/example/demo/com/jvm.Test13.class";
Enumeration<URL> resource = classLoader.getResources(res);//獲取 類的資源
while (resource.hasMoreElements()) {
URL url = resource.nextElement();
System.out.println(url);
}
System.out.println("--------獲取類加載器的有對應(yīng)的的類-----------");
Class<Test14> test14Class = Test14.class;
System.out.println(test14Class.getClassLoader()); //sun.misc.Launcher$AppClassLoader@18b4aac2
}
}獲取類加載器的幾種方法。
獲取類加載的幾種方式
責(zé)任編輯：姜華
來源：
今日頭條
