Java类加载机制

理解：
掘金：类加载:https://juejin.cn/post/6844903517388275726
简书：https://www.jianshu.com/p/b09888ddac35， 每一个类加载器，都拥有一个独立的类名称空间.
双亲委派机制：https://juejin.cn/post/684490383892781466。
SPI打破双亲委派：https://zhuanlan.zhihu.com/p/185612299， 理解DriverManager类由启动类加载器加载，Class.forName此时在家在类使用启动类加载器无法加载Driver对应的class。所以需要通过获取上下文类加载器加载（默认是应用类加载器）。

jvm启动java程序过程
引用：https://blog.csdn.net/m0_45406092/article/details/108976907，https://blog.csdn.net/m0_45406092/article/details/108984101
这两篇博客讲的比较好，用自己的语言来总结下，
java org.luanlouis.jvm.load.Main 时，jvm会开启一个进程运行程序。不同的java程序，内存隔离。

1. 根据JVM内存配置要求，为JVM申请特定大小的内存空间
2. jvm实例化引导类加载器，加载jvm系统类到jvm内存中，通常是{JRE_HOME}/lib下的类，String.class、Object.class. 由于String.class、Object.class这些类对象的都是引导类加载器加载的，所以这些类的对象得到的加载器都是null

System.out.println(String.class.getClassLoader());//null
System.out.println(Object.class.getClassLoader());//null
System.out.println(Math.class.getClassLoader());//null
System.out.println(System.class.getClassLoader());//null

3. 创建JVM 启动器实例 Launcher,并取得类加载器ClassLoader.
   (注意)Launcher类，Launcher类的实例化为单例的。

ExtClassLoader 扩展类是Launcher的静态内部类， 是单例的。

static class ExtClassLoader extends URLClassLoader {
        private static volatile Launcher.ExtClassLoader instance;

        public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
            if (instance == null) {
                Class var0 = Launcher.ExtClassLoader.class;
                synchronized(Launcher.ExtClassLoader.class) {
                    if (instance == null) {
                        instance = createExtClassLoader();
                    }
                }
            }

            return instance;
        }

        private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
            try {
                return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
                    public Launcher.ExtClassLoader run() throws IOException {
                        File[] var1 = Launcher.ExtClassLoader.getExtDirs();
                        int var2 = var1.length;

                        for(int var3 = 0; var3 < var2; ++var3) {
                            MetaIndex.registerDirectory(var1[var3]);
                        }

                        return new Launcher.ExtClassLoader(var1);
                    }
                });
            } catch (PrivilegedActionException var1) {
                throw (IOException)var1.getException();
            }
        }

AppClassLoader类也为Launcher类的静态内部类

static class AppClassLoader extends URLClassLoader {
        final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

        public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
            final String var1 = System.getProperty("java.class.path");
            final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
            return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
                public Launcher.AppClassLoader run() {
                    URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
                    return new Launcher.AppClassLoader(var1x, var0);
                }
            });
        }

        AppClassLoader(URL[] var1, ClassLoader var2) {
            super(var1, var2, Launcher.factory);
            this.ucp.initLookupCache(this);
        }

        public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
            int var3 = var1.lastIndexOf(46);
            if (var3 != -1) {
                SecurityManager var4 = System.getSecurityManager();
                if (var4 != null) {
                    var4.checkPackageAccess(var1.substring(0, var3));
                }
            }

            if (this.ucp.knownToNotExist(var1)) {
                Class var5 = this.findLoadedClass(var1);
                if (var5 != null) {
                    if (var2) {
                        this.resolveClass(var5);
                    }

                    return var5;
                } else {
                    throw new ClassNotFoundException(var1);
                }
            } else {
                return super.loadClass(var1, var2);
            }
        }

public class Launcher {
    private static URLStreamHandlerFactory factory = new Launcher.Factory();
    //单例模式
    private static Launcher launcher = new Launcher();
    private static String bootClassPath = System.getProperty("sun.boot.class.path");
    private ClassLoader loader;
    private static URLStreamHandler fileHandler;

    public static Launcher getLauncher() {
        return launcher;
    }

    public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }
        //初始化，AppClassLoader，AppClassLoader虽然不是单例模式，但是Launcher只初始化时，执行一次单例模式，如果不主动实例化Launcher，Launcher只有一个实例。 AppClassLoader和ExtclassLoader一般也只有一个实例。
        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   
    public ClassLoader getClassLoader() {
        return this.loader;
    }
}

4. Step 4. 类加载器AppClassLoader加载Main类，

ClassLoader classloader = launcher.getClassLoader();//取得AppClassLoader类
classLoader.loadClass("org.luanlouis.jvm.load.Main");//加载自定义类

