深入理解JVM_类加载1

类加载

基本概念

在Java代码中，类型的加载、连接与初始化过程都是在程序运行期间完成的。
提供了更大的灵活性，增加了更多的可能性。

类加载器深入刨析

Java虚拟机与程序的生命周期
在如下几种情况，Java虚拟机将结束生命周期
- 执行了System.exit()方法。
- 程序正常执行结束。
- 程序正在执行过程中遇到了异常或错误而异常终止。
- 由于操作系统出现错误而导致Java虚拟机进程终止。

类的使用过程

加载：查找并加载类的二进制数据。

就是把二进制形式的java类型读入java虚拟机中
连接:
- 验证：确保被加载类的正确性。
- 准备：为类的静态变量分配内存，并将其初始化为默认值。
  
  为类变量分配内存，设置默认值。但是在到达初始化之前，类变量都没有初始化为真正的初始值。
- 解析：把类中的符号引用转换为直接引用。
  
  解析过程就是在类型的常量池中寻找类、接口、字段和方法的符号引用，把这些符号引用替换成直接引用的过程。
初始化：为类的静态变量赋予正确的初始值。
类实例化:
- 为新的对象分配内存。
- 为实例变量赋默认值。
- 为实例变量赋正确的初始值
- java编译器为它编译的每一个类都至少生成一个实例初始化方法，在java的class文件中，这个实例初始化方法被称为”<init>”。针对源代码中每一个类的构造方法，java编译器都产生一个<init&gt方法。
使用。
卸载。

类的加载、连接与初始化

Java程序对类的使用方式分为两种
- 主动使用
- 被动使用
所有Java虚拟机实现必须在每个类或接口被Java程序”首次主动使用”时才初始化他们。

主动使用(七种)

创建类的实例。
访问某个类或接口的静态变量，或者对该静态变量赋值。
调用类的静态方法。
- 助记符(javap 反编译)：
  - 访问：getstatic
  - 赋值：putstatic
  - 调用：invokestatic
反射(如Class.forName(“com.test.Test”)).
初始化一个类的子类。
Java虚拟机启动时被标明为启动类的类(带有main方法的类)。
JDK1.7开始提供的动态语言支持:
java.lang.invoke.MethodHandle实例的解析结果REF_invokeStatic句柄对应的类没有初始化，则初始化。

被动使用

除了主动使用的七种情况，其它使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化。


import java.util.UUID;

/**
 * -XX:+TraceClassLoading,用于追踪类的加载信息并打印出来
 * -XX:+&lt;option&gt;,表示开启option选项
 * -XX:-&lt;option&gt;,表示关闭option选项
 * -XX:&lt;option&gt;=&lt;value&gt;,表示将option选项的值设置为value
 */
public class Main {

    public static void main(String[] args) {
        //Example 1
        System.out.println(Child.stringParent);
        /*
        输出结果
        Parent static block
        hello world
        对于静态字段来说，只有直接定义了该字段的类才会被初始化。
        */

        //Example 2
        System.out.println(Child.stringChild);
        /*
        输出结果
        Parent static block
        Child static block
        welcome
        初始化一个类的子类时，要求它的父类都已经被初始化完毕。
        */

        //Example 3
        System.out.println(Parent1.stringParent1);
        /*
        输出结果
        hello parent1
        在编译阶段，常量就会被存入到调用这个常量的方法所在的类的常量池当中，
        本质上，调用类并没有直接引用到定义常量的类，因此并不会触发定义常量类
        的初始化。

        注意：这里指的是将常量存放到了Main的常量池中，
        之后Parent1与Main就没有任何关系了，
        甚至可以将Parent1的class文件删除。
        */

        //Example 4
        System.out.println(Parent2.stringParent2);
        /*
        输出结果
        Parent2 static block
        71bd2365-e20c-4d3e-b071-2b56287afadf
        当一个常量的值并非编译期间可以确定的，那么其值就不会被放到调用类的常量池中，
        这时在程序运行时，会导致主动使用这个常量所在的类，显然会导致这个类被初始化。
        */

        //Example 5
        Parent3[] parent3s=new Parent3[1];
        System.out.println(parent3s.getClass());
        System.out.println(parent3s.getClass().getSuperclass());
         /*
        输出结果
        class [LParent3;
        class java.lang.Object
        对于数组实例来说，其类型时有JVM在运行期动态生成的，表示为[LParents3这种形式。
        动态生成的类型，其父类型就是Object
        对于数组来说，JavaDoc经常将构成数组的元素称为Component，实际上就是将数组降低一个维度后的类型。

        ints.getClass()       Class [i
        chars.getClass()      Class [C
        booleans.getClass()   Class [Z
        shorts.getClass()     Class [S
        bytes.getClass()      Class [B
        */

        //Example 6
        Singleton singleton = Singleton.getInstance();
        System.out.println("counter1: " + Singleton.counter1);
        System.out.println("counter2: " + Singleton.counter2);
        System.out.println("counter3: " + Singleton.counter3);
        /*
        输出结果
        Singleon() counter1: 1
        Singleon() counter2: 2
        Singleon() counter3: 1
        counter1: 1
        counter2: 2
        counter3: 0

        准备阶段赋默认值，初始化是从上到下顺序执行。
        */
    }
}

