细思极恐！你真的理解类加载机制吗

import org.slf4j.impl.StaticLoggerBinder;
import java.util.concurrent.TimeUnit;

public class App {
    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(15);
        System.out.println(">>>>>>>>>>");
        StaticLoggerBinder.getSingleton();
    }
}

public class Test {
    private byte[] one_hundred_mb = new byte[1024 * 1024 * 100];
}

public class SpecClassLoader extends ClassLoader {
    
    private byte[] two_hundred_mb = new byte[1024 * 1024 * 200];
    
    public SpecClassLoader(ClassLoader parent) {
        super(parent);
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (!name.startsWith("io.github.dk900912.classloading")) {
            return super.loadClass(name);
        }
        synchronized (getClassLoadingLock(name)) {
            Class<?> loadedClass = findLoadedClass(name);
            if (loadedClass == null) {
                loadedClass = findClass(name);
            }
            return loadedClass;
        }
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String path = name.replace('.', '/').concat(".class");
        try (InputStream inputStream = getResourceAsStream(path);
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int length = 0;
            while ((length = inputStream.read(buffer)) != -1) {
                byteArrayOutputStream.write(buffer, 0, length);
            }
            byte[] classData = byteArrayOutputStream.toByteArray();
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException();
        }
    }
}

public class App {
    public static void main(String[] args) {
        SpecClassLoader specClassLoader = new SpecClassLoader(Thread.currentThread().getContextClassLoader());
        Object test = specClassLoader.loadClass("io.github.dk900912.classloading.Test").newInstance();

        TimeUnit.SECONDS.sleep(20);

        test = null;

        for (;;) {}
    }
}

public class App {
    public static void main(String[] args) {
        SpecClassLoader specClassLoader = new SpecClassLoader(Thread.currentThread().getContextClassLoader());
        Object test = specClassLoader.loadClass("io.github.dk900912.classloading.Test").newInstance();

        TimeUnit.SECONDS.sleep(20);

        test = null;
        specClassLoader = null;

        for (;;) {}
    }
}

[27.601s][info][class,unload] unloading class io.github.dk900912.classloading.Test 0x0000000800c02000

# JDK 9 之前的类加载器继承体系
ClassLoader (java.lang)
    SecureClassLoader (java.security)
        URLClassLoader (java.net)
            ExtClassLoader in Launcher (sun.misc)
            AppClassLoader in Launcher (sun.misc)
   
# JDK 9 之后的类加载器继承体系   
ClassLoader (java.lang)
    SecureClassLoader (java.security)
        BuiltinClassLoader (jdk.internal.loader)
            BootClassLoader in ClassLoaders (jdk.internal.loader)
            PlatformClassLoader in ClassLoaders (jdk.internal.loader)
            AppClassLoader in ClassLoaders (jdk.internal.loader)

public abstract class ClassLoader {
    private final ClassLoader parent;
 
    protected ClassLoader() {
        this(getSystemClassLoader());
    }
    private ClassLoader(ClassLoader parent) {
        this.parent = parent;
    }
 
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
 
    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) {
                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.
                    c = findClass(name);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
 
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    } 
}

public final class Class<T> {
    public static Class<?> forName(String className) throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }
    private static native Class<?> forName0(String name, boolean initialize, ClassLoader loader, Class<?> caller) throws ClassNotFoundException;
}

public class DriverManager {
    
    static {
        loadInitialDrivers();
    }
    private static void loadInitialDrivers() {
        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();
                    }
                } catch(Throwable t) {
                    // Do nothing
                }
                return null;
            }
        });
    }
}

public final class ServiceLoader<S> {
    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return new ServiceLoader<>(Reflection.getCallerClass(), service, cl);
    }
}

public final class System {
    /*
     * Invoked by VM.  Phase 3 is the final system initialization:
     * 1. eagerly initialize bootstrap method factories that might interact
     *    negatively with custom security managers and custom class loaders
     * 2. set security manager
     * 3. set system class loader
     * 4. set TCCL
     *
     * This method must be called after the module system initialization.
     * The security manager and system class loader may be a custom class from
     * the application classpath or modulepath.
     */
    @SuppressWarnings("removal")
    private static void initPhase3() {
        // initializing the system class loader
        VM.initLevel(3);

        // system class loader initialized
        ClassLoader scl = ClassLoader.initSystemClassLoader();

        // set TCCL
        Thread.currentThread().setContextClassLoader(scl);

        // system is fully initialized
        VM.initLevel(4);
    }
}

