1. 类的加载、连接、初始化

加载：查找并加载类的二进制数据
连接：
-- 验证：确保被加载类的正确性
-- 准备：为类的静态变量分配内存，并将其初始化为默认值
-- 解析：把类中的符号引用转换为直接引用
初始化：为类的静态变量赋予正确的初始化值

12.png

1.1 符号引用&直接引用

静态解析：有些符号引用在类加载阶段或者第一次使用时就会转换为直接引用，这种转换叫做静态解析
-- 静态方法
-- 父类方法
-- 构造方法
-- 私有方法（无法被重写）
-- 这四类方法称为非虚方法，他们是在类加载阶段就可以把符号引用转换为直接引用的
动态链接：一些符号引用则在每次运行期转换为直接引用，这种转换叫做动态链接，这体现为Java的多态性
感觉这个文章讲的挺好的： https://blog.csdn.net/coslay/article/details/49404823

1、invokeinterface：调用接口中的方法，实际上是在运行期决定到底调用实现该接口的那个对象的特定方法
2、invokestatic：调用静态方法
3、invokespecial：调用自己的私有方法，构造方法（<init>）以及父类的方法
4、invokevirtual：调用虚方法，运行期动态查找的过程
5、invokedynamic：动态调用方法

public class Test5 {
    // 方法重载，是一种静态行为，编译器就可以完全确定
    public void test(Grandpa grandpa) {
        System.out.println("grandpa");
    }
    public void test(Father father) {
        System.out.println("father");
    }
    public static void main(String[] args) {
        // 方法的静态分派：
        // g1 的类型是Grandpa,而实际类型(指向的类型)是Father
        // 变量的静态类型是不会发生改变的。变量的实际类型可以发生变化(多态的体现)，实际类型在运行期方可确定
        Grandpa g1 = new Father();

        Test5 test5 = new Test5();
        test5.test(g1);
    }
}
class Grandpa {
}
class Father extends Grandpa {
}



public class Test6 {

    public static void main(String[] args) {
        Fruit fruit = new Fruit();
        Fruit apple = new Apple();

        // 方法的动态分派：方法接收者
        // invokevirtual字节码指令的多态查找流程，

        // 比较方法重载(overload)和方法重写（override），可以得到这样一个结论
        // 方法重载时静态的，是编译器行为；方法重写是动态的，是运行期行为

        fruit.test();
        apple.test();

        fruit = new Apple();
        fruit.test();
    }
}

class Fruit {

    public void test() {
        System.out.println("Fruit");
    }
}

class Apple extends Fruit {

    @Override
    public void test() {
        System.out.println("Apple");
    }
}

1.1 加载

jvm规范允许类加载器在预料某个类将要被使用的时候就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或者存在错误，类加载器必须在程序首次主动使用该类是，才报告错误(LinkkageError错误)
如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误

1.2 验证

类的验证内容
-- 类文件的结构检查
-- 语义检查
-- 字节码验证
-- 二进制兼容性验证

1.3 准备

在准备阶段，Java虚拟机为类的静态变量分配内存，并设置默认的初始值，列如对于以下Sample类，在准备阶段，将int类型的静态变量a分配4个字节的内存空间，并且赋予默认值0，为long类型的静态变量b分配8个字节的内存空间，并且赋予默认值0


class Sample {
    private static int a = 1;// 在静态变量的声明处初始化
    public static long b;
    public static long c;
    static {
        b = 2;// 在静态代码块中进行初始化
    }
}

1.4 初始化

在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值，在程序中，静态变量的初始化有两种途径，
-- 1-在静态变量的声明处进行初始化，
-- 2-在静态代码块中进行初始化，

1.5 初始化的时机

请看 《6、接口》 样例
当Java虚拟机初始化一个类的时候，要求他的所有父类都已经被初始化，但是这条规则并不适应于接口
-- 在初始化一个类时，并不会先初始化他所实现的接口
-- 在初始化一个接口时，并不会先初始化他的父接口
只有当程序首次使用特定接口的静态变量时，才会导致该接口初始化

