類的加載、連接與初始化
概述
在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");
}
}
運行結果做一個好人！
Father01 static block
做一個好人！
代碼二
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
做一個好人！
分析：
- 代碼一中，我們通過子類調用父類中的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：調用構造函數
- 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>方法
類的卸載
- 當一個類被加載、連接和初始化后，它的生命周期就開始了。當代表該類的Class對象不再被引用，即不可觸及時，Class對象就會結束生命周期，這個類在方法區內的數據也會被卸載，從而結束自己的生命周期
- 一個類何時結束生命周期，取決於代表它的Class對象何時結束生命周期
- 由Java虛擬機自帶的類加載器所加載的類，在虛擬機的生命周期中，始終不會被卸載。Java虛擬機本身會始終引用這些類加載器，而這類加載器則會始終引用它們所加載的類的Class對象，因此這些Class對象始終是可觸及的；由用戶自定義的類加載器所加載的類是可以被卸載的
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※帶您來了解什麼是 USB CONNECTOR ?
※自行創業 缺乏曝光? 下一步”網站設計“幫您第一時間規劃公司的門面形象
※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!
※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化
※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益
