java面经-JVM篇

public class ClassLoaderDemo {

    public static final String aaa = "aaaa";

    public static void main(String[] args) throws Exception {
        // 父子关系 AppClassLoader <- ExtClassLoader <- Bootstrap ClassLoader
        ClassLoader cl1 = ClassLoaderDemo.class.getClassLoader();
        System.out.println("cl1 > " + cl1);
        System.out.println("parent of cl1 > " + cl1.getParent());
        // Bootstrap ClassLoader由C++开发，是JVM虚拟机的一部分，本身不是JAVA类。
        System.out.println("grand parent of cl1 > " + cl1.getParent().getParent());
        // String, Int等基础类由Bootstrap ClassLoader加载。
        ClassLoader cl2 = String.class.getClassLoader();
        System.out.println("cl2 > " + cl2);
        System.out.println(ClassLoaderDemo.class.getClassLoader().loadClass("java.util.List").getClassLoader());
        // java指令可以通过增加-verbose:class -verbose:gc 参数在启动时打印出类加载情况
        // Bootstrap ClassLoader，加载java基础类。这个属性不能在java指令中指定，推断不是由java语言处理。
        System.out.println("Bootstrap ClassLoader: " + System.getProperty("sun.boot.class.path"));
        // Extension ClassLoader 加载JAVA_HOME/ext 下的jar包。可通过-D java.ext.dirs另行指定目录
        System.out.println("Extension ClassLoader: " + System.getProperty("java.ext.dirs"));
        // AppClassLoader 加载CLASSPATH，应用下的Jar包。可通过-D java.class.path另行指定目录
        System.out.println("AppClassLoader: " + System.getProperty("java.class.path"));
    }
}

cl1 > jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
parent of cl1 > jdk.internal.loader.ClassLoaders$PlatformClassLoader@76ed5528
grand parent of cl1 > null
cl2 > null
jdk.internal.loader.BuiltinClassLoader@6d06d69c
Bootstrap ClassLoader: /opt/jdk-16.0.1/lib
Extension ClassLoader: /opt/jdk-16.0.1/lib/ext:/usr/java/packages/lib/ext
AppClassLoader: /home/user/example:/opt/jdk-16.0.1/lib

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