類加載器 - 類的加載、鏈接與初始化

時間  2019-11-21
標籤 加載 鏈接 初始化 简体版
原文   原文鏈接

類的加載、鏈接與初始化

概述

在Java代碼中，類型的加載、鏈接與初始化過程都是在程序運行期間完成的java

  • 類型：能夠理解爲一個class
  • 加載：查找並加載類的二進制數據，最多見的狀況是將已經編譯完成的類的class文件從磁盤加載到內存中
  • 鏈接：肯定類型與類型之間的關係，對於字節碼的相關處理
    • 驗證：確保被加載的類的正確性
    • 準備：爲類的靜態變量分配內存，並將其初始化爲默認值。可是在到達初始化以前，類變量都沒有初始化爲真正的初始值
    • 解析：在類型的常量池中尋找類、接口、字段和方法的符號引用，把這些符號引用轉換爲直接引用的過程
  • 初始化：爲類的靜態變量賦予正確的初始值
  • 使用：好比建立對象，調用類的方法等
  • 卸載：類從內存中銷燬

理解：public static int number = 666;程序員

上面這段代碼，在類加載的鏈接階段，爲對象number分配內存，並初始化爲0；而後再初始化階段在賦予正確的初始值：666數據庫

類的使用方式

Java程序對類的使用方式可分爲兩種數組

  • 主動使用
    • 建立類的實例
    • 訪問某個類或接口的靜態變量，或者對靜態變量賦值
    • 調用類的靜態方法
    • 反射
    • 初始化類的子類
    • Java虛擬機啓動時被標明爲啓動類的類（包含main方法）
    • JDK1.7開始提供的動態語言支持（java.lang.invoke.MethodHandle實例的解析結果REF_getStatic，REF_putStatic，REF_invokeStatic句柄對應的類沒有初始化，則初始化）
  • 被動使用
    • 除了主動使用的七種狀況以外，其餘使用Java類的方法都被看做是對類的被動使用，都不會致使類的初始化

全部的Java虛擬機實現必須在每一個類或接口被Java程序「首次主動使用」時才初始化他們網絡

代碼理解

示例一：類的加載鏈接和初始化過程

代碼一數據結構

public class Test01 {
    public static void main(String[] args) {
        System.out.println(Child01.str);
    }
}

class Father01 {
    public static String str = "作一個好人！";
    static {
        System.out.println("Father01 static block");
    }
}

class Child01 extends Father01 {
    static {
        System.out.println("Child01 static block");
    }
}

運行結果作一個好人！dom

Father01 static block
作一個好人！

代碼二jvm

public class Test01 {
    public static void main(String[] args) {
        System.out.println(Child01.str2);
    }
}

class Father01 {
    public static String str = "作一個好人！";

    static {
        System.out.println("Father01 static block");
    }
}

class Child01 extends Father01 {
    public static String str2 = "作一個好人！";
    static {
        System.out.println("Child01 static block");
    }
}

運行結果函數

Father01 static block
Child01 static block
作一個好人！

分析：spa

  • 代碼一中，咱們經過子類調用父類中的str，這個str是在父類被定義的，對Father01主動使用，沒有主動使用Child01，故Child01的靜態代碼塊沒有執行，父類的靜態代碼塊被執行了。 -> 對於靜態字段來講，只有直接定義了該字段的類纔會被初始化。
  • 代碼二中，對Child01主動使用；根據主動使用的7種狀況，調動類的子類時，其全部的父類都會被先初始化，因此Father01會被初始化。 -> 當一個類初始化時，要求其父類所有都已經初始化完畢了。

以上驗證的是類的初始化狀況，那麼如何驗證類的加載狀況呢，能夠經過在啓動的時候配置虛擬機參數：-XX:+TraceClassLoading查看

運行代碼一，查看輸出結果，能夠看見控制檯打印了very多的日誌，第一個加載的是java.lang.Object類（無論加載哪一個類，他的父類必定是Object類），後面是加載的一系列jdk的類，他們都位於rt包下。往下查看，能夠看見Loaded classloader.Child01，說明即便沒有初始化Child01，可是程序依然加載了Child01類。

[Opened /usr/local/jdk1.8/jre/lib/rt.jar]
[Loaded java.lang.Object from /usr/local/jdk1.8/jre/lib/rt.jar]
...
[Loaded java.lang.Void from /usr/local/jdk1.8/jre/lib/rt.jar]
[Loaded classloader.Father01 from file:/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/]
[Loaded classloader.Child01 from file:/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/]
Father01 static block
作一個好人！
[Loaded java.lang.Shutdown from /usr/local/jdk1.8/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /usr/local/jdk1.8/jre/lib/rt.jar]

