类在JVM中如何加载？何为双亲委派机制？

类的加载顺序

一个class进来进行loading加载到内存中，然后进行linking，linking中又分为verification(检查)，preparartion(准备)，resolution(处理)。接着进行initalizing初始化给静态变量赋初始值,判断为无用类进行GC回收。
linking模块进行描述：
verification->用来检查加载进来的class是否符合解析的标准
preparartion->给class的静态变量赋默认值，一般基本类型为0，引用类型为null。
resolution->将class类中常量池中的地址符号转换成为直接的内存地址，及可访问的内存地址

类加载器与双亲委派机制

1.Bootstrap类加载器为顶级的classloader加载路径为<JAVA_HOME>\lib目录中jar文件
2.Extension加载器负责加载<JAVA_HOME>\lib\ext目录中的jar文件
3.App加载器负责加载用户类路径（ClassPath）上所指定的类库，如果应用程序中没有自定义自己的类加载器，一般情况下这个就是程序中默认的类加载器。
4.Custom为自定义加载器，由用户自己实现。

JVM是按需动态加载，采用双亲委派机制，自底部往上检查该类是否加载(图中1>2>3的顺序)，如果没有classloader加载过该类则会自上而下(4>5>6)再去查找加载class，直到找到该class并加载到内存中。
采用双亲委派机制的好处是为了安全，避免外部加载进来的类和内部classloader链中产生冲突，做恶意破坏，如果有同名的类被加载进来JVM首先会判断是否有这样一个类已经加载过，如果已经加载则不会再加载一次该类。
下面我们来看下classloader的源码
name参数为class的名称，实际调用的是loadClass()

   public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }

再来看看loadClass().

先findLoadedClass加载类，如果返回为null则调用 parent.loadClass();这里的parent即为上图中classloader的父级classloader，依次调用如果都找不到在调用findClass()

    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) {
                       **//自下而上loadclass**
                        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();
                    **//自上而下findclass**
                    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;
        }
    }

如果想要自定义classloader 直接继承ClassLoader并重写findclass方法，在findclass中调用defaulclass()传入需要加载的class信息。下面上代码

public class MyClassloader extends ClassLoader{

    @SneakyThrows
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        FileInputStream fileInputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            fileInputStream=new FileInputStream(new File(name));
            byteArrayOutputStream=new ByteArrayOutputStream();
            int i;
            while ((i=fileInputStream.read())!=-1){
                byteArrayOutputStream.write(i);
            }
            byte[] classByte=byteArrayOutputStream.toByteArray();
            return defineClass(name,classByte,0,classByte.length);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            fileInputStream.close();
            byteArrayOutputStream.close();
        }
        return super.findClass(name);
    }

    public static void main(String[] args) {
        ClassLoader classLoader=new MyClassloader();
        try {
            classLoader.loadClass("C:/test.class");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

如何打破双亲委派机制？
我们从上述源码可以推断，只要重写ClassLoader的loadClass()方法，在loadClass方法中不在调用父类的loadClass()，而是直接去load自己的class，这样就可以打破双亲委派机制。
举一个列子：tomcate的热部署就是打破了双亲委派机制，修改一个class文件可以立即同步到上下文中，其实本质就是重新加载了一次该class，如果有感兴趣的可以去了解一下tomcat的实现原理里面大致应该也是重写了loadClass()方法。

懒加载

类的加载不是在初始化时loading所有的类，而是在用到的时候才会去加载class。即会发生懒加载，懒加载有五种情况：
1.new对象，获取和访问静态变量，记住访问final变量除外

2.java.lang.reflect对类进行反射调用时

3.初始化子类的时候，父类首先初始化

4.虚拟机启动时，被执行的主类必须初始化

5.动态语言支持java.lang.invoke.MethodHandle解析的结果为REF_getstatic REF_putstatic REF_invokestatic的方法句柄时，该类必须初始化