//Example 1
class Parent {
    public static String stringParent = "hello world";

    static {
        System.out.println("Parent static block");
    }
}

//Example 2
class Child extends Parent {
    public static String stringChild = "welcome";

    static {
        System.out.println("Child static block");
    }
}

//Example 3
class Parent1 {
    public static final String stringParent1 = "hello parent1";

    static {
        System.out.println("Parent1 static block");
    }
}

//Example 4
class Parent2 {
    public static final String stringParent2 = UUID.randomUUID().toString();

    static {
        System.out.println("Parent2 static block");
    }
}

//Example 5
class Parent3 {

    static {
        System.out.println("Parent3 static block");
    }
}

//Example 6
class Singleton {

    public static int counter1;

    public static int counter2 = 1;

    private static Singleton singleton = new Singleton();

    private Singleton() {
        counter1++;
        counter2++;
        counter3++;

        System.out.println("Singleon() counter1: " + counter1);
        System.out.println("Singleon() counter2: " + counter2);
        System.out.println("Singleon() counter3: " + counter3);
    }

    public static int counter3 = 0;

    public static Singleton getInstance() {
        return singleton;
    }
}

助记符：

ldc表示将int,flot或是String类型的常量值从常量池中推送至栈顶。
bipush表示将单字节(-128 ~ 127)的常量值推送至栈顶。
sipush表示将一个短整型常量值(-32768 ~ 32767)推送至栈顶。
iconst_1表示将int类型1推送值栈顶(iconst_m1 ~ iconst_5)。
anewarray表示创建一个引用类型的(如类、接口、数组)数组，并将其引用值压入栈顶。
newarray表示创建一个原始类型(如int、float、char等)数组，并将其引用值压入栈顶。

类的加载

类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区中，然后在内存中创建一个java.lang.Class对象(规范并未说明Class对象位于哪里，HotSpot虚拟机将其放在了方法区中)来封装类在方法区内的数据结构。
加载.class文件的方式
- 从本地系统中直接加载。
- 通过网络下载.class文件。
- 从zip，jar等归档文件中加载.class文件。
- 从专有数据库中提取.class文件。
- 将Java源文件动态编译为.class文件。
类的加载的最终产品是位于内存中的Class对象。
Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。

类加载器

类加载器用来把类加载到Java虚拟机中。从JDK1.2版本开始，类的加载过程采用父亲委托机制，这种机制能更好的保证Java平台的安全。在此委托机制中，除了Java虚拟机自带的根类加载器以外，其余的类加载器都有且只有一个父加载器。当Java程序请求加载器loader1加载Sample类时，loader1首先委托自己的父类加载器去加载Sample类，若父加载器能加载，则由父加载器完成加载任务，否则才由加载器loader1本身加载Sample类。

有两种类型的类加载器：
- Java虚拟机自带的类加载器：
  - 根加载器(Bootstrap)。根加载器从系统属性sun.boot.class.path所指定的目录中加载类库。根加载器的实现依赖于底层操作系统，属于虚拟机实现的一部分，并没有基础java.lang.ClassLoader类。
  - 扩展类加载器(Extension)。它的父加载器为根类加载器。它从java.ext.dirs系统属性所指定的目录中加载类库，或者从JDK的安装目录的jre\lib\ext子目录(扩展目录)下加载类库，如果把用户创建的JAR文件放在这个目录下，也会自动由扩展类加载器加载。扩展类加载器是纯Java类，是java.lang.ClassLoader类的子类。
  - 系统(应用)类加载器(System)。它的父加载器为扩展类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中加载类，它是用户自定义的类加载器的默认父加载器。系统类加载器是纯Java类，是java.lang.ClassLoader类的子类。