拓展：JVM參數介紹

由於前一章節使用了JVM參數，因此對其作一下簡單的介紹

  • 全部的JVM參數都是以-XX:開頭的
  • 若是形式是：-XX:+<option>，表示開啓option選項
  • 若是形式是：-XX:-<option>，表示關閉option選項
  • 若是形式是：-XX:<option>=<value>，表示將option選項的值設置爲value

示例二：常量的本質含義

public class Test02 {
    public static void main(String[] args) {
        System.out.println(Father02.str);
    }
}

class Father02{
    public static final String str = "作一個好人！";

    static {
        System.out.println("Father02 static block");
    }
}

執行結果

作一個好人！

分析

能夠看見，此段代碼並無初始化Father02類。這是由於final表示的是一個常量，在編譯階段常量就會被存入到調用這個常量的方法所在的類的常量池當中，本質上，調用類並無直接引用到定義常量的類，所以並不會觸發定義常量的類的初始化。在本代碼中，常量str會被存入到Test02的常量池中，以後Test02與Father02沒有任何關係，甚至能夠刪除Father02的class文件。

咱們反編譯一下Test02類

Compiled from "Test02.java"
public class classloader.Test02 {
  public classloader.Test02();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #4                  // String 作一個好人！
       5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

第一塊是Test02類的構造方法，第二塊是咱們要看的main方法。能夠看見3: ldc #4 // String 作一個好人！，此時這個值已是肯定無疑的作一個好人！了，而不是Father02.str，證明了上面說的在編譯階段常量就會被存入到調用這個常量的方法所在的類的常量池當中。

拓展：助記符

因前一章節涉及到了助記符，因此介紹下本章節涉及到的助記符及擴展

  • ldc：表示將int、float或String類型的常量值常量池中推送至棧頂
  • bipush：表示將單字節（-128 -至 127）的常量推送至棧頂
  • sipush：表示將一個短整形（-32768 至 32767）的常量推送至棧頂
  • iconst_1：表示將int類型的1推送至棧頂（這類助記符只有iconst_m1 - iconst_5七個）

示例三：編譯期常量與運行期常量的區別

public class Test03 {
    public static void main(String[] args) {
        System.out.println(Father03.str);
    }
}

class Father03 {
    public static final String str = UUID.randomUUID().toString();

    static {
        System.out.println("Father03 static block");
    }
}

運行結果

Father03 static block
a60c5db4-2673-4ffc-a9f0-2dbe53fae583

分析

本代碼與示例二的區別在於str的值是在運行時確認的，而不是編譯時就肯定好的，屬於運行期常量，而不是編譯期常量。當一個常量的值並不是編譯期間肯定的，那麼其值就不會被放到調用類的常量池中，這時在程序運行時，會致使主動使用這個常量所在的類，致使這個類被初始化。

示例四：數組建立本質

代碼一

public class Test04 {
    public static void main(String[] args) {
         Father04 father04_1 = new Father04();
        System.out.println("-----------");
        Father04 father04_2 = new Father04();
    }
}

class Father04 {
    static {
        System.out.println("Father04 static block");
    }
}

運行結果

Father04 static block
-----------

分析