2. 加载.class文件的方式

从本地系统中直接加载
通过网络下载.class文件
从zip，jar等归档文件中加载.class文件
从专有的数据库中提取.class文件
将Java源文件动态编译为.class

3. 主动使用（7种）

创建类的实例
访问某个类或接口的静态变量
调用类的静态方法
反射如 Class.forName("");
初始化一个类的子类
Java虚拟机启动时被标明为启动的类的类
JDK1.7开始提供动态语言支持：java.lang.invoke.MethodHandle实例解析的结果REF_getStatic, REF_putStatic, REF_invokeStatic句柄对应的类没有初始化，则初始化

4. 静态初始化

final静态常量：在编译阶段会存入到调用这个常量方法所在的类的常量池中，本质上没有直接引用定义常量的类，因此不会触发初始化
final动态常量：常量的值在编译期间不可以确定的，那么其值就不会放到调用类的常量池中，程序运行导致主动使用，初始化此类
静态常量：只有直接定义了该字段的类才会被初始化
父类：当一个类在初始化时，要求其父类先全部初始化
助记符：
-- ldc：将int、float、String类型的常量值从常量池推送至栈顶
-- bipush：将单字节(-128 ~ 127)的常量值推送至栈顶
-- sipush：将一个短整型(-32768 ~ 32767)推送至栈顶
-- iconst_1：将int类型的1推送至栈顶(iconst_1 ~ iconst_5)

-XX:+TraceClassLoading 打印类加载信息
-XX:+<option> 表示开启option选项
-XX:-<option> 表示关闭option选项
-XX:<option>=<value> 表示设置option选项值

输出结果：
2
---------------
P static init
1de47824-58c7-47ea-9f51-3f9bdf86e7c2
---------------
1

public class Test1 {

    public static void main(String[] args) {
        System.out.println(C.c1); // final常量，C P都不会初始化
        System.out.println("---------------");
        // System.out.println(C.p2); // final动态值，导致P初始化,C不会初始化
        System.out.println("---------------");
        System.out.println(C.p); // 类静态常量，导致P初始化，C也不会初始化
    }
}

class P {

    public static int          p  = 1;
    public static final int    p1 = 11;
    public static final String p2 = UUID.randomUUID().toString();
    static {
        System.out.println("P static init");
    }
}

class C extends P {

    public static int       c  = 2;
    public static final int c1 = 2;
    static {
        System.out.println("C static init");
    }
}

5. 数组