public abstract class ClassLoader {
    static synchronized ClassLoader initSystemClassLoader() {
        ClassLoader builtinLoader = getBuiltinAppClassLoader();

        String cn = System.getProperty("java.system.class.loader");
        if (cn != null) {
            try {
                Constructor<?> ctor = Class.forName(cn, false, builtinLoader)
                                           .getDeclaredConstructor(ClassLoader.class);
                scl = (ClassLoader) ctor.newInstance(builtinLoader);
            } catch (Exception e) {
                Throwable cause = e;
                if (e instanceof InvocationTargetException) {
                    cause = e.getCause();
                    if (cause instanceof Error) {
                        throw (Error) cause;
                    }
                }
                if (cause instanceof RuntimeException) {
                    throw (RuntimeException) cause;
                }
                throw new Error(cause.getMessage(), cause);
            }
        } else {
            scl = builtinLoader;
        }
        return scl;
    }
}

package org.slf4j;

public final class LoggerFactory {
    private final static void bind() {
        try {
            Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
            if(staticLoggerBinderPathSet.size() > 1) {
                Util.report("Class path contains multiple SLF4J bindings.");
                for (URL path : staticLoggerBinderPathSet) {
                    Util.report("Found binding in [" + path + "]");
                }
            }
            // the next line does the binding
            StaticLoggerBinder.getSingleton();
        } catch (NoClassDefFoundError ncde) {
            // Ignore details
        } catch (java.lang.NoSuchMethodError nsme) {
            // Ignore details
        } catch (Exception e) {
            // Ignore details
        }
    }
}

----------------------------------------------------------------------------------------------
classloaderName                                              instanceCount        loadedCount 
jdk.internal.loader.ClassLoaders$AppClassLoader              1                    4081        
jdk.internal.reflect.DelegatingClassLoader                   81                   81          
BootClassLoader                                              1                    3174        
jdk.internal.loader.ClassLoaders$PlatformClassLoader         1                    46          
sun.reflect.misc.MethodUtil                                  1                    1           
----------------------------------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>>> package list loaded by jdk.internal.loader.ClassLoaders$AppClassLoader             
javax.websocket
org.aopalliance
org.slf4j
javax.security
com.mysql
com.intellij
com.ulisesbocchio
javax.annotation
javax.servlet
com.zaxxer
ch.qos
org.springframework
com.sun
io.github
com.example
org.jasypt
org.apache
com.fasterxml

>>>>>>>>>>>>>>>>>>>> package list loaded by jdk.internal.reflect.DelegatingClassLoader                  
jdk.internal

>>>>>>>>>>>>>>>>>>>> package list loaded by BootClassLoader                                        
javax.xml
java.rmi
sun.reflect
java.util
sun.management
sun.net
java.beans
javax.security
javax.naming
java.nio
sun.nio
jdk.jfr
sun.invoke
sun.launcher
java.time
org.xml
jdk.net
java.net
sun.rmi
com.sun
sun.instrument
sun.text
java.math
java.security
sun.security
javax.management
sun.io
jdk.xml
sun.util
java.lang
java.text
jdk.management
java.io
jdk.internal
javax.net
javax.swing

>>>>>>>>>>>>>>>>>>>> package list loaded by jdk.internal.loader.ClassLoaders$PlatformClassLoader        
java.sql
sun.util
sun.security
org.jcp
com.sun
javax.sql
sun.text

>>>>>>>>>>>>>>>>>>>> package list loaded by sun.reflect.misc.MethodUtil                                 
sun.reflect

public class RestartClassLoader extends URLClassLoader implements SmartClassLoader {
    @Override
    public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        String path = name.replace('.', '/').concat(".class");
        ClassLoaderFile file = this.updatedFiles.getFile(path);
        if (file != null && file.getKind() == Kind.DELETED) {
            throw new ClassNotFoundException(name);
        }
        synchronized (getClassLoadingLock(name)) {
            Class<?> loadedClass = findLoadedClass(name);
            if (loadedClass == null) {
                try {
                    loadedClass = findClass(name);
                } catch (ClassNotFoundException ex) {
                    loadedClass = Class.forName(name, false, getParent());
                }
            }
            if (resolve) {
                resolveClass(loadedClass);
            }
            return loadedClass;
        }
    }
}