深入理解JVM（一）类加载器部分、类变量、常量、jvm参数

类加载概述

1. 在java代码中，类型的加载、连接与初始化过程都是在程序运行期间完成的

类型：class、interface（object本身）、类型可在运行期间生成，如动态代理。一种runting概念

加载：最常见的方式是将已经存在的类的字节码文件（.class文件）从磁盘上加载到内存中；

连接：将类与类之间的关系确立下来，对于字节码的一些相关处理、校验在连接阶段完成

初始化：对于一些静态的变量进行复制

过程不是一定按照上述顺序，按照规范即可

1. 提供了更大的灵活性，增加了更多的可能性

本身是静态类型的语言，但是很多特点又使得java具有动态的特点

类加载器深入剖析

• Java虚拟机与程序生命周期： 在下面的情况下,Java虚拟机将结束生命周期

执行了System.exit()方法

程序正常结束

程序在执行过程中遇到了异常或者错误而异常终止

由于操作系统出现错误而导致Java虚拟机进程终止

类的加载、连接、初始化进一步介绍

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

class文件（不一定是文件 也许来源网络 数据库等） 加载进内存

• 连接
• • 验证：确保被加载的类的正确性
• • 准备：为类的静态变量分配内存，并将其初始化为默认值。

此时类的实例对象还没创建

//假设代码中有
class Test{
    public static int a = 1;
}
//在准备这个阶段，虚拟机在准备阶段不会将1赋值给a,它会为a分配内存并且把0赋值给a

• • 解析：把类中的符号引用转换为直接引用

符号引用：间接的引用方式

直接引用：直接将引用的对象指向内存中的位置

• 初始化：为类的静态变量赋予正确的初始化值

//假设代码中有
class Test{
    public static int a = 1;
}
//在准备阶段，虚拟机在准备阶段不会将1赋值给a,它会为a分配内存并且把0赋值给a
//在初始化阶段，将a=0替换为a=1

类的使用与卸载

• 类的使用

创建对象、使用方法

• 类的卸载

从内存中销毁，osgi

---

类加载

主动使用与被动使用

所有的java虚拟机实现 必须在每个类或接口被java程序“首次主动使用”时才初始化它们

• java程序类的使用方式分为两种

1. 主动使用（七种）

• 创建类的实例

• 访问某个类或接口的静态变量，或者对该静态变量赋值（助记符：getstatic,putstatic）

• 调用类的静态方法(助记符：invokestatic)

• 反射（如Calss.forName("com.test.Test")）

• 初始化一个类的子类

初始化一个类的时候，如果该类有父类，也会对父类进行初始化，如果父类也有父类，也会往上进行初始化

• Java虚拟机启动时被标记为启动类的类（Java Test）

• JDK1.7开始提供的动态语言支持

java.lang.invoke.MethodHandle实例的解析结果 REF_getStatic, REF_putStatic,REF_invokeStatic句柄对应的类没有初始化，则初始化

1. 被动使用

• 除了上述其中情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化

被动使用也许会加载这个类，只是不进行初始化

类的加载

• 类的加载

类的加载是指将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在内存中创建一个java.lang.Class对象（规范并未说明Class对象位于哪里，HotSpot虚拟机将其放在方法区内）用来封装类在方法区内的数据结构

加载.class文件的方式

1. 从本地文件系统中直接加载（最常用）
2. 通过网络下载.class文件
3. 从zip,jar等归档问价那种加载.calss文件
4. 从专有的数据库中提取.calss文件
5. 将Java源文件动态编译为.calss文件（动态代理，运行期创建，web开发会用到）

---

举例

eg1：
public class MyTest {
    public static void main(String[] args) {
        System.out.println(MyChild1.str1);
    }
}
class MyParent1 {
    public static String str1 = "hello world str1";
    static {
        System.out.println("MyParent1 static block");
    }
}
class MyChild1 extends MyParent1 {
    public static String str2 = "hello world str2";
    static {
        System.out.println("MyChiled1 static block");
    }
}
//输出结果：
MyParent1 static block
hello world str1

对于静态字段来说，只有直接定义了该字段的类才会被初始化。所以在本例中，直接使用的是MyParent1的str1，所以会对MyParent1进行初始化，不会对MyChild1进行初始化，对MyParent1是主动使用。

符合上述所有的java虚拟机实现必须在每个类或接口被java程序“首次主动使用”时才初始化它们

 eg2：
public class MyTest {
    public static void main(String[] args) {
        System.out.println(MyChild1.str2);
    }
}
class MyParent1 {
    public static String str1 = "hello world str1";
    static {
        System.out.println("MyParent1 static block");
    }
}
class MyChild1 extends MyParent1 {
    public static String str2 = "hello world str2";
    static {
        System.out.println("MyChiled1 static block");
    }
}
//输出结果：
MyParent1 static block
MyChiled1 static block
hello world str2

