本文详细介绍了JVM虚拟机，包括其概述、JDK、JVM和JRE之间的关系，以及JVM的体系构成，如类加载子系统和运行时数据区。文章通过类加载过程和运行时数据区的分析，揭示了Java跨平台特性的实现，并讨论了JVM的优化策略，如堆内存管理和GC调优。
深入理解Java之JVM虚拟机
JVM概述
JVM（Java Virtual Machine）：指以软件的方式模拟具有完整硬件系统功能、运行在一个完全隔离环境中的完整计算机系统，是物理机的软件实现
Java虚拟机阵营：
- Sun HotSpot VM
- BEA JRockit VM
- IBM J9 VM
- Azul VM
- Apache Harmony
- … …
众所周知 Java 是一门跨平台的语言，它的跨平台性就是通过 JVM 来体现的，运行示意图：
Java文件（源码）通过编译生成 class 文件（字节码），而操作系统并不能识别字节码文件，因为其底层是机器码（0101），因此，JVM 就充当了一个中间件的作用，屏蔽了底层硬件、指令层面的某些细节
JDK、JVM、JRE
JDK、JVM、JRE 这三者的关系也是面试中经常会问的一类问题
网上都会说：JDK 包含 JRE 包含 JVM
以开发的角度简单概况则是：
开发人员写好代码之后，通过编译生成字节码文件，这一步骤叫做编译时期环境，是 JDK 帮我们完成的
而字节码文件装载入 JVM 虚拟机，在不同的操作系统上运行，这一步骤叫做运行时期环境，是 JRE 在起作用
JVM体系构成
JVM 的组织分为三个子系统：
- 类加载子系统
- 运行时数据区
- 执行引擎
类加载子系统
java 源文件编译为字节码文件时，会通过 JAVA 源码编译器进行处理
这一过程中包括：词法分析器、Token流、语法分析器等等，过程如图所示
类加载器需要操作的对象则是经过编译后生成的字节码文件：
类加载器执行过程：
- 类加载：将 class 文件加载到虚拟机的内存
- 加载：在硬盘上查找并通过 IO 读入字节码文件
- 连接：执行校验、准备、解析（可选）步骤
- 校验：校验字节码文件的正确性
- 准备：给类的静态变量分配内存，并赋予默认值
- 解析：类装载器装入类所引用的其他类
- 初始化：对类的静态变量初始化为指定的值，执行静态代码块
class 字节码文件加载原理：
将任意字节码文件打开如下：
每一个字节码文件开头，都会有一个 CA FE BA BE ，这也被称为 Java魔数
一个文件能否被Java虚拟机接受，不是通过文件的扩展名来进行识别的，而是通过魔数来进行识别．这主要是基于安全方面的考虑，因为文件的扩展名可以随意改动．而且在很多文件存储标准中都使用魔数来进行身份识别，例如图片格式．
另外，Java 的 logo 也是一个咖啡杯，这也对应了 java魔数
运行时数据区
JVM 通过 Thread 线程运行我们编写的代码，运行时数据区图如下：
1、程序计数器（线程私有）：是一个指针，指向方法区中的方法字节码（用来储存指向下一条指令的地址，也即将要执行的指令代码），由执行引擎读取下一条指令，是一个非常小的内存空间。
演示 demo 源代码：
public class Test1 {
private String name;
private Object object = new Object();
public int add() {
int a = 1;
int b = 2;
int c = (a + b) * 100;
return c;
}
public static void main(String[] args) {
Test1 test1 = new Test1();
int result = test1.add();
System.out.println(result);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
通过编译后生成字节码文件，将该字节码文件通过 javap 命令进行反汇编
C:\Users\86136>javap
用法: javap <options> <classes>
其中, 可能的选项包括:
-? -h --help -help 输出此帮助消息
-version 版本信息
-v -verbose 输出附加信息
-l 输出行号和本地变量表
-public 仅显示公共类和成员
-protected 显示受保护的/公共类和成员
-package 显示程序包/受保护的/公共类
和成员 (默认)
-p -private 显示所有类和成员
-c 对代码进行反汇编
-s 输出内部类型签名
-sysinfo 显示正在处理的类的
系统信息 (路径, 大小, 日期, MD5 散列)
-constants 显示最终常量
--module <模块>, -m <模块> 指定包含要反汇编的类的模块
--module-path <路径> 指定查找应用程序模块的位置
--system <jdk> 指定查找系统模块的位置
--class-path <路径> 指定查找用户类文件的位置
-classpath <路径> 指定查找用户类文件的位置
-cp <路径> 指定查找用户类文件的位置
-bootclasspath <路径> 覆盖引导类文件的位置
反汇编指令：
javap -c Test1.class >Test1.txt
打开通过反汇编生成的 txt 文件如下：
Compiled from "Test1.java"
public class Test1 {
public Test1();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: new #2 // class java/lang/Object
8: dup
9: invokespecial #1 // Method java/lang/Object."<init>":()V
12: putfield #3 // Field object:Ljava/lang/Object;
15: return
public int add();
Code:
0: iconst_1
1: istore_1
2: iconst_2
3: istore_2
4: iload_1
5: iload_2
6: iadd
7: bipush 100
9: imul
10: istore_3
11: iload_3
12: ireturn
public static void main(java.lang.String[]);
Code:
0: new #4 // class Test1
3: dup
4: invokespecial #5 // Method "<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #6 // Method add:()I
12: istore_2
13: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream;
16: iload_2
17: invokevirtual #8 // Method java/io/PrintStream.println:(I)V
20: ldc2_w #9 // long 100l
23: invokestatic #11 // Method java/lang/Thread.sleep:(J)V
26: goto 34
29: astore_3
30: aload_3
31: invokevirtual #13 // Method java/lang/InterruptedException.printStackTrace:()V
34: return
Exception table:
from to target type
20 26 29 Class java/lang/InterruptedException
}
文件中的内容就是和 JVM 相关的指令，JVM 如何运行程序就是依靠这些指令
且，在每一条指令之前，都会有一个行号，而行号的数字则是程序计数器顺序指向的内容，从而告诉线程如何执行
2、虚拟机栈（线程私有）：java线程执行方法的内存模型，一个线程对应一个栈，线程中的每一个方法在执行的同时都会创建一个栈帧（用于储存局部变量表、操作数栈、动态链接、方法出口等信息），不存在垃圾回收等问题，只要线程一结束该栈就会释放，生命周期和线程一致
即，在 Test1.java 程序中，由于只存在一个主线程，则该线程中的虚拟机栈内容如下：
JVM 执行过程：程序计数器告知线程去执行反编译文件中的 JVM 指令，因此源程序方法中的代码和指令是一一对应的
这里将通过 add() 方法分析 JVM 指令执行流程和栈帧的变化
public int add() { public int add();
int a = 1; Code:
int b = 2; 0: iconst_1
int c = (a + b) * 100; 1: istore_1
return c; 2: iconst_2
} 3: istore_2
4: iload_1
5: iload_2
6: iadd
7: bipush 100
9: imul
10: istore_3
11: iload_3
12: ireturn
0: iconst_1：将 int 类型常量 1 压入栈； 此时，add() 栈帧中的操作数栈会压入常量 1
1: istore_1：将 int 类型值存入局部变量 1； 此时，局部变量表中存入 a
2: iconst_2：将 int 类型常量 2 压入栈； 此时，add() 栈帧中的操作数栈会压入常量 2
3: istore_2：将 int 类型值存入局部变量 2； 此时，局部变量表中存入 a
4: iload_1：从局部变量 1 中装载 int 类型值；
5: iload_2：从局部变量 2 中装载 int 类型值； 此时，a = 1，b = 2
6: iadd：执行 int 类型的加法； 此时，会将操作数栈中的 2 、1 出栈，同时执行加法得到 3，且再将 3 压入操作数栈
7: bipush 100：将一个 8 位带符号整数压入栈；此时，将 100 压入操作数栈
9: imul：执行 int 类型的乘法； 此时，将 100、3 出栈，得到 300压入操作数栈
注：程序计数器此时从 7 直接到了 9，原因是 bipush 本身是单独的指令，即 bipush 占了一位， 100 占了一位
10: istore_3：将 int 类型值存入局部变量 3； 此时，局部变量表中存入 c
11: iload_3：从局部变量 3 中装载 int 类型值； 此时，c = 300
12: ireturn：从方法中返回 int 类型的数据；
问题：递归调用时，会产生 1 个还是 N 个栈帧
验证，如：
package JVM;
public class StackErrorTest {
private static int index = 1;
public void fun() {
index++;
fun();
}
public static void main(String[] args) {
StackErrorTest stackErrorTest = new StackErrorTest();
try {
stackErrorTest.fun();
} catch (Throwable e) {
// TODO: handle exception
System.out.println("Stack deep: " + index);
e.printStackTrace();
}
}
}
此时，运行程序会抛出错误：stackOverflowError：
栈帧的深度为 22898
通过改变运行时参数进行调优，给栈帧分配内存
-Xss1m
通过验证，递归方法由于会有栈溢出错误，因此递归函数会创建 N 个栈帧
3、方法区（线程共享）：类的所有字段和方法字节码，以及一些特殊方法如构造函数，接口代码也在此定义。简单地说，所有定义类的信息都保存在该区域，静态变量、常量、类信息、运行时常量池都存在方法区中。
即以下内容等都是存储在方法区中
public class Test1
private String name;
private Object object = new Object();
4、本地方法栈：登记 native 方法，在 Execution Engine 执行时加载本地方法库
因为 Java 语言底层是用 C 语言写的
因此某一写方法会通过 JNI（Java Native Interface）调用底层的 C 的代码
如 Test1.java 程序中的如下：
try {
Thread.sleep(100);
}
发现并不能够查看 sleep() 方法的源码
public static native void sleep(long millis) throws InterruptedException;
5、堆（线程共享）：虚拟机在启动时创建，用于存放对象实例，几乎所有的对象（包含常量池）都在堆上分配内存，当对象无法在该空间申请到内存时将抛出 OutOfMemoryError，同时也是垃圾收集器管理的主要区域。同时，JVM 调优所指的调优的对象也是堆。可以使用 -Xmx 和 -Xms 设置最小堆和最大堆
堆结构示意图
Java堆的内存划分如图所示，分别为年轻代、Old Memory（老年代）、Perm（永久代）。其中在Jdk1.8中，永久代被移除，使用MetaSpace代替。
代码演示堆监控
package JVM;
import java.util.ArrayList;
import java.util.List;
public class HeapTest {
public static void main(String[] args) {
List<byte[]> list = new ArrayList<byte[]>();
int i = 0;
boolean flag = true;
while(flag) {
try {
i++;
list.add(new byte[1024*1024]); //每次增加1M大小的数组对象
Thread.sleep(30);
} catch (Throwable e) {
// TODO: handle exception
e.printStackTrace();
flag = false;
System.out.println("Count = " + i); //记录运行次数
}
}
}
}
运行代码，同时打开 jconsole
C:\Users\86136>jconsole
JVM 的优化：
- 当survivor区不够大或者占用量达到50%，就会把一些对象放到老年区。通过设置合理的eden区，survivor区及使用率，可以将年轻对象保存在年轻代，从而避免full GC。
- 对于占用内存比较多的大对象，一般会选择在老年代分配内存。通过设置参数：
-XX:PetenureSizeThreshold=1000000，标明对象大小超过1M时，在老年代(tenured)分配内存空间 - 一般情况下，年轻对象放在eden区，当第一次GC后，如果对象还存活，放到survivor区，此后，每GC一次，年龄增加1，当对象的年龄达到阈值，就被放到tenured老年区。
- 设置最小堆和最大堆：系统在运行时堆大小理论上是恒定的，稳定的堆空间可以减少GC次数，因此，很多服务端都会将 -Xmx 和 -Xms 这两个参数设置为一样的数值。稳定的堆大小虽然减少GC次数，但是增加每次GC的时间，因为每次GC要把堆的大小维持在一个区间内。
- 尝试使用大的内存分页：使用大的内存分页增加CPU的内存寻址能力，从而系统的性能。
- … …
时间：2019.6.25 13：57
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
