JVM-类加载机制

1.类的生命周期

类的生命周期主要包括加载、连接、初始化、使用和卸载。

1.1 加载

1.通过全类限定名获取类的二进制流。

2.将静态存储结构转化成方法区的动态存储结构。

3.并且在堆中生成Class对象，并且将静态变量附在Class对象后面。

1.2 验证

验证主要是保证字节码的安全性
1. 验证字节码是否合理，比如是否以魔数开头；

2. 验证所描述的字节码是否符合java语义规范,比如类是否有父类;

3.字节码验证，比如验证对象引用是否超过了内存范围；

4.符号引用的验证，是否能够通过符号引用转换成直接引用.

1.3 准备

准备其实就是给类的静态变量赋上初始值，比如int设置为0，对象引用设置为null。

1.4 解析

解析就是将符号引用转化为直接引用

1.4.1 什么是符号引用

符号引用其实就是字节码文件常量池里面名称标识，比如变量名，方法名等就是符号引用。

1.4.2 什么是直接引用

直接引用就是变量或者方法的地址。

在解析的时候其实就是将方法的名称，找到对应的存储地址,并且生成一条指令访问该地址。

1.5 初始化

初始化其实就是给变量赋值，也就是调用类的<cinit>方法对值进行初始化成程序员填写的内容。

初始化的时候需要注意几个地方:

1.当有静态代码块和静态变量初始化的时候，就会有<cinit>方法。

2.初始化的时候，如果静态代码块和静态变量同时赋值的时候，按照书写顺序赋值。

3.调用<cinit>方法的时候，需要先调用父类的<cinit>方法。

3.<cinit>方法在多线程环境下，一定能够保证同步去初始化一个类。

1.6 类的使用

类就是被程序员使用。

1.7 类的卸载

当满足如下两个条件的时候，会卸载类：
1.类所有的实例已经被gc掉。

2.加载该类的类加载器被gc。

所以java自带的类加载器加载的类都一般不能被卸载。

2.什么时候会触发类的加载

2.1 主动引用

当一个类被主动引用的时候会触发类加载，在以下几种场景就是主动引用:

1.调用new 关键字实例化对象的时候会初始化该类；

2.引用类中的静态变量的时候会初始化；

3.当进行反射调用的时候，如果该类未被加载，会主动加载该类。比如调用Class.forName方法的时候会加载该类；

4.jdk7推的函数指针，MethodHandle调用该类方法的时候，会触发类的初始化；

5.当子类加载的时候，会优先加载父类。

2.2 被动引用

被被动引用的类并不会初始化，比如以下的几种场景：

1.在子类中调用父类的静态变量，只会初始化父类

public class Father{
    private static int a = 0;
}

public class Son extends father{

}

public class Test{
    public static void main(String[] args) {
        System.out.println(Son.value);
    }
}

可以结合对象中的变量是静态分派进行记忆。

2.定义一个类的数组，并不会导致该类加载

即数组不通过类加载器进行加载。

3. 引用类的静态常量，并不会触发类的加载

因为静态常量会在编译阶段优化的时候存入到常量池中，本质上是直接获取到常量。

3.类加载器

类加载器可以将字节码转换成一个内存中的java对象，并且采用不同的类加载器加载的同一个名称的类，对于java也是不同的类。

3.1 双亲委派模型

3.1.1 什么是双亲委派模型

java的类加载器主要是分成4类：

1.启动类加载器：主要加载java核心库里面的类，比如rt.jat，是由c++实现的，如果要把代码交给启动类加载器加载，可以直接使用null便可；

2.扩展类加载器：主要加载/lib/ext目录下面的文件；

3.应用类加载器：加载ClassPath上面的文件，为系统默认的类加载器；

4.应用类加载器：用户自定义类加载的过程，用户可以重写findClass或者defineClass实现自己的类加载逻辑。

那什么是双亲委派机制呢？

1.类加载器加载一个类的时候，首先会交给父类加载器去加载，如果父类加载器不能加载才自己加载；

2.父类加载器加载的类不能引用子类加载器加载的类;

3.1.2 为什么需要双亲委派模型

1.保证java核心类库的类只会被加载一次。因为他都是有启动类加载器进行加载。

2.保证java核心类的安全性，比如对于String类，如果可以用户自定义类加载器加载的话，便可以用户自定义一个String类来替换掉rt.jar包中的String类。

3.1.3 双亲委派模型代码实现

双亲委派模型的代码就在ClassLoader的loadClass方法里面：
 

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            //检查需要加载的类是否已经被加载过
            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);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

3.1.4 双亲委派模型的缺点

由于java类加载中的可见性，子类加载器加载的类对父类加载器加载的类是不可见的。java中的一般实现是在java的核心类库中定义好自己的规范，而具体实现是由第三方实现的。我们可以举一个数据库驱动的例子说明：
 

public class DriverManager {
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
}


 private static void loadInitialDrivers() {
        String drivers;
        try {
            drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty("jdbc.drivers");
                }
            });
        } catch (Exception ex) {
            drivers = null;
        }
        // If the driver is packaged as a Service Provider, load it.
        // Get all the drivers through the classloader
        // exposed as a java.sql.Driver.class service.
        // ServiceLoader.load() replaces the sun.misc.Providers()

        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {

                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
            }
        }
}

可以看出DriverManager 这个类是定义在rt.jar包中的，是由启动类加载器加载的，但是在这个类加载器里面回去加载实现了Driver接口的类，这些类都是由系统里加载器加载的，这时就出现了可见性这个问题。

3.1.5 怎么打破双亲委派模型

双亲委派模型由3次被打破的场景：

1.loadClass方法是一个protected方法，用户可以重写该方法，并且重新定义类加载的逻辑，所以自定义类加载器的时候最好重写findClass方法；

2.针对可见性问题，引入线程上下文类加载器，这样在接口中就可以通过线程上下文类加载器去加载子类中的类。

3.代码热替换或者热部署其实就是对双亲委派模型的打破。

3.1.6 打破双亲委派能够重写java核心类库中的类吗？

只是重新类加载逻辑是不能够的，因为自定义类加载器还是要调用defineClass方法来将字节流转换成一个Class，这个方法里面会检查这个类的犬类限定名是否是以java开头，保证java核心类库的安全性。

3.2 热部署的实现

如果我们希望java代码像jsp一样，修改过后编译便进行热替换的话。可以通过自定义类加载器实现，自定义一个类加载器，每次读取最新的字节码，并且生产新的Class类，同时将原来的Class类给丢弃。