深入探究Java類加載機制

一、概述

Java虛擬機（JVM）是運行Java程序的重要平台。在JVM中，類的加載、連接、初始化是Java程序運行的基礎。在Java中，類是按需加載的，也就是在程序首次使用類的時候才會被加載。Java採用的是雙親委派模型的類加載機制，這個機制對於Java的生態系統是非常重要的。本文將從多個方面闡述Java類加載機制。

二、類的生命周期

在了解Java的類加載機制之前，需要了解類的生命周期：

加載：從文件系統、網絡等來源讀取二進制數據，並且創建出Class對象。
連接：包括驗證、準備和解析三個階段。
初始化：為類的靜態變量賦初值，執行<clinit>方法。
使用：類被調用。
卸載：類不再被引用，被GC回收。

三、類加載機制

1. 雙親委派模型

Java採用的是雙親委派模型的類加載機制，這個機制對Java的生態系統是非常重要的。它是從Java1.2開始加入的，嚴格來說應該叫做雙親委派委派模型。簡單來說，就是當一個類加載器接收到一個類加載請求後，它會將請求轉發給它的父類加載器，直到最頂層的啟動類加載器。

    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 首先從緩存中查找已經被加載過的類
            Class<?> c = findLoadedClass(name);
            // 如果沒有被加載，再讓父親去試一下
            if (c == null) {
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException ignored) {}
                // 如果父親都找不到，最後就由自己去加載
                if (c == null) {
                    c = findClass(name);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

2. 雙親委派的好處

藉助於雙親委派機制，Java程序可以避免類的重複加載。這種機制從根本上保證了Java程序的穩定性和安全性。例如，在使用微服務和大型框架的情況下，如果每個服務請求使用不同的類加載器，就會造成類重複加載，從而會導致內存使用量過高、版本不一致等問題。通過引入雙親委派機制，可以將類加載的責任傳遞給父類加載器，避免了類重複加載問題。

3. 破壞雙親委派模型

雖然雙親委派模型時Java的默認類加載機制，但是它並不是萬能的。有時候，我們會遇到一些特殊場景，需要打破這個機制。Java提供了兩種方式來打破雙親委派機制：

線程上下文類加載器

為了解決上述問題，Java引入了線程上下文類加載器的概念。它是從Java1.2引入的。當默認的類加載器無法滿足某個類加載請求時，可以通過線程上下文類加載器來加載。可以通過Thread.currentThread().setContextClassLoader()方法來設置線程上下文類加載器。

    public static void main(String[] args) {
        Thread.currentThread().setContextClassLoader(new MyClassLoader());
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Class<?> clazz = classLoader.loadClass("com.example.MyClass");
    }

自定義類加載器

通過自定義類加載器，可以打破雙親委派模型，從而實現更靈活的類加載機制。自定義類加載器需要繼承java.lang.ClassLoader類，並重寫其中的findClass()方法。調用自定義類加載器的代碼應該在類和類加載器分離的情況下，通過newInstance()來創建新的類對象。

    public class MyClassLoader extends ClassLoader {
        @Override
        protected Class<?> findClass(String name) {
            // 從指定的磁盤路徑加載類
            byte[] bytes = loadClassBytes(name);
            return defineClass(name, bytes, 0, bytes.length);
        }
    }

四、常見問題

1. 類被重複加載了怎麼辦？

我們可以通過JVM參數-verbose:class來查看類的加載情況。如果出現類重複加載的情況，可以使用強制主動加載的方式來防止重複加載。例如，在使用spring-boot-devtools的場景下，可以在build.gradle文件中添加以下代碼：

plugins {
    id 'org.springframework.boot' version '2.3.1.RELEASE' apply false
}
 
ext['spring-boot'] = ["org.springframework.boot:spring-boot-devtools"]
dependencies {
    runtimeOnly "${spring-boot}"
}
 
configurations {
    developmentOnly
    runtimeClasspath {
        extendsFrom developmentOnly
    }
}
 
task developmentJar(type: Jar) {
    classifier = 'development'
    from sourceSets.main.output
    appendix = "-${version}-SNAPSHOT"
}
 
artifacts {
    developmentOnly developmentJar
}
 
bootJar {
    requiresUnpack '**/spring-boot-devtools-*.jar'
}
 
task devtools(additionalResourceDirs: sourceSets.main.output.resourcesDir) {
    doLast {
        files(additionalResourceDirs).visit {
            def file = it.getFile();
            if (file.path.endsWith('.class')) {
                Class.forName(file.path.split('main\\\\classes\\\\', 2)[1].replaceAll('\\\\', '.').replaceAll('.class', ''))
            }
        }
    }
}
 
tasks.compileJava {
    finalizedBy devtools
}

2. 打破雙親委派模型會帶來什麼問題？

在某些情況下，打破雙親委派機制可能會導致類重複加載、版本不一致等問題。例如：Maven的classpath中存在多個版本的同一依賴包時，使用默認的雙親委派模型無法加載到正確版本的類，這時就可以通過線程上下文類加載器來加載。但需要注意的是，過多地使用自定義類加載器會降低Java程序的性能。

五、總結

Java的類加載機制是Java程序運行的基礎，其中雙親委派模型是其重要的機制之一。通過對雙親委派模型的理解和應用，可以保證Java程序的穩定性和安全性。當然，在必要的情況下，也可以通過線程上下文類加載器或者自定義類加載器來打破默認的類加載機制，實現更靈活的類加載方式。

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/156901.html