Java類加載器ClassLoader源碼層面分析講解

更新時間：2022年09月28日 09:49:18 作者：Echoo2787

ClassLoader翻譯過來就是類加載器，普通的java開發(fā)者其實用到的不多，但對于某些框架開發(fā)者來說卻非常常見。理解ClassLoader的加載機制，也有利于我們編寫出更高效的代碼。ClassLoader的具體作用就是將class文件加載到j(luò)vm虛擬機中去，程序就可以正確運行了

Launcher 源碼

sun.misc.Launcher類是java 虛擬機的入口，在啟動 java應(yīng)用的時候會首先創(chuàng)建Launcher。在初始化Launcher對象的時候會創(chuàng)建一個ExtClassLoader拓展程序加載器和 AppClassLoader應(yīng)用程序類加載器(這倆鬼東西好像只是加載類的路徑不一樣而已)，然后由這倆類加載器去加載應(yīng)用程序中需要的各種類。

public class Launcher {
	// 成員 ClassLoader 類加載器，用來存儲 應(yīng)用程序類加載器，
	// 此加載器與線程綁定，用作線程的上下文類加載器。
	private ClassLoader loader;  
	// 兩個靜態(tài)內(nèi)部類
	static class AppClassLoader extends URLClassLoader {...}
	static class ExtClassLoader extends URLClassLoader {...}
	    // 構(gòu)造器
	    public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }
        try {
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }
        Thread.currentThread().setContextClassLoader(this.loader);
        String var2 = System.getProperty("java.security.manager");
        if (var2 != null) {
            SecurityManager var3 = null;
            if (!"".equals(var2) && !"default".equals(var2)) {
                try {
                    var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
                } catch (IllegalAccessException var5) {
                } catch (InstantiationException var6) {
                } catch (ClassNotFoundException var7) {
                } catch (ClassCastException var8) {
                }
            } else {
                var3 = new SecurityManager();
            }
            if (var3 == null) {
                throw new InternalError("Could not create SecurityManager: " + var2);
            }
            System.setSecurityManager(var3);
        }
    }
}

AppClassLoader 源碼

AppletClassLoader 就是我們

AppletClassLoader 繼承 URLClassLoader 繼承 SecureClassLoader 繼承 ClassLoader

 static class AppClassLoader extends URLClassLoader { 
        public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
            // ...
            // 調(diào)用了一個 native 本地方法 knownToNotExist()，去查找該類的加載記錄
            if (this.ucp.knownToNotExist(var1)) {        // 如果有該類加載記錄
                Class var5 = this.findLoadedClass(var1); // 直接去已經(jīng)加載的類中找
                if (var5 != null) {
                    if (var2) {
                        this.resolveClass(var5);
                    }
                    return var5;
                } else {                                 // 如果沒找到報異常
                    throw new ClassNotFoundException(var1);
                }
            } else {                                     // 如果沒有該類的加載記錄
                return super.loadClass(var1, var2);      // 調(diào)用父類 ClassLoader 的 loadClass()
            }
        }
}

ExtClassLoader 源碼

ExtClassLoader 并沒有對 loadClass() 方法進行重寫，也就是說它直接調(diào)用其父類 ClassLoader 的 loadClass() 方法。

static class ExtClassLoader extends URLClassLoader {
	//...
}

ClassLoader 源碼

 /** 允許直接調(diào)用的是這個根據(jù) 類名加載類 的方法， */
 public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false); // 內(nèi)部調(diào)用的是類加載方法默認不對類進行解析
    }

 	protected Class<?> loadClass(String name, boolean resolve)  throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) { // 加載一個類的時候，鎖住對應(yīng)的類加載器對象
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);    // 查詢已加載的類中是否有該類存在 
            if (c == null) {
                long t0 = System.nanoTime();       // 記錄開始時間
                try {
                    if (parent != null) {          // 非頂層類加載器
                        c = parent.loadClass(name, false);  // 調(diào)用父類加載器進行加載
                    } else {
                        c = findBootstrapClassOrNull(name); // 調(diào)用啟動類加載器加載
                    }
                } 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.
                    long t1 = System.nanoTime();  // 記錄結(jié)束時間
                    c = findClass(name);          // 再由當(dāng)前加載器加載
                    // this is the defining class loader; record the stats
                    // 性能計數(shù)器
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c); // 對類進行解析
            }
            return c;
        }
    }

這個尋找類的方法一般需要實現(xiàn)類重寫，否則默認直接拋出 ClassNotFoundException

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }

ClassLoader 維護的線程安全的映射集合，用來存儲 類加載器對象和它的鎖

    // Maps class name to the corresponding lock object when the current
    // class loader is parallel capable.
    // Note: VM also uses this field to decide if the current class loader
    // is parallel capable and the appropriate lock object for class loading.
    private final ConcurrentHashMap<String, Object> parallelLockMap;

根據(jù)類名獲取對應(yīng)的鎖（其實就是對應(yīng)的類加載對象本身）

    protected Object getClassLoadingLock(String className) {
        Object lock = this; // 這個鎖就是類加載器對象本身！
        if (parallelLockMap != null) {
            Object newLock = new Object(); 
            lock = parallelLockMap.putIfAbsent(className, newLock); // 放入集合里存儲
            if (lock == null) { // 如果沒有對應(yīng)的類加載器對象
                lock = newLock; // 創(chuàng)建一個新的類加載器
            }
        }
        return lock; // 返回類加載器對象
    }

findBootstrapClass()是底層系統(tǒng)的本地方法

	 /**
     * Returns a class loaded by the bootstrap class loader;
     * or return null if not found.
     */
    private Class<?> findBootstrapClassOrNull(String name)
    {
        if (!checkName(name)) return null;
        return findBootstrapClass(name);
    }
    // 返回 BootstrapClassLoader 啟動類加載器加載的類。
    private native Class<?> findBootstrapClass(String name);

總結(jié)

首先雙親委派個人認為應(yīng)該是個翻譯錯誤。這個翻譯非常容易誤導(dǎo)人啊！我一拳就過去！

雙親在漢語里是指父母的意思，雙親委派直接理解就是一個類加載器對象去加載類的時候是委派它的父類和母類去加載的（他的父類母類都是加載器，不然怎么生出個它這么懶的加載器）。而且這里的委派改成委托更為合理。

但是根據(jù)源碼里的邏輯，并不是這樣的（坑爹啊）：

一個類加載器要加載類（無論是 AppClassLoader 還是 ExtClassLoader，還是自定義的類加載器），因為他們統(tǒng)統(tǒng)都是 ClassLoader 的子類對象（繼承者），最終都是委托最頂層的那個 ClassLoader (老太公) 去加載那個需要的類。
此時壓力來到了 ClassLoader (老太公)這里，它要干活啊，去加載類然后拿給它的不肖子孫們啊。但是它也懶，于是它就去委托它的盆友，別人家的老太公幫他加載。這個別人家的老太公就是 BootStrapClassLoader （啟動類加載器）。