初始化一个子类时，要求其父类全部已经初始化，在本例中，直接使用的是MyChild1的str2，所以会对MyChild1进行初始化，但是由上述的主动使用中初始化一个类的子类可知，对于父类也会进行初始化。(每个类只会被初始化一次)

所以本例中会先初始化MyParent1在初始化MyChild1，最后再执行输出MyChild1.str2操作

eg3：
//执行主类的 VM arguments 中 添加 -XX:+TraceClassLoading
//打印类加载信息
public class MyTest {
    public static void main(String[] args) {
        System.out.println(MyChild1.str1);
    }
}
class MyParent1 {
    public static String str1 = "hello world str1";
    static {
        System.out.println("MyParent1 static block");
    }
}
class MyChild1 extends MyParent1 {
    public static String str2 = "hello world str2";
    static {
        System.out.println("MyChiled1 static block");
    }
}
//输出结果
[Loaded java.lang.Object from shared objects file]
[Loaded java.io.Serializable from shared objects file]
...
[Loaded java.security.UnresolvedPermission from shared objects file]
[Loaded java.security.BasicPermissionCollection from shared objects file]
[Loaded cn.lillcol.classloader.MyTest from file:/E:/lteworkspace/gaSvr/target/classes/]
[Loaded sun.launcher.LauncherHelper$FXHelper from shared objects file]
[Loaded java.lang.Class$MethodArray from shared objects file]
[Loaded java.lang.Void from shared objects file]
[Loaded cn.lillcol.classloader.MyParent1 from file:/E:/lteworkspace/gaSvr/target/classes/]
[Loaded cn.lillcol.classloader.MyChild1 from file:/E:/lteworkspace/gaSvr/target/classes/]
MyParent1 static block
hello world str1
[Loaded java.lang.Shutdown from shared objects file]
[Loaded java.lang.Shutdown$Lock from shared objects file]

加载的第一个类是java.lang.Object，它是所有类的父类

虽然 MyChild1 没有初始化，但是虚拟机还是加载了MyChild1

与我们编写的相关类加载顺序MyTest、MyParent1、MyChild1，其中MyTest类为Java虚拟机启动时被标记为启动类的类

eg4:
public class MyTest {
    static {
        System.out.println("MyTest static block");
    }
    public static void main(String[] args) {
        System.out.println(MyChild1.str1);
    }
}
class MyParent1 {
    public static String str1 = "hello world str1";
    static {
        System.out.println("MyParent1 static block");
    }
}
class MyChild1 extends MyParent1 {
    public static String str2 = "hello world str2";
    static {
        System.out.println("MyChiled1 static block");
    }
}
//输出结果：
[Loaded cn.lillcol.classloader.MyTest from file:/E:/lteworkspace/gaSvr/target/classes/]
[Loaded sun.launcher.LauncherHelper$FXHelper from shared objects file]
[Loaded java.lang.Class$MethodArray from shared objects file]
[Loaded java.lang.Void from shared objects file]
MyTest static block
[Loaded cn.lillcol.classloader.MyParent1 from file:/E:/lteworkspace/gaSvr/target/classes/]
[Loaded cn.lillcol.classloader.MyChild1 from file:/E:/lteworkspace/gaSvr/target/classes/]
MyParent1 static block
hello world str1
[Loaded java.lang.Shutdown from shared objects file]
[Loaded java.lang.Shutdown$Lock from shared objects file]

MyTest 加载顺序在MyParent1、MyChild1之前，为Java虚拟机启动时被标记为启动类的类

eg5：
public class MyTest2 {
    public static void main(String[] args) {
        System.out.println(MyParent2.str2);
    }
}
class MyParent2 {
    public static final String str2 = "hello world";
    static {
        System.out.println("MyParent2 static block");
    }
}
//输出结果
hello world

常量在编译阶段，会被存入到调用这个常量的方法所在的类的常量池中.

本质上，调用类并没有直接引用到定义常量的类，因此并不会触发定义常量的类的初始化

注意：这里指的是将常量str2存放到MyTest2的常量池中，之后MyTest2与MyParent2就没有任何关系了，甚至此时将MyParent2的.class文件删除也没有关系

eg6:
public class MyTest3 {
    public static void main(String[] args) {
        System.out.println(MyParent3.str3);
    }
}
class MyParent3{
    public static final String str3= UUID.randomUUID().toString();
    static {
        System.out.println("MyParent3 static block ");
    }
}
//输出结果:
MyParent3 static block
62322324-7b63-49c8-a8c4-f6607421f7ff

如果一个常量值不是在编译期间可以确定，那么其值就不会放到调用类的常量池中

这时在运行程序的时候，会导致主动使用这个常量所在的类，显然会导致这个类被初始化