当AppClassLoader要加载 org.luanlouis.jvm.load.Main类时，会去查看该类的定义，发现它内部声明使用了其它的类： sun.security.pkcs11.P11Util、java.lang.Object、java.lang.System、java.io.PrintStream、java.lang.Class；org.luanlouis.jvm.load.Main类要想正常工作，首先要能够保证这些其内部声明的类加载成功。所以AppClassLoader要先将这些类加载到内存中。（注：为了理解方便，这里没有考虑懒加载的情况，事实上的JVM加载类过程比这复杂的多）。
依赖双亲委派类加载机制，最终会在判断引导类加载器，是否加载过这些类，如果加载过，直接返回类对象了。

5. 使用Main类的main方法作为程序入口运行程序
6. 方法执行完毕，JVM销毁，释放内存

java双亲委派机制:

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();
                    //在find的过程中defineclass
                    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;
        }
    }

1.授信判断自己是否加载过class文件，如果没有
2.查看是否有parent加载器，如果有交给父加载器加载，如果父加载器没有加载过，判断引导类加载器，是否加载过class文件，如果没有，自己加载该类。
3.自定义类加载器，一般重写findclass方法， 如果想要打破双亲委派机制，则需要重写loadclass方法。

java类加载器的extend继承关系
classLoader->SecureClassLoader->URLClassLoader->ExtClassLoader
classLoader->SecureClassLoader->URLClassLoader->AppClassLoader

其中parent关系
URLClassLoader->AppClassLoader->ExtClassLoader->null
URLClassLoader实例化时，利用的当前线程的上下文类加载器，作为自己的parent.

\package RememberTest;
import sun.misc.Launcher;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;


public class TestLoader{
    public static void main(String[] args) throws ClassNotFoundException, MalformedURLException {
        String classPath = System.getProperty("java.class.path");
        for (String path : classPath.split(";")) {
            System.out.println(path);
        }
        ClassLoader launcherClassLoader = Launcher.class.getClassLoader();
        //类对象是class<T>  泛型
        Class<Launcher> sh = Launcher.class;
        sh.getClassLoader();

        Launcher launcher = Launcher.getLauncher();


        //此处路径是有问题的，在这个路径下/home/mayansong/eclipse-workspace/Algorithm/扫描不到RememberTest.Test
        URLClassLoader loader_1 = new URLClassLoader(new URL[]{new File("/home/mayansong/eclipse-workspace/Algorithm/").toURI().toURL()});

        URLClassLoader loader_2 = new URLClassLoader(new URL[]{new File("/home/mayansong/eclipse-workspace/Algorithm/").toURI().toURL()});
        Class<?> clazz_1 = loader_1.loadClass("RememberTest.Test");
        Class<?> clazz_2 = loader_2.loadClass("RememberTest.Test");
        //得到的类加载相同，因为有双亲委派机制所以他们的类加载器都是AppclassLoader, 在classpath下能够找到class文件。
        System.out.println(clazz_1.getClassLoader()==clazz_2.getClassLoader());

 

        URLClassLoader loader_1 = new URLClassLoader(new URL[]{new File("/home/mayansong/java_test").toURI().toURL()});

        URLClassLoader loader_2 = new URLClassLoader(new URL[]{new File("/home/mayansong/java_test").toURI().toURL()});
        //由于父类加载不到class文件，只能自己加载
        Class<?> clazz_1 = loader_1.loadClass("JavaTest");
        Class<?> clazz_2 = loader_2.loadClass("JavaTest");
        //他们的类加载器不同，同时由于类标识在jvm中是通过包名、列名、类加载器（实例）名共同决定，所以生成了两个不同的累对象。
        System.out.println(clazz_1.getClassLoader()==clazz_2.getClassLoader());
        System.out.println(clazz_1==clazz_2);  //结果为false

    }
}

Java类加载机制。
1.首先类的加载分为 加载、验证、准备、解析、初始化。首先要区分下加载和类加载的概念。
2.加载指的是加载class文件到内存中，并实例化class对象，这里加载到内存中，指的是两部分：
a. 将class信息，加载到方法区中，包括类信息，常量，静态变量等信息。
b.类对象放在堆中，具有类的方法，成员变量等信息，通过反射能够获取。
3.在jvm中存放类信息的类限定名和（类名，类在的包名，类的加载器实例名共同决定的），也就是不同的类加载器实例如果不遵循双亲委派机制，打破双亲委派机制，则会在jvm加载一个class文件中两次。

个人class文件理解
一些class文件，在编译时，就会将注解等信息编译到class文件中。