数据类型：其类型是由jvm在运行期间动态生成的，表示为 [I 这种形式，动态生成的类型，其父类型是object
数组不会导致类进行初始化
助记符
-- anewarray：表示创建一个引用类型的(类、接口、数组)数组、并将其引用值压入栈顶
-- newarray：表示创建一个原始类型(int、float、char等)的数组，并将其引用值压入栈顶

输出结果
class [Lcom.hui.classloader.P4;
class java.lang.Object
-----------------------
class [[Lcom.hui.classloader.P4;
class java.lang.Object
-----------------------
class [I
class java.lang.Object
-----------------------
null
null
-----------------------
P4 static init
com.hui.classloader.P4@7530d0a


public class Test4 {

    public static void main(String[] args) {
        P4[] p4s = new P4[1];
        System.out.println(p4s.getClass());
        System.out.println(p4s.getClass().getSuperclass());
        System.out.println("-----------------------");

        P4[][] p4s1 = new P4[1][1];
        System.out.println(p4s1.getClass());
        System.out.println(p4s1.getClass().getSuperclass());
        System.out.println("-----------------------");

        int[] ints = new int[1];
        System.out.println(ints.getClass());
        System.out.println(ints.getClass().getSuperclass());
        System.out.println("-----------------------");

        System.out.println(new String[1].getClass().getClassLoader());//根加载器
        System.out.println(ints.getClass().getClassLoader());//原生类型没有加载器
        System.out.println("-----------------------");

        System.out.println(new P4());
    }
}
class P4 {
    static {
        System.out.println("P4 static init");
    }
}

6、接口

父接口：一个接口/类初始化时，并不要求其父接口都完成初始化，只有在真正使用父接口的时候(如引用接口中定义的常量)，才会初始化接口

输出结果：
==========================================================
C5 static init
1
-----------------------
T5 static init
com.hui.classloader.T5@7530d0a
==========================================================


public class Test5 {

    public static void main(String[] args) {
        System.out.println("==========================================================");
        System.out.println(C5.c5);
        System.out.println("-----------------------");
        System.out.println(C5.t5);
        System.out.println("==========================================================");
    }
}

interface P5 {
    // 接口默认就是 public static final
    public static final T5 t5 = new T5();
}

class C5 implements P5 {
    public static int c5 = 1;
    static {
        System.out.println("C5 static init");
    }
}

class T5 {
    static {
        System.out.println("T5 static init");
    }
}

7、初始化顺序

语句是自上而下进行初始化的

输出结果：
i1=2
i2=1
--------------------
2
3

public class Test6 {

    public static void main(String[] args) {
        P6 p = P6.getInstance();
        System.out.println("--------------------");
        System.out.println(P6.i1);
        System.out.println(P6.i2);
    }

}

class P6 {

    public static int i1 = 1;
    private static P6 p6 = new P6();

    private P6(){
        i1++;
        i2++;// p6构造方法在i2初始化语句上方,所以此时i2=0
        System.out.println("i1=" + i1);
        System.out.println("i2=" + i2);
    }

    // i1常量，p6常量初始化后，对i2初始化，i2又被改为2
    public static int i2 = 2;

    public static P6 getInstance() {
        return p6;
    }
}

8. 父亲委托

20.png

9. ClassLoader.loadClass

输出：
class com.hui.classloader.CL
-----------------
CL static
class com.hui.classloader.CL

public class Test12 {
    public static void main(String[] args) throws Exception {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        // ClassLoader.loadClass不会导致类初始化
        Class<?> aClass = loader.loadClass("com.hui.classloader.CL");
        System.out.println(aClass);
        System.out.println("-----------------");
        Class<?> aClass1 = Class.forName("com.hui.classloader.CL");// 导致类初始化
        System.out.println(aClass1);
    }
}
class CL {
    static {
        System.out.println("CL static");
    }
}

10. 获取ClassLoader的途径

获取当前类的ClassLoader
-- clazz.getClassLoader()
获取当前线程的上下文ClassLoader
-- Thread.currentThread().getContextClassLoader()
获取系统的ClassLoader
-- ClassLoader.getSystemClassLoader()
获取调用者的ClassLoader
-- Reflection.getCallerClass().getClassLoader()

11. 卸载

由用户自定义的类加载器所加载的类，是可以被卸载的

12. 命名空间

每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成
在同一个命名空间中，不会出现类的完整名字相同的类
在不同的命名空间中，有可能会出现类的完整名字相同的两个类
1. 子加载器所加载的类能够访问到父加载器所加载的类
1. 父加载器所加载的类无法访问到子加载器所加载的类

13. 类加载器的双亲委托模型的好处

可以确保核心库的类型安全：借助于双亲委托模型，Java核心类库中的类加载工作都是由启动类加载器来统一完成的，从而确保了Java应用所使用的都是同一个版本的Java核心类库，他们之间是相互兼容的
可以确保Java核心类库所提供的类不会被自定义的类所替代
不同的类加载器可以为相同名称的类创建额外的命名空间，相同名称的类可以并存在Java虚拟机中，只需要用不同的类加载器来加载他们即可，不同类加载器所加载的类之间是不兼容的，这就相当于在Java虚拟机内部创建了一个又一个的相互隔离的Java类空间，这类技术在很多框架中都得到了实际应用

14. 自定义类加载器

内建于jvm中的启动类加载器会加载java.lang.ClassLoader以及其他的Java平台类，当jvm启动时，一块特殊的机器码会运行，他会加载扩展类加载器与系统类加载器
启动类加载器并不是Java类，它是特定于平台的机器指令，它负责开启整个加载过程，而其他的加载器则都是Java类，
所有的类加载器(除了启动类加载器)都被实现为Java类，不过总归要有一个组件来加载第一个类加载器，从而让整个加载过程能够顺利进行下去，加载第一个纯Java类加载器就是启动类加载器的职责

public class Test161 extends ClassLoader {

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        File file = new File("/class/" + name);// 加载class目录下的类
        byte[] data = FileUtils.readFileToByteArray(file);
        return this.defineClass(name, data, 0, data.length);
    }
}

public class Test23 {

    public static void main(String[] args) {
        System.out.println(System.getProperty("sun.boot.class.path"));
        System.out.println(System.getProperty("java.ext.dirs"));
        System.out.println(System.getProperty("java.class.path"));

        System.out.println(ClassLoader.class.getClassLoader());
        System.out.println(Launcher.class.getClassLoader());
        System.out.println("-----------------------------");
        System.out.println(System.getProperty("java.system.class.loader"));
        System.out.println(Test23.class.getClassLoader());
        // -Djava.system.class.loader=com.hui.classloader.Test16
        System.out.println("===============================");
        System.out.println(ClassLoader.getSystemClassLoader());

    }
}

15. 当前类加载器

每个类都会使用自己的类加载器(加载自身的类加载器)来去加载所依赖的类，如果ClassX引用了ClassY，那么ClassX的类加载器就会去加载ClassY

16. 线程上下文类加载器

通过 Thread.currentThread().getContextClassLoader() 和 Thread.currentThread().setContextClassLoader(); 获取和设置线程上下文类加载器
如果没有通过setContextClassLoader 进行设置的话，线程将继承父线程的上下文加载器，Java应用的运行时的初始线程上下文加载器是系统类加载器，在线程中运行的代码可以通过该类加载器来加载类和资源

16. SPI

父ClassLoader可以使用当前线程Thread.currentThread().getContextClassLoader()所指定的classLoader加载类，这就改变了父ClassLoader不能使用子ClassLoader或者其他没有直接父子关系的ClassLoader加载的类情况，即改变了父亲委托模型
线程上下文类加载器就是当前线程的Current ClassLoader
在双亲委托模型下，类加载是由下至上的，即下层的类加载器会委托上层进行加载，但是对于SPI来说，有些接口是Java核心库提供的，而Java核心库是由启动类加载器来加载的，而这些接口的实现却来自不同的jar包，Java的启动类加载器是不会加载其他来源的jar包的，这样传统的双亲委托模型就无法满足SPI的要求，而通过给当前线程设置上下文类加载器，就可以由设置的上下文类加载器来实现对于接口实现类的加载
ContextClassLoader的作用就是为了破坏Java的类加载委托机制，
当高层提供统一的接口让底层实现，同时又在高层加载（或实例化）底层类时，就必须通过线程上下文类加载器来帮助高层的ClassLoader找到并加载该类

线程上下文类加载器的一般使用模式（获取 - 使用 - 还原）

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
try {
    Thread.currentThread().setContextClassLoader(target);
    method();
} finally {
    Thread.currentThread().setContextClassLoader(classLoader);
}



public class Test26 {
    public static void main(String[] args) {
        //   点入可以看到使用的线程上下文加载器
        ServiceLoader<Driver> loader = ServiceLoader.load(Driver.class);

        Iterator<Driver> iterator = loader.iterator();
        while (iterator.hasNext()) {
            Driver driver = iterator.next();
            System.out.println("driver:" + driver.getClass() + ", loader:" + driver.getClass().getClassLoader());
        }

        System.out.println("线程上下文加载器：" + Thread.currentThread().getContextClassLoader());
        System.out.println("ServiceLoader：" + ServiceLoader.class.getClassLoader());
    }
}
public class Test27 {
    public static void main(String[] args) throws Exception {
        // 点入可以看到，使用的调用类的加载器即Test27.class.getClassLoader()
        Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection("", "", "");
    }
}