JVM第一天学习之类加载

类加载模型图

class类被类加载器加载解析后，会生成Klcass实例。类的信息，常量池等就是存储在Klass的中的

普通的类会生成instanceKlass实例，而instanceKlass又分有三个子类

暂时不是很懂
1.instanceMirrorKlass：学名叫镜像类，存在堆中，是instanceKlass的class对象
2.InstanceRefKlass：用于表示java/lang/ref/Reference类的子类
3.InstanceClassLoaderKlass：用于遍历某个加载器加载的类

java中的数组不是静态数据，它是在运行期动态生成的。数组的元数据是用ArrayKlass存储的

1.TypeArrayKlass：存储基本类型的数组
2.ObjArrayKlass：存储对象实例的数组 	

类的加载过程

类的生命周期有七个步骤，而类的加载是前五个

加载

1、通过类的全限定名获取存储该类的class文件（没有指明必须从哪获取）
2、解析成运行时数据，即instanceKlass实例，存放在方法区
3、在堆区生成该类的Class对象，即instanceMirrorKlass实例

何时加载？

1.主动使用时
1.new、getstatic、putstatic、invokestatic
2.反射
3.执行子类，父类会先加载。(使用父类，不一定会加载子类，如果没有用到子类，就不会去加载子类！！！)
4.启动类
5.当使用jdk1.7动态语言支持时，如果一java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄,并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化(基本不会用到)
2.预加载：Thread、String等

---

因为没有指明必须从哪获取class文件，脑洞大开的工程师们开发了这些
1、从压缩包中读取，如jar、war
2、从网络中获取，如Web Applet
3、动态生成，如动态代理、CGLIB
4、由其他文件生成，如JSP
5、从数据库读取
6、从加密文件中读取

验证

1、文件格式验证
2、元数据验证
3、字节码验证
4、符号引用验证

---

准备

为静态变量分配内存、赋初值
实例变量是在创建对象的时候完成赋值的，没有赋初值一说
如果被final修饰，在编译的时候会给属性添加ConstantValue属性，准备阶段直接完成赋值，即没有赋初值这一步

---

解析

将常量池的符号引用转为直接(内存地址)引用
解析后的信息存储在ConstantPoolCache类实例中

1、类或接口的解析
2、字段解析
3、方法解析
4、接口方法解析

何时解析？

思路：
1、加载阶段解析常量池时
2、用的时候

openjdk是第二种思路，在执行特定的字节码指令之前进行解析：
anewarray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invokespecial、invokestatic、invokevirtual、ldc、ldc_w、ldc2_w、multianewarray、new、putfield

---

初始化

1、执行静态代码块，完成静态属性的赋值

静态字段、静态代码段，字节码层面会生成clinit方法
方法中语句的先后顺序与代码的编写顺序相关

静态字段现在是保存在instanceMirrorKlass中的，而instanceMirrorKlass是保存在堆中的。jdk1.6之前是保存在方法区的

---

案例分析

public class Test_1 {
    public static void main(String[] args) {
        System.out.printf(Test_1_B.str);
    }
}

class Test_1_A {
    public static String str = "A str";

    static {
        System.out.println("A Static Block");
    }
}

class Test_1_B extends Test_1_A {
    static {
        System.out.println("B Static Block");
    }
}

结果：A Static Block 、A str
为什么：因为java类只有在使用的时候加载，调用str跟B类没有关系，所以不会加载B类。

public class Test_2 {

    public static void main(String[] args) {
        System.out.printf(Test_2_B.str);
    }
}

class Test_2_A {
    static {
        System.out.println("A Static Block");
    }
}

class Test_2_B extends Test_2_A {
    public static String str = "B str";

    static {
        System.out.println("B Static Block");
    }
}

结果: A Static Block 、 B Static Block 、 B str
为什么：因为初始化子类默认会加载父类

public class Test_3 {
    public static void main(String[] args) {
        System.out.printf(Test_3_B.str);
    }
}
class Test_3_A {
    public static String str = "A str";
    static {
        System.out.println("A Static Block");
    }
}
class Test_3_B extends Test_3_A {
    static {
        str = "B str";
        System.out.println("B Static Block");
    }
}

结果：A Static Block 、 A str
为什么：还是因为使用的时候才会加载类。Test_3_B.str在加载的时候在父类找到了这个属性，就不需要去初始化Test_3_Bl ,赋值操作是在初始化的时候才会进行

public class Test_4 {

    public static void main(String[] args) {
        Test_4 arrs[] = new Test_4[1];
    }
}

class Test_4_A {
    static {
        System.out.println("Test_4_A Static Block");
    }
}

结果：无
为什么：数组是动态生成的，是用ObjArrayKlass存储的，是去new ObjArrayKlass对象不是去实例化对象。

public class Test_6 {

    public static void main(String[] args) {
        System.out.println(Test_6_A.str);
    }
}

class Test_6_A {
    public static final String str = "A Str";

    static {
        System.out.println("Test_6_A Static Block");
    }
}

结果：A str(看到这个结果，很惊讶，是因为我看漏了final)
为什么：因为final修饰的属性在准备阶段就进行了赋值操作，就不会在执行初始化了。(我试了下再加一个静态属性，还是不会执行静态块)

public class Test_8 {

    static {
        System.out.println("Test_8 Static Block");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> clazz = Class.forName("com.luban.ziya.classload.Test_1");
    }
}

结果：Test_8 Static Block
为什么：因为在使用反射的时候会加载本类

public class Test_21 {
    public static void main(String[] args) {
        Test_21_A obj = Test_21_A.getInstance();
        System.out.println(Test_21_A.val1);
        System.out.println(Test_21_A.val2);
    }
}

class Test_21_A {
    public static int val1;
    public static int val2 = 1;

    public static Test_21_A instance = new Test_21_A();
     Test_21_A() {
        val1++;
        val2++;
    }
    public static Test_21_A getInstance() {
        return instance;
    }
}

结果：1，2
为什么：执行getInstance()方法时，会实例化A类，从而在准备阶段从上往下执行赋初值操作val1=0,val2=0，在初始化的时候也是这样赋值val1 =0,val2=1.再执行静态块，所以变成了1，2

public class Test_22 {

    public static void main(String[] args) {
        Test_22_A obj = Test_22_A.getInstance();

        System.out.println(Test_22_A.val1);
        System.out.println(Test_22_A.val2);
    }
}

class Test_22_A {
    public static int val1;

    public static Test_22_A instance = new Test_22_A();

     Test_22_A() {
        val1++;
        val2++;
    }

    public static int val2 = 1;

    public static Test_22_A getInstance() {
        return instance;
    }
}

结果：1，1
为什么：因为执行getInstance()方法时，会实例化A类，从而在准备阶段从上往下执行赋初值操作val1=0,val2=0(所以它没有报错，可能很多人觉得会报错)，在初始化的时候也是这样顺序赋值val1 =0,val2=0。再执行静态块的时候val2还是0，所以结果变成了1，1.后面的val2=1就又覆盖了val2。大家可以把静态块的val2值随便改，但是结果还是1,1