- 用户自定义的类加载器：
  - java.lang.ClassLoader的子类。
  - 用户可以定制类的加载方式。
类加载器并不需要等到某个类被”首次主动使用”时再加载它。
JVM规范运行类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误(LinkageError错误)。
如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误。
若有一个类加载器能够成功加载Test类，那么这个类加载器被称为定义类加载器，所有能成功返回Class对象引用的类加载器(包括定义类加载器)都被称为初始化类加载器。

类的验证

类被加载后，就进入连接阶段。连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。
类的验证的内容：
- 类文件的结构检查。
- 语义检查。
- 字节码验证。
- 二进制兼容性的验证。

类的准备

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

类的初始化

在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。
在程序中，静态变量的初始化有两种途径：

在静态变量的声明处进行初始化。
在静态代码块中进行初始化。
静态变量的声明语句，以及静态代码块都被看作类的初始化语句，Java虚拟机会按照初始化语句在类文件中的先后顺序来依次执行。

类的初始化步骤：

假如这个类还没有被加载和连接，那就先进行加载和连接。
假如类存在直接父类，并且这个父类还没有被初始化，那就先初始化直接父类。
假如类中存在初始化语句，那就一次执行这些初始化语句。

类的初始化时机：

主动使用(七种)
当Java虚拟机初始化一个类时，要求它所有父类都已经被初始化，但是这条规则不适用于接口。
- 在初始化一个类时，并不会先初始化它所实现的接口。
- 在初始化一个接口时，并不会先初始化它的父接口。
  
  因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。
只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用。
调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

类加载和类初始化深度刨析

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


import java.util.UUID;

public class Main {

    public static void main(String[] args) {
        System.out.println(Child5.c);
        System.out.println(Child4.b);
        System.out.println(Parent4.a);
        /*
        输出结果
        5
        随机0 ~ 3;
        0
        classLoader.Parent4 invoked

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

    }
}

import java.util.Random;

public interface Parent4 {
    public static final int a = new Random().nextInt(4);

    public static final Thread thread = new Thread() {
        {
            System.out.println("classLoader.Parent4 invoked");
        }
    };
}

interface Child4 extends Parent4 {
    public static final int b = new Random().nextInt(4);
}

class Child5 implements Child4 {
    public static int c = 5;
}

如果用子类类名访问父类的静态变量或静态方法，都表示对父类的主动使用，而不是对子类的主动使用。


package classLoader;

public class Test {
    public static void main(String[] args) {
        System.out.println(Child6.a);
        System.out.println("-----------");
        Child6.doSomething();
        /*
        输出结果：
        Parent6 static block
        3
        -----------
        do something

        如果用子类类名访问父类的静态变量或静态方法，
        都表示对父类的主动使用，而不是对子类的主动使用。
        */
    }
}

class Parent6{
    static int a = 3;

    static {
        System.out.println("Parent6 static block");
    }

    static void doSomething(){
        System.out.println("do something");
    }
}

class Child6 extends Parent6{
    static {
        System.out.println("Child6 static block");
    }
}

调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。


package classLoader;

public class Test2 {
    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        Class<?> clazz = classLoader.loadClass("classLoader.CL");
        System.out.println(clazz);
        System.out.println("---------");
        clazz = Class.forName("classLoader.CL");
        System.out.println(clazz);
        /*
        class classLoader.CL
        ---------
        Class CL
        class classLoader.CL

        调用ClassLoader类的loadClass方法加载一个类，
        并不是对类的主动使用，不会导致类的初始化。
        */
    }
}

class CL{
    static {
        System.out.println("Class CL");
    }
}

学习笔记

深入理解JVM_类加载1
Publish: 2020/2/28
JVM
Java

类加载

基本概念

类加载器深入刨析

类的使用过程

类的加载、连接与初始化

主动使用(七种)

被动使用

类的加载

类加载器

类的验证

类的准备

类的初始化

类的初始化步骤：

类的初始化时机：

类加载和类初始化深度刨析

学习笔记

深入理解JVM_类加载1 Publish: 2020/2/28 JVMJava

类加载

基本概念

类加载器深入刨析

类的使用过程

类的加载、连接与初始化

主动使用(七种)

被动使用

类的加载

类加载器

类的验证

类的准备

类的初始化

类的初始化步骤：

类的初始化时机：

类加载和类初始化深度刨析

深入理解JVM_类加载1
Publish: 2020/2/28
JVM
Java