【JVM】淺談雙親委派和破壞雙親委派

一、前言

筆者曾經閱讀過周志明的《深入理解Java虛擬機》這本書，閱讀完后自以為對jvm有了一定的了解，然而當真正碰到問題的時候，才發現自己讀的有多粗糙，也體會到只有實踐才能加深理解，正應對了那句話——“Talk is cheap, show me the code”，前段時間，筆者同事提出了一個關于類加載器破壞雙親委派的問題，以我們常見到的資料庫驅動Driver為例，為什么要實作破壞雙親委派，下面一起來重溫一下，

二、雙親委派

想要知道為什么要破壞雙親委派，就要先從什么是雙親委派說起，在此之前，我們先要了解一些概念：

?對于任意一個類，都需要由加載它的類加載器和這個類本身來一同確立其在Java虛擬機中的唯一性，

什么意思呢？我們知道，判斷一個類是否相同，通常用equals()方法，isInstance()方法和isAssignableFrom()方法，來判斷，對于同一個類，如果沒有采用相同的類加載器來加載，在呼叫的時候，會產生意想不到的結果：

public class DifferentClassLoaderTest {

    public static void main(String[] args) throws Exception {
        ClassLoader classLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                InputStream stream = getClass().getResourceAsStream(fileName);
                if (stream == null) {
                    return super.loadClass(name);
                }
                try {
                    byte[] b = new byte[stream.available()];
                    // 將流寫入位元組陣列b中
                    stream.read(b);
                    return defineClass(name, b, 0, b.length);
                } catch (IOException e) {
                    e.printStackTrace();
                }

                return super.loadClass(name);
            }
        };
        Object obj = classLoader.loadClass("jvm.DifferentClassLoaderTest").newInstance();
        System.out.println(obj.getClass());
        System.out.println(obj instanceof DifferentClassLoaderTest);

    }
}//需要獲取資料的朋友請加Q君樣：290194256*

輸出結果：

class jvm.DifferentClassLoaderTest
false

如果在通過classLoader實體化的使用，直接轉化成DifferentClassLoaderTest物件:

DifferentClassLoaderTest obj = (DifferentClassLoaderTest) classLoader.loadClass("jvm.DifferentClassLoaderTest").newInstance();

就會直接報 `java.lang.ClassCastException: ，因為兩者不屬于同一類加載器加載，所以不能轉化！

2.1、為什么需要雙親委派

基于上述的問題：如果不是同一個類加載器加載，即時是相同的class檔案，也會出現判斷不想同的情況，從而引發一些意想不到的情況，為了保證相同的class檔案，在使用的時候，是相同的物件，jvm設計的時候，采用了雙親委派的方式來加載類，

雙親委派：如果一個類加載器收到了加載某個類的請求,則該類加載器并不會去加載該類,而是把這個請求委派給父類加載器,每一個層次的類加載器都是如此,因此所有的類加載請求最終都會傳送到頂端的啟動類加載器;只有當父類加載器在其搜索范圍內無法找到所需的類,并將該結果反饋給子類加載器,子類加載器會嘗試去自己加載，

這里有幾個流程要注意一下：

1.子類先委托父類加載
2.父類加載器有自己的加載范圍，范圍內沒有找到，則不加載，并回傳給子類
3.子類在收到父類無法加載的時候，才會自己去加載

jvm提供了三種系統加載器：

1.啟動類加載器（Bootstrap ClassLoader）：C++實作，在java里無法獲取，負責加載<JAVA_HOME>/lib下的類，
2.擴展類加載器（Extension ClassLoader）： Java實作，可以在java里獲取，負責加載<JAVA_HOME>/lib/ext下的類，
3.系統類加載器/應用程式類加載器（Application ClassLoader）：是與我們接觸對多的類加載器，我們寫的代碼默認就是由它來加載，ClassLoader.getSystemClassLoader回傳的就是它，

附上三者的關系：

2.2、雙親委派的實作

雙親委派的實作其實并不復雜，其實就是一個遞回，我們一起來看一下 ClassLoader 里的代碼：

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
    {
    	// 同步上鎖
        synchronized (getClassLoadingLock(name)) {
            // 先查看這個類是不是已經加載過
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                	// 遞回，雙親委派的實作，先獲取父類加載器，不為空則交給父類加載器
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    // 前面提到，bootstrap classloader的類加載器為null，通過find方法來獲得
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }//需要獲取資料的朋友請加Q君樣：290194256*
                } catch (ClassNotFoundException e) {
                }

                if (c == null) {
                    // 如果還是沒有獲得該類，呼叫findClass找到類
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // jvm統計
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            // 連接類
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }//需要獲取資料的朋友請加Q君樣：290194256*
    }

三、破壞雙親委派

3.1、為什么需要破壞雙親委派？

因為在某些情況下父類加載器需要委托子類加載器去加載class檔案，受到加載范圍的限制，父類加載器無法加載到需要的檔案，以Driver介面為例，由于Driver介面定義在jdk當中的，而其實作由各個資料庫的服務商來提供，比如mysql的就寫了 MySQL Connector ，那么問題就來了，DriverManager（也由jdk提供）要加載各個實作了Driver介面的實作類，然后進行管理，但是DriverManager由啟動類加載器加載，只能記載JAVA_HOME的lib下檔案，而其實作是由服務商提供的，由系統類加載器加載，這個時候就需要啟動類加載器來委托子類來加載Driver實作，從而破壞了雙親委派，這里僅僅是舉了破壞雙親委派的其中一個情況，

3.2、破壞雙親委派的實作

我們結合Driver來看一下在spi（Service Provider Inteface）中如何實作破壞雙親委派，

先從DriverManager開始看，平時我們通過DriverManager來獲取資料庫的Connection：

String url = "jdbc:mysql://localhost:3306/testdb";
Connection conn = java.sql.DriverManager.getConnection(url, "root", "root"); 

在呼叫DriverManager的時候，會先初始化類，呼叫其中的靜態塊：

static {
    loadInitialDrivers();
    println("JDBC DriverManager initialized");
}

private static void loadInitialDrivers() {
    ...
        // 加載Driver的實作類
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {

                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }//需要獲取資料的朋友請加Q君樣：290194256*
                } catch(Throwable t) {
                }
                return null;
            }
        });
    ...
}


為了節約空間，筆者省略了一部分的代碼，重點來看一下 ServiceLoader.load(Driver.class) ：
public static <S> ServiceLoader<S> load(Class<S> service) {
    // 獲取當前執行緒中的背景關系類加載器
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}


可以看到，load方法呼叫獲取了當前執行緒中的背景關系類加載器，那么背景關系類加載器放的是什么加載器呢？
public Launcher() {
	...
    try {
        this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
        throw new InternalError("Could not create application class loader", var9);
    }//需要獲取資料的朋友請加Q君樣：290194256*
    Thread.currentThread().setContextClassLoader(this.loader);
    ...
}

在 sun.misc.Launcher 中，我們找到了答案，在Launcher初始化的時候，會獲取AppClassLoader，然后將其設定為背景關系類加載器，而這個AppClassLoader，就是之前上文提到的系統類加載器Application ClassLoader，所以背景關系類加載器默認情況下就是系統加載器，

繼續來看下 ServiceLoader.load(service, cl) ：

public static <S> ServiceLoader<S> load(Class<S> service,
                                        ClassLoader loader){
    return new ServiceLoader<>(service, loader);
}

private ServiceLoader(Class<S> svc, ClassLoader cl) {
    service = Objects.requireNonNull(svc, "Service interface cannot be null");
    // ClassLoader.getSystemClassLoader()回傳的也是系統類加載器
    loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
    acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
    reload();
}

public void reload() {
    providers.clear();
    lookupIterator = new LazyIterator(service, loader);
}


上面這段就不解釋了，比較簡單，然后就是看LazyIterator迭代器：
private class LazyIterator implements Iterator<S>{
    // ServiceLoader的iterator()方法最后呼叫的是這個迭代器里的next
    public S next() {
        if (acc == null) {
            return nextService();
        } else {
            PrivilegedAction<S> action = new PrivilegedAction<S>() {
                public S run() { return nextService(); }
            };
            return AccessController.doPrivileged(action, acc);
        }V
    }
    
    private S nextService() {
        if (!hasNextService())
            throw new NoSuchElementException();
        String cn = nextName;
        nextName = null;
        Class<?> c = null;
        // 根據名字來加載類
        try {
            c = Class.forName(cn, false, loader);
        } catch (ClassNotFoundException x) {
            fail(service,
                 "Provider " + cn + " not found");
        }
        if (!service.isAssignableFrom(c)) {
            fail(service,
                 "Provider " + cn  + " not a subtype");
        }//需要獲取資料的朋友請加Q君樣：290194256*
        try {
            S p = service.cast(c.newInstance());
            providers.put(cn, p);
            return p;
        } catch (Throwable x) {
            fail(service,
                 "Provider " + cn + " could not be instantiated",
                 x);
        }
        throw new Error();          // This cannot happen
    }//需要獲取資料的朋友請加Q君樣：290194256*
    
    public boolean hasNext() {
        if (acc == null) {
            return hasNextService();
        } else {
            PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                public Boolean run() { return hasNextService(); }
            };
            return AccessController.doPrivileged(action, acc);
        }
    }
    
    
    private boolean hasNextService() {
        if (nextName != null) {
            return true;
        }
        if (configs == null) {
            try {
                // 在classpath下查找META-INF/services/java.sql.Driver名字的檔案夾
                // private static final String PREFIX = "META-INF/services/";
                String fullName = PREFIX + service.getName();
                if (loader == null)
                    configs = ClassLoader.getSystemResources(fullName);
                else
                    configs = loader.getResources(fullName);
            } catch (IOException x) {
                fail(service, "Error locating configuration files", x);
            }
        }
        while ((pending == null) || !pending.hasNext()) {
            if (!configs.hasMoreElements()) {
                return false;
            }
            pending = parse(service, configs.nextElement());
        }
        nextName = pending.next();
        return true;
    }

}

最新2020整理收集的一些高頻面試題（都整理成檔案），
有很多干貨，包含mysql，netty，spring，執行緒，spring cloud、jvm、
原始碼、演算法等詳細講解，也有詳細的學習規劃圖，面試題整理等，
需要獲取這些內容的朋友請加Q君樣：290194256*