  • 建立類的實例時，會初始化類
  • 全部的Java虛擬機實現必須在每一個類或接口被Java程序「首次主動使用」時才初始化他們

代碼二

public class Test04 {
    public static void main(String[] args) {
        Father04[] father04s = new Father04[1];
        System.out.println(father04s.getClass());
    }
}

運行結果

class [Lclassloader.Father04;

分析

  • 建立數組對象再也不主動使用的7種狀況內，屬於被動使用，故不會初始化Father04
  • 打印father04s的類型爲[Lclassloader.Father04，這是虛擬機在運行期生成的。 -> 對於數組示例來講，其類型是有JVM在運行期動態生成的，表示爲[Lclassloader.Father04這種形式，動態生成的類型，其父類就是Object。
  • 對於數組來講，JavaDoc常常將構成數組的元素爲Component，實際上就是將數組下降一個維度後的類型

反編譯一下：

public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: anewarray     #2                  // class classloader/Father04
       4: astore_1
       5: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       8: aload_1
       9: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      12: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      15: return
  • anewarray：表示建立一個引用類型（如類、接口、數組）的數組，並將其引用值值壓入棧頂
  • newarray：表示建立一個指定的原始類型（如int、float、char等）的數組，並將其引用值壓入棧頂

示例五：接口的加載與初始化

代碼一

public class Test05 {
    public static void main(String[] args) {
        System.out.println(Child05.j);
    }
}

interface Father05 {
    int i = 5;
}

interface Child05 extends Father05 {
    int j = 6;
}

運行結果

6

分析

  • 接口中定義的常量自己就是public、static、final的
  • 結果顯而易見，這時咱們刪除掉Father05.class文件和Child05.class文件，程序依然能夠正常運行
    • 接口中的常量自己就是final常量，會被加載到Test05的常量池中
    • 此時，Father05和Child05都不會被加載

代碼二

public class Test05 {
    public static void main(String[] args) {
        System.out.println(Child05.j);
    }
}

interface Father05 {
    int i = 5;
}

interface Child05 extends Father05 {
    int j = new Random().nextInt(8);
}

運行結果

6

將Father05.class文件刪除，運行結果

Exception in thread "main" java.lang.NoClassDefFoundError: classloader/Father05
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
    at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:338)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    at classloader.Test05.main(Test05.java:15)
Caused by: java.lang.ClassNotFoundException: classloader.Father05
    at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:338)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    ... 13 more

分析

  • 只有在真正使用到父接口的時候（如引用接口中所定義的常量時），纔會加載初始化

代碼三

public class Test05 {
    public static void main(String[] args) {
        System.out.println(Child05.j);
    }
}

interface Father05 {
    Thread thread = new Thread() {
        {
            System.out.println("Father05 code block");
        }
    };
}

class Child05 implements Father05 {
    public static int j = 8;
}

運行結果

8

分析

  • 在初始化一個類時，並不會先初始化他所實現的接口

代碼四

public class Test05 {
    public static void main(String[] args) {
        System.out.println(Father05.thread);
    }
}

interface GrandFather {
    Thread thread = new Thread() {
        {
            System.out.println("GrandFather code block");
        }
    };
}

interface Father05 extends GrandFather{
    Thread thread = new Thread() {
        {
            System.out.println("Father05 code block");
        }
    };
}

運行結果

Father05 code block
Thread[Thread-0,5,main]

分析

  • 在初始化一個接口時，並不會先初始化他的父接口

示例六：類加載器準備階段和初始化階段

代碼一

public class Test06 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();

        System.out.println("i:" + Singleton.i);
        System.out.println("j:" + Singleton.j);
    }
}

class Singleton {
    public static int i;

    public static int j = 0;

    private static Singleton singleton = new Singleton();

    private Singleton() {
        i ++;
        j ++;
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

運行結果

i:1
j:1

分析

首先Singleton.getInstance();進入Singleton的getInstance方法，getInstance會返回Singleton的實例，Singleton的實例是new Singleton();出來的，所以調用了自定義的私有構造方法。在調用構造方法以前，給靜態變量賦值，i默認賦值爲0，j顯式的賦值爲0，通過構造函數以後，值都爲1。

代碼二

public class Test06 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();

        System.out.println("i:" + Singleton.i);
        System.out.println("j:" + Singleton.j);
    }
}

class Singleton {
    public static int i;

    private static Singleton singleton = new Singleton();

    private Singleton() {
        i ++;
        j ++;
    }

    public static int j = 0;

    public static Singleton getInstance() {
        return singleton;
    }
}

運行結果

i:1
j:0

分析

程序主動使用了Singleton類，準備階段對類的靜態變量分配內存，賦予默認值，下面給出類在鏈接及初始化階段常量的值的變化

  • i ： 0
  • singleton：null
  • j ： 0
  • getInstance：初始化
    • i：0
    • singleton：調用構造函數
      • i：1
      • j：1
    • j：0【覆蓋了以前的1】

故返回的值i爲1，j爲0

深刻解析類的加載、鏈接與初始化

類的加載

  • 將類的.class文件中的二進制數據讀入到內存中，將其放在運行時數據區的方法區內，而後再內存中建立一個java.lang.Class對象（規範並未說明Class對象位於哪裏，HotSpot虛擬機將其放在了方法區中）用來封裝類在方法區的數據結構
  • 加載.class文件的方式
    • 從本地系統直接加載
    • 經過網絡下載.class文件
    • 從zip等歸檔文件中加載.class文件
    • 從專有數據庫中提取.class文件
    • 將Java源代碼動態編譯爲.class文件
  • 類的加載的最終產品是位於內存中的Class對象
  • Calss對象封裝了類在方法區內的數據結構，而且向Java程序員提供了訪問方法區內的數據結構的接口
  • 有兩種類型的類加載器
    • Java虛擬機自帶的類加載器
      • 根類加載器（Bootstrap）：該加載器沒有父加載器。他負責加載虛擬機的核心類庫，如java.lang.*等。根類加載器從系統屬性sun.boot.class.path所指定的目錄中加載類庫。根類加載器的實現依賴於底層操做系統，呀沒有繼承java.lang.CalssLoader類
      • 擴展類加載器（Extension）：父加載器爲根加載器。從java.ext.dirs系統屬性所指定的目錄中加載類庫，或者從JDK的安裝目錄的jre\lib\ext子目錄（擴展目錄）下加載類庫，若是用戶建立的JAR文件放在這個目錄下，也會自動由擴展類加載器加載。擴展類加載器是純Java類，是java.lang.ClassLoader類的子類
      • 系統（應用）類加載器（System）：父加載器爲擴展加載器。從環境變量classpath或者系統屬性java.class.path所指定的目錄中加載類，是用戶自定義類加載器的默認父加載器。系統類加載器是純Java類，是java.lang.ClassLoader類的子類
    • 用戶自定義的類加載器
      • java.lang.ClassLoader的子類
      • 用戶能夠定製類的加載方式
  • 類加載器並不須要等到某個類被「首次使用」時再加載他
  • JVM規範容許類加載器在預料某個類將要被使用時就預先加載他，若是在預先加載的過程當中遇到了.class文件缺失或存在錯誤，類加載器必須在程序首次主動使用時才報告錯誤（LinkageError錯誤）。若是這個類一直沒有被程序主動使用，那麼類加載器就不會報告錯誤

類的鏈接

類被加載後，就進入鏈接階段。鏈接就是將已經讀入到內存中的類的二進制數據合併到虛擬機的運行時環境中去

類的驗證

類的驗證的內容

  • 類文件的結構檢查
  • 語義檢查
  • 字節碼驗證
  • 二進制兼容性驗證

類的準備

在準備階段，Java虛擬機爲類的靜態變量分配內存，並設置默認的初始值。例如對於下面的Sample類，在準備階段，將爲int類型的靜態變量i分配4個字節的內存空間，而且賦默認值0；爲long類型的靜態變量j分配8個字節的內存空間，並賦予默認值0

public class Sample {
    private static int i = 8;
    private static long j = 8L;
    ......
}

類的初始化

在初始化階段，Java虛擬機執行類的初始化語句，爲類的靜態變量賦予初始值。在程序中，靜態變量的初始化有兩種途徑：

  • 在靜態變量的聲明處初始化
  • 在靜態代碼塊中初始化

靜態變量的聲明語句，預計靜態代碼塊都被看做類的初始化語句，Java虛擬機會按照初始化語句在類文件中的前後順序來依次執行他們

類的初始化步驟

  • 假如這個類尚未被加載和鏈接誒，須要先進行加載和鏈接
  • 假如類存在直接父類，而且這個父類尚未被初始化，須要先初始化直接父類
  • 假如類中存在初始化語句，須要依次執行這些初始化語句

類的初始化時機

  • 當Java虛擬機初始化一個類時，要求他的全部父類都已經被初始化，可是這條規則並不適用於接口

    • 在初始化一個類時，並不會先初始化他所實現的接口
    • 在初始化一個接口時，並不會先初始化他的父接口

    所以，一個父接口並不會由於他的子接口或實現類的初始化而初始化，只有當程序首次使用特定接口的靜態變量時，纔會致使該接口的初始化。代碼參照代碼理解-接口的初始化

  • 只有當程序訪問的靜態變量或者靜態方法確實在當前類或者當前接口中定義時，才認爲是對類或接口的主動使用

  • 調用ClassLoader類的loadClass方法加載一個類，並非對類的主動使用，不會致使類的初始化

拓展：類實例化

類的生命週期除了前文提到的加載、鏈接、初始化以外，還有類示例化，垃圾回收和對象終結

  • 爲新的對象分配內存
  • 爲實例變量賦予默認值
  • 爲實例變量賦予正確的初始值
  • Java編譯器爲它編譯的每個類都至少生成一個實例初始化方法，在Java的class文件中，這個實例初始化方法被稱爲<init>。針對源代碼中每個類的構造方法，Java編譯器都產生一個<init>方法
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程