說說 JVM 的類加載機制『非專業』
類加載機制
類是在運行期間第一次使用時動態加載的，而不是一次性加載所有類。因為如果一次性加載，那么會占用很多的內存。
類的生命周期
包括以下 7 個階段：
- 「加載(Loading)」
- 「驗證(Verification)」
- 「準備(Preparation)」
- 「解析(Resolution)」
- 「初始化(Initialization)」
- 使用(Using)
- 卸載(Unloading)
類加載過程 --- new 一個對象的過程
包含加載、驗證、準備、解析和初始化這 5 個階段。
1.加載
加載過程完成以下三件事：
其中二進制字節流可以從以下方式中獲取：
- 從 ZIP 包讀取，成為 JAR、EAR、WAR 格式的基礎。
- 從網絡中獲取，最典型的應用是 Applet。
- 運行時計算生成，例如動態代理技術，在 java.lang.reflect.Proxy 使用 ProxyGenerator.generateProxyClass 的代理類的二進制字節流。
- 由其他文件生成，例如由 JSP 文件生成對應的 Class 類。
- 通過類的完全限定名稱獲取定義該類的二進制字節流。
- 將該字節流表示的靜態存儲結構轉換為方法區的運行時存儲結構。
- 在內存中生成一個代表該類的 Class 對象，作為方法區中該類各種數據的訪問入口。
2.驗證
格式驗證：驗證是否符合class文件規范 語義驗證：檢查一個被標記為final的類型是否包含子類;檢查一個類中的final方法是否被子類進行重寫;確保父類和子類之間沒有不兼容的一些方法聲明(比如方法簽名相同，但方法的返回值不同) 操作驗證：在操作數棧中的數據必須進行正確的操作，對常量池中的各種符號引用執行驗證(通常在解析階段執行，檢查是否可以通過符號引用中描述的全限定名定位到指定類型上，以及類成員信息的訪問修飾符是否允許訪問等)
3.準備
類變量是被 static 修飾的變量，準備階段為類變量分配內存并設置初始值，使用的是方法區的內存。
- public static int value = 123;
如果類變量是常量，那么它將初始化為表達式所定義的值而不是 0。例如下面的常量 value 被初始化為 123 而不是 0。
- public static final int value = 123;
實例變量不會在這階段分配內存，它會在對象實例化時隨著對象一起被分配在堆中。
4.解析
將常量池中的符號引用轉為直接引用(得到類或者字段、方法在內存中的指針或者偏移量，以便直接調用該方法)，這個可以在初始化之后再執行，可以支持 Java 的動態綁定。
以上2、3、4三個階段又合稱為鏈接階段，鏈接階段要做的是將加載到JVM中的二進制字節流的類數據信息合并到JVM的運行時狀態中。
5.初始化
初始化階段是虛擬機執行類構造器
虛擬機會保證一個類的
上述步驟簡單來說就是分為以下兩步：
- 類變量的賦值操作
- 執行static代碼塊。static代碼塊只有jvm能夠調用。如果是多線程需要同時初始化一個類，僅僅只能允許其中一個線程對其執行初始化操作，其余線程必須等待，只有在活動線程執行完對類的初始化操作之后，才會通知正在等待的其他線程。
最終，方法區會存儲當前類的類信息，包括類的靜態變量、類初始化代碼(定義靜態變量時的賦值語句和靜態初始化代碼塊)、實例變量定義、實例初始化代碼(定義實例變量時的賦值語句實例代碼塊和構造方法)和實例方法，還有父類的類信息引用。
創建對象
假設是第一次使用一個類的話，那么需要經過上述的類加載的過程，之后才是創建對象。
「1、在堆區分配對象需要的內存」
分配的內存包括本類和父類的所有實例變量，但不包括任何靜態變量
「2、對所有實例變量賦默認值」
將方法區內對實例變量的定義拷貝一份到堆區，然后賦默認值
「3、執行實例初始化代碼」
初始化順序是先初始化父類再初始化子類，初始化時先執行實例代碼塊然后是構造方法。(第一執行類中的靜態代碼，包括靜態成 員變量的初始化和靜態語句塊的執行;第二執行類中的非靜態代碼，包括非靜態成員變量的初始化和非靜態語句塊的執行，最后執 行構造函數。在繼承的情況下，會首先執行父類的靜態代碼，然后執行子類的靜態代碼;之后執行父類的非靜態代碼和構造函數; 最后執行子類的非靜態代碼和構造函數)
「4、如果有類似于Child c = new Child()形式的c引用的話，在棧區定義Child類型引用變量c，然后將堆區對象的地址賦值給它」
需要注意的是，「每個子類對象持有父類對象的引用」，可在內部通過super關鍵字來調用父類對象，但在外部不可訪問。
存在繼承的情況下，初始化順序為：
- 父類(靜態變量、靜態語句塊)
- 子類(靜態變量、靜態語句塊)
- 父類(實例變量、普通語句塊)
- 父類(構造函數)
- 子類(實例變量、普通語句塊)
- 子類(構造函數)
類初始化的情況
主動引用
虛擬機規范中并沒有強制約束何時進行加載，但是規范嚴格規定了有且只有下列五種情況必須對類進行初始化(加載、驗證、準備都會隨之發生)：
- 遇到 new、getstatic、putstatic、invokestatic 這四條字節碼指令時，如果類沒有進行過初始化，則必須先觸發其初始化。最常見的生成這 4 條指令的場景是：使用 new 關鍵字實例化對象的時候;讀取或設置一個類的靜態字段(被 final 修飾、已在編譯期把結果放入常量池的靜態字段除外)的時候;以及調用一個類的靜態方法的時候。
- 使用 java.lang.reflect 包的方法對類進行反射調用的時候，如果類沒有進行初始化，則需要先觸發其初始化。
- 當初始化一個類的時候，如果發現其父類還沒有進行過初始化，則需要先觸發其父類的初始化。
- 當虛擬機啟動時，用戶需要指定一個要執行的主類(包含 main() 方法的那個類)，虛擬機會先初始化這個主類。
被動引用
以上的行為稱為對一個類進行主動引用。除此之外，所有引用類的方式都不會觸發初始化，稱為被動引用。被動引用的常見例子包括：
- 通過子類引用父類的靜態字段，不會導致子類初始化。
- System.out.println(SubClass.value); // value 字段在 SuperClass 中定義
通過數組定義來引用類，不會觸發此類的初始化。該過程會對數組類進行初始化，數組類是一個由虛擬機自動生成的、直接繼承自 Object 的子類，其中包含了數組的屬性和方法。
- SuperClass[] sca = new SuperClass[10];
- 常量在編譯階段會存入調用類的常量池中，本質上并沒有直接引用到定義常量的類，因此不會觸發定義常量的類的初始化。
- System.out.println(ConstClass.HELLOWORLD);
類與類加載器
兩個類相等，需要類本身相等，并且使用同一個類加載器進行加載。這是因為每一個類加載器都擁有一個獨立的類名稱空間。那么最終的相等包括了類的 Class 對象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回結果為 true，也包括使用 instanceof 關鍵字做對象所屬關系判定結果為 true。
從 Java 虛擬機的角度來講，只存在以下兩種不同的類加載器：
- 啟動類加載器(Bootstrap ClassLoader)，使用 C++ 實現，是虛擬機自身的一部分;
- 所有其它類的加載器，使用 Java 實現，獨立于虛擬機，繼承自抽象類 java.lang.ClassLoader。
那么上述又可以分為以下三種類加載器：BootstrapClassLoader、ExtensionClassLoader、App ClassLoader
- 啟動類加載器(BootstrapClassLoader)是嵌在JVM內核中的加載器，該加載器是用C++語言寫的，主要負載加載JAVA_HOME/lib下的類庫，或者被 -Xbootclasspath 參數所指定的路徑中的，并且是虛擬機識別的(僅按照文件名識別，如 rt.jar，名字不符合的類庫即使放在 lib 目錄中也不會被加載)。
啟動類加載器無法被 Java 程序直接引用，用戶在編寫自定義類加載器時，如果需要把加載請求委派給啟動類加載器，直接使用 null 代替即可。
- 擴展類加載器(ExtensionClassLoader)是用JAVA編寫，由 ExtClassLoader(sun.misc.Launcher$ExtClassLoader)實現的。它負責將
/lib/ext 或者被 java.ext.dir 系統變量所指定路徑中的所有類庫加載到內存中，開發者可以直接使用擴展類加載器。
它的父類加載器是Bootstrap。
- 應用程序類加載器(Application ClassLoader)這個類加載器是由 AppClassLoader(sun.misc.Launcher$AppClassLoader)實現的。一般負責加載應用程序classpath目錄下的所有jar和class文件。
開發者可以直接使用這個類加載器，如果應用程序中沒有自定義過自己的類加載器，一般情況下這個就是程序中默認的類加載器。
它的父加載器為ExteClassLoader。
雙親委派模型
應用程序是由三種類加載器互相配合從而實現類加載，除此之外還可以加入自己定義的類加載器。下圖展示了類加載器之間的層次關系，稱為雙親委派模型(Parents Delegation Model)。這里的父子關系一般通過委托來實現，而不是繼承關系(Inheritance)。
- 工作流程
如果一個類加載器收到了一個類加載請求，它不會自己去嘗試加載這個類，而是把這個請求轉交給父類加載器去完成。每一個層次的類加載器都是如此。因此所有的類加載請求都應該傳遞到最頂層的啟動類加載器中，只有到父類加載器反饋自己無法完成這個加載請求(在它的搜索范圍沒有找到這個類)時，子類加載器才會嘗試自己去加載。
- 好處
使得 Java 類隨著它的類加載器一起具有一種帶有優先級的層次關系，從而使得基礎類得到統一。
例如 java.lang.Object 存放在 rt.jar 中，如果編寫另外一個 java.lang.Object 并放到 ClassPath 中，程序可以編譯通過。由于雙親委派模型的存在，所以在 rt.jar 中的 Object 比在 ClassPath 中的 Object 優先級更高，這是因為 rt.jar 中的 Object 使用的是啟動類加載器，而 ClassPath 中的 Object 使用的是應用程序類加載器。rt.jar 中的 Object 優先級更高，那么程序中所有的 Object 都是這個 Object。
- demo
以下是抽象類 java.lang.ClassLoader 的代碼片段，其中的 loadClass() 方法運行過程如下：先檢查類是否已經加載過，如果沒有則讓父類加載器去加載。當父類加載器加載失敗時拋出 ClassNotFoundException，此時嘗試自己去加載。
- public abstract class ClassLoader {
- // The parent class loader for delegation
- private final ClassLoader parent;
- public Class<?> loadClass(String name) throws ClassNotFoundException {
- return loadClass(name, false);
- }
- protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
- synchronized (getClassLoadingLock(name)) {
- // First, check if the class has already been loaded
- Class<?> c = findLoadedClass(name);
- if (c == null) {
- try {
- if (parent != null) {
- c = parent.loadClass(name, false);
- } else {
- c = findBootstrapClassOrNull(name);
- }
- } catch (ClassNotFoundException e) {
- // ClassNotFoundException thrown if class not found
- // from the non-null parent class loader
- }
- if (c == null) {
- // If still not found, then invoke findClass in order
- // to find the class.
- c = findClass(name);
- }
- }
- if (resolve) {
- resolveClass(c);
- }
- return c;
- }
- }
- protected Class<?> findClass(String name) throws ClassNotFoundException {
- throw new ClassNotFoundException(name);
- }
- }
- 自定義類加載器實現
以下代碼中的 FileSystemClassLoader 是自定義類加載器，繼承自 java.lang.ClassLoader，用于加載文件系統上的類。它首先根據類的全名在文件系統上查找類的字節代碼文件(.class 文件)，然后讀取該文件內容，最后通過 defineClass() 方法來把這些字節代碼轉換成 java.lang.Class 類的實例。
java.lang.ClassLoader 的 loadClass() 實現了雙親委派模型的邏輯，自定義類加載器一般不去重寫它，但是需要重寫 findClass() 方法。
- public class FileSystemClassLoader extends ClassLoader {
- private String rootDir;
- public FileSystemClassLoader(String rootDir) {
- this.rootDir = rootDir;
- }
- protected Class<?> findClass(String name) throws ClassNotFoundException {
- byte[] classData = getClassData(name);
- if (classData == null) {
- throw new ClassNotFoundException();
- } else {
- return defineClass(name, classData, 0, classData.length);
- }
- }
- private byte[] getClassData(String className) {
- String path = classNameToPath(className);
- try {
- InputStream ins = new FileInputStream(path);
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- int bufferSize = 4096;
- byte[] buffer = new byte[bufferSize];
- int bytesNumRead;
- while ((bytesNumRead = ins.read(buffer)) != -1) {
- baos.write(buffer, 0, bytesNumRead);
- }
- return baos.toByteArray();
- } catch (IOException e) {
- e.printStackTrace();
- }
- return null;
- }
- private String classNameToPath(String className) {
- return rootDir + File.separatorChar
- + className.replace('.', File.separatorChar) + ".class";
- }
- }
巨人的肩膀
程序鍋春招筆記的摘記
https://github.com/CyC2018/CS-Notes
本文轉載自微信公眾號「多選參數」，可以通過以下二維碼關注。轉載本文請聯系多選參數公眾號。