eg7:在终端下用 javap -c 命令反编译MyTest2的.calss文件
javap -c MyTest2
#输出结果
Compiled from "MyTest2.java"
public class cn.lillcol.classloader.MyTest2 {
  public cn.lillcol.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #22                 // String hello world
       5: invokevirtual #24                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

助记符：ldc 表示将int、float或是String类型的常量值从常量池中推送至栈顶

eg8:将代码作如下修改
public class MyTest2 {
    public static void main(String[] args) {
        System.out.println(MyParent2.s);
    }
}
class MyParent2 {
    public static final String str2 = "hello world";
    public static final short s = 7;
    static {
        System.out.println("MyParent2 static block");
    }
}
//输出：
7
//反编译结果：
Compiled from "MyTest2.java"
public class cn.lillcol.classloader.MyTest2 {
  public cn.lillcol.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: bipush        7
       5: invokevirtual #22                 // Method java/io/PrintStream.println:(I)V
       8: return
}

助记符：bipush 表示将单字节（-128 - 127）的常量值从常量池中推送至栈顶

 eg9:将代码作如下修改
public class MyTest2 {
    public static void main(String[] args) {
        System.out.println(MyParent2.i);
    }
}
class MyParent2 {
    public static final String str2 = "hello world";
    public static final short s = 7;
    public static final int i = 128;
    static {
        System.out.println("MyParent2 static block");
    }
}
//输出：
128
//反编译结果：
Compiled from "MyTest2.java"
public class cn.lillcol.classloader.MyTest2 {
  public cn.lillcol.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: sipush        128
       6: invokevirtual #22                 // Method java/io/PrintStream.println:(I)V
       9: return
}

助记符：sipush 表示将单字节（-32768 - 32767）的常量值从常量池中推送至栈顶

eg10:将代码作如下修改
public class MyTest2 {
    public static void main(String[] args) {
        System.out.println(MyParent2.m);
    }
}
class MyParent2 {
    public static final String str2 = "hello world";
    public static final short s = 7;
    public static final int i = 128;
    public static final int m = 0;
    static {
        System.out.println("MyParent2 static block");
    }
}
//输出：
0
//反编译结果：
Compiled from "MyTest2.java"
public class cn.lillcol.classloader.MyTest2 {
  public cn.lillcol.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: iconst_0
       4: invokevirtual #22                 // Method java/io/PrintStream.println:(I)V
       7: return
}

助记符：iconst_0 表示将int类型1从常量池中推送至栈顶（iconst_m1 - iconst_5）

助记符存储的位置：jdk的rt.jar中

eg11:
public class MyTest4 {
    public static void main(String[] args) {
        MyParent4[] myTest4s = new MyParent4[1];
        System.out.println(myTest4s.getClass());
        MyParent4[][] myTest4s1 = new MyParent4[1][1];
        System.out.println(myTest4s1.getClass());
        System.out.println(myTest4s.getClass().getSuperclass());
        System.out.println(myTest4s1.getClass().getSuperclass());
        int[] ints=new int[1];
        System.out.println(ints.getClass());
        System.out.println(ints.getClass().getSuperclass());
    }
}
class MyParent4{
    static {
        System.out.println("MyParent4 static block");
    }
}
//输出：
class [Lcom.aaa.test.MyParent4;
class [[Lcom.aaa.test.MyParent4;
class java.lang.Object
class java.lang.Object
class [I
class java.lang.Object

对于数组实例来说，其类型是由JVM在运行期间动态生成的，表示为class [Lcom.aaa.test.MyParent4;这种形式，动态生成的类型其父类是java.lang.Object。

对于数组来说，JavaDoc经常将构成数组的元素称为Component,实际上就是将数组降低一个维度后的类型。

eg12：
        int[] ints=new int[1];
        System.out.println(ints.getClass());
        short[] showts=new short[1];
        System.out.println(showts.getClass());
        boolean[] booleans=new boolean[1];
        System.out.println(booleans.getClass());
        char[] chars=new char[1];
        System.out.println(chars.getClass());
        byte[] bytes=new byte[1];
        System.out.println(bytes.getClass());
        float[] floats=new float[1];
        System.out.println(floats.getClass());
        double[] doubles=new double[1];
        System.out.println(doubles.getClass());
//输出：
class [I
class [S
class [Z
class [C
class [B
class [F
class [D

助记符：

anewarray: 表示创建一个引用类型（如类、接口、数组）数组，并将其引用值压入栈顶

ewarray:表示创建一个指定的原始类型（如int、float、char等）的数组，并将其引用值压入栈顶

JVM参数

-XX:+<option>,表示开启option选项
-XX:-<option>,表示关闭option选项
-XX:<option>=<value>,表示将option选项的值设置value

+、-是因为有些参数默认开启或者关闭

本文为学习张龙老师深入理解JVM的笔记与心得，转载请注明出处！！！