Java基础：类加载与双亲委派源码解析

本是古典何须时尚 2022-09-10 08:16 122阅读 0赞

# 1 类加载 #

## 1.1 类加载细节 ##

类加载过程如图1.1所示。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp54S2546p5a62_size_15_color_FFFFFF_t_70_g_se_x_16_pic_center]

图1.1 类加载过程

由1.1流程可知，类加载过程，经过四次判断，第一次：判断系统是否已经加载；第二次：parent是否加载，第三次：启动类加载器是否加载，第四次：自定义类加载是否加载。其中，parent类加载有两种，即应用程序类加载器（ApplicationClassLoader）和扩展类加载器（ExtensionClassLoader），也就是双亲委派。

## 1.2 类加载架构 ##

由1.1抽象出类加载架构如图1.2所示。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp54S2546p5a62_size_12_color_FFFFFF_t_70_g_se_x_16_pic_center]

## 1.2 双亲委派 ##

由1.1流程可知，类加载过程，parent类加载有两种，即应用程序类加载器（ApplicationClassLoader）和扩展类加载器（ExtensionClassLoader），所谓的双亲。

# 2 源码解析 #

ClassLoader所在包：

package java.lang;

## 2.1 classLoad()方法 ##

源码流程即1.1流程图。由注释可知：classLoad()方法即按照一定的规则进行类加载。自定义类加载器重写findClass方法。

/**
 * Loads the class with the specified <a href="#name">binary name</a>. The
 * default implementation of this method searches for classes in the
 * following order:
 *
 * <ol>
 *
 * <li> Invoke {@link #findLoadedClass(String)} to check if the class
 * has already been loaded. </li>
 *
 * <li> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method
 * on the parent class loader. If the parent is <tt>null</tt> the class
 * loader built-in to the virtual machine is used, instead. </li>
 *
 * <li> Invoke the {@link #findClass(String)} method to find the
 * class. </li>
 *
 * </ol>
 *
 * If the class was found using the above steps, and the
 * <tt>resolve</tt> flag is true, this method will then invoke the {@link
 * #resolveClass(Class)} method on the resulting <tt>Class</tt> object.
 *
 * Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link
 * #findClass(String)}, rather than this method. 
 *
 * Unless overridden, this method synchronizes on the result of
 * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method
 * during the entire class loading process.
 *
 * @param name
 * The <a href="#name">binary name</a> of the class
 *
 * @param resolve
 * If <tt>true</tt> then resolve the class
 *
 * @return The resulting <tt>Class</tt> object
 *
 * @throws ClassNotFoundException
 * If the class could not be found
 */
 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) {
 
 long t0 = System.nanoTime();
 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.
 long t1 = System.nanoTime();
 c = findClass(name);
 
 // this is the defining class loader; record the stats
 sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
 sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
 sun.misc.PerfCounter.getFindClasses().increment();
 }
 }
 if (resolve) {
 
 resolveClass(c);
 }
 return c;
 }
 }

## 2.2 parent属性 ##

双亲属性，即应用类加载器和扩展类加载器。

// The parent class loader for delegation
        // Note: VM hardcoded the offset of this field, thus all new fields
        // must be added *after* it.
        private final ClassLoader parent;

## 2.3 抽象类ClassLoader构造器 ##

protected ClassLoader(ClassLoader parent) {
 
 this(checkCreateClassLoader(), parent);
 }
 
 private ClassLoader(Void unused, ClassLoader parent) {
 
 this.parent = parent;
 if (ParallelLoaders.isRegistered(this.getClass())) {
 
 parallelLockMap = new ConcurrentHashMap<>();
 package2certs = new ConcurrentHashMap<>();
 assertionLock = new Object();
 } else {
 
 // no finer-grained lock; lock on the classloader instance
 parallelLockMap = null;
 package2certs = new Hashtable<>();
 assertionLock = this;
 }
 }
 protected ClassLoader() {
 
 this(checkCreateClassLoader(), getSystemClassLoader());
 }

其中getSystemClassLoader即应用程序类构造器和扩展类构造器。

@CallerSensitive
        public static ClassLoader getSystemClassLoader() {
        
            initSystemClassLoader();
            if (scl == null) {
        
                return null;
            }
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
        
                checkClassLoaderPermission(scl, Reflection.getCallerClass());
            }
            return scl;
        }

initSystemClassLoader()

private static synchronized void initSystemClassLoader() {
        
            if (!sclSet) {
        
                if (scl != null)
                    throw new IllegalStateException("recursive invocation");
                sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
                if (l != null) {
        
                    Throwable oops = null;
                    scl = l.getClassLoader();
                    try {
        
                        scl = AccessController.doPrivileged(
                            new SystemClassLoaderAction(scl));
                    } catch (PrivilegedActionException pae) {
        
                        oops = pae.getCause();
                        if (oops instanceof InvocationTargetException) {
        
                            oops = oops.getCause();
                        }
                    }
                    if (oops != null) {
        
                        if (oops instanceof Error) {
        
                            throw (Error) oops;
                        } else {
        
                            // wrap the exception
                            throw new Error(oops);
                        }
                    }
                }
                sclSet = true;
            }
        }

## 2.4 ExtensionClassLoader和ApplicationClassLoader ##

sun.misc.Launcher.getLauncher()加载ExtClassLoader()和AppClassLoader

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);
            }
            ...
      }

## 2.5 run ##

class SystemClassLoaderAction
 implements PrivilegedExceptionAction<ClassLoader> {
 
 private ClassLoader parent;
 
 SystemClassLoaderAction(ClassLoader parent) {
 
 this.parent = parent;
 }
 
 public ClassLoader run() throws Exception {
 
 String cls = System.getProperty("java.system.class.loader");
 if (cls == null) {
 
 return parent;
 }
 
 Constructor<?> ctor = Class.forName(cls, true, parent)
 .getDeclaredConstructor(new Class<?>[] {
 ClassLoader.class });
 ClassLoader sys = (ClassLoader) ctor.newInstance(
 new Object[] {
 parent });
 Thread.currentThread().setContextClassLoader(sys);
 return sys;
 }
 }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp54S2546p5a62_size_15_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/1a78c23fbe934207a0f55a6d49dc8331.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp54S2546p5a62_size_12_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/0c2f398a23b64248a6f79ecec05f8bd0.png