《深入解析Java虚拟机:从JVM体系结构到垃圾回收算法》

文章目录

- JVM体系结构
- - JVM的组成
- [类加载器Class Loader](#类加载器Class Loader)
- - 类加载器的作用
  - - 双亲委派机制
    - - JVM自带三个类加载器
      - [Bootstrap ClassLoader-根加载器](#Bootstrap ClassLoader-根加载器)
        
        ExtClassLoader-扩展加载器
        
        AppClassLoader-应用类加载器
- Java历史-沙箱安全机制
- - 沙箱概念
  - 沙箱的作用
  - 本地代码和远程代码
  - 沙箱安全机制模型
  - - [JDK1 .0安全模型](#JDK1 .0安全模型)
    - [JDK1 .1安全模型](#JDK1 .1安全模型)
    - [JDK1 .2安全模型](#JDK1 .2安全模型)
    - 目前最新的安全模型
  - 沙箱安全机制的基本组件
  - - [字节码校验器(bytecode verifier)](#字节码校验器(bytecode verifier))
    - [类装载器(class loader)](#类装载器(class loader))
    - [存取控制器(access controller)](#存取控制器(access controller))
    - [安全管理器(security manager)](#安全管理器(security manager))
    - [安全软件包(security package) :](#安全软件包(security package) :)
- Native与方法区
- - Native
  - 方法区
- 深入理解栈
- HotSpot和堆
- - 堆
- 新生区、老年区、永久区
- 堆内存调优
- - 报OOM怎么办？
  - - 使用Jprofiler工具分析OOM原因
- imgGC：垃圾回收

来看一下常见的JVM面试题：

请你谈谈对JVM的理解？java8虚拟机和之前的变化更新？
什么是OOM，什么是栈溢出StackOverFlowError？怎么分析？
JVM的常用调优参数有哪些？
内存快照如何抓取，怎么分析Dump文件？
谈谈你对JVM中类加载器的认识？

如果回答不了上面的题目，那就开始接下来的学习JVM之路把~

JVM体系结构

Java程序是跑在我们的JVM虚拟机上的，而虚拟机又在操作系统之上。

下面的图要自己动手画一遍！

需要知道，操作系统是在硬件之上的。

栈这个区域是不会有垃圾的：

垃圾都在堆区，而方法区又是特殊堆：

jvm调优：99%都是在方法区和堆，大部分时间调堆。

JVM的组成

通过上图，我们已知JVM由三部分组成：

类加载子系统
运行时数据区
执行引擎

类加载器Class Loader

类加载器的作用

类加载器的作用是把类（class）装在进内存里。

java 复制代码

package com.linghu;

/**
 * @author linghu
 * @date 2024/1/19 16:57
 */
public class Car {
    public static void main(String[] args) {
        //类是模板，对象是具体的
        Car car1 = new Car();
        Car car2 = new Car();
        Car car3 = new Car();

        System.out.println("======对象=======");
        System.out.println(car1.hashCode());
        System.out.println(car2.hashCode());
        System.out.println(car3.hashCode());

        //这就是类的模板
        Class<? extends Car> aClass1 = car1.getClass();
        Class<? extends Car> aClass2 = car1.getClass();
        Class<? extends Car> aClass3 = car1.getClass();
        System.out.println("======类模板=======");
        System.out.println(aClass1.hashCode());
        System.out.println(aClass2.hashCode());
        System.out.println(aClass3.hashCode());
    }
}

分析如上代码和下图，可知：

类加载器Class Loader将类Car加载初始化成类模板 。也就是上面的aClass1、aClass2、aClass3 就是类模板，这三个都是同一个类模板！

我们输出类模板的hash：

类模板的作用就是，类模板可以为我们的类实例化对象 ，也就是创建对象 ！我们上面的代码已经创建了三个对象：car1、car2、car3。

我们输出三个对象的hash：

同样，我们也可以通过类模板调用getClassLoader()得到类加载器，从而获取类的名字，这就是Java反射！

双亲委派机制

首先需要知道的是ClassLoader的作用就是将class文件加载到jvm虚拟机中去，JVM就可以正确运行了。但是，jvm启动的时候，并不会一次性加载所有的class文件，而是根据需要去动态加载。

类加载器在加载类的时候，优先委托给上级类加载器，其委托方向如为 AppClassLoader -> ExtClassLoader -> BootStrap

JVM自带的有三个类加载器：

JVM自带三个类加载器

Bootstrap ClassLoader-根加载器

最顶层的加载类。加载目录jre/lib/rt.jar里所有的class。

ExtClassLoader-扩展加载器

扩展的类加载器，加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。

AppClassLoader-应用类加载器

加载当前应用的classpath的所有类。也就是我们自己定义的class。

初始化顺序： Bootstrap ClassLoader->ExtClassLoader(加载路径：java.ext.dirs)->AppClassLoader(加载路径：java.class.path) 。

java 复制代码

package com.linghu;

/**
 * @author linghu
 * @date 2024/1/19 16:57
 */
public class Car {
    public static void main(String[] args) {
        //类是模板，对象是具体的
        Car car1 = new Car();
        Car car2 = new Car();
        Car car3 = new Car();

//        System.out.println("======对象=======");
//        System.out.println(car1.hashCode());
//        System.out.println(car2.hashCode());
//        System.out.println(car3.hashCode());

        //这就是类的模板
        Class<? extends Car> aClass1 = car1.getClass();
//        Class<? extends Car> aClass2 = car1.getClass();
//        Class<? extends Car> aClass3 = car1.getClass();
        ClassLoader classLoader = aClass1.getClassLoader();
        System.out.println(classLoader);//AppClassLoader
        System.out.println(classLoader.getParent());//ExtClassLoader-->\jre\lib\ext
        System.out.println(classLoader.getParent().getParent());//null,1、不存在

    }
}

总结：双亲委派保证类加载器，自下而上的委派，又自上而下的加载，保证每一个类在各个类加载器中都是同一个类。一个非常明显的目的就是保证java官方的类库<JAVA_HOME>\lib和扩展类库<JAVA_HOME>\lib\ext的加载安全性，不会被开发者覆盖。

Java历史-沙箱安全机制

沙箱概念

Java安全模型的核心就是Java沙箱(sandbox)。沙箱机制就是将Java代码限定只能在虚JVM虚拟机中特定的运行范围，并且严格限制代码对本地系统资源访问，通过这样的方式来保证对Java代码的有效隔离，防止对本地操作系统造成破坏。

其实Windows也有这个沙箱的概念，像个内置虚拟机。

沙箱的作用

主要限制系统资源（CPU、内存、文件系统、网络）的访问。

不同级别的沙箱对系统资源访问的限制也有差异。

本地代码和远程代码

Java的执行程序分为：本地代码和远程代码。，

本地代码：默认视为可信任的，可以访问一切本地资源。

远程代码：被看作是不受信的。对于授信的本地代码，对于非授信的远程代码在早期的Java实现中,安全依赖于沙箱(Sandbox)机制。

沙箱安全机制模型

JDK1 .0安全模型

JDK1 .0安全模型本地代码可以访问系统资源，远程代码无法访问系统资源，比如用户希望远程代码访问本地系统的文件时候，就无法实现。

JDK1 .1安全模型

JDK1 .1 安全模型版本中，针对安全机制做了改进，增加了受信任安全策略，允许用户指定代码对本地资源的访问权限

JDK1 .2安全模型

JDK1 .2安全模型改进了安全机制，增加了代码签名。不论本地代码或是远程代码，统一按照用户的安全策略设定，由类加载器加载到虚拟机中权限不同的运行空间，从而来实现差异化的代码执行权限控制。

目前最新的安全模型

目前最新的安全模型引入了域 (Domain) 的概念。JVM虚拟机会把所有代码加载到不同的系统域和应用域，系统域部分专门负责与关键资源系统进行交互，而每个应用域部分则通过系统域的部分代理来对各种需要的资源进行精细划分然后可以进行访问。JVM虚拟机中不同的受保护域 (Protected Domain)对应不一样的权限 (Permission)。存在于不同域中的类文件就拥有了它所包含应用域所有可访问资源之和。

沙箱安全机制的基本组件

字节码校验器(bytecode verifier)

确保lava类文件遵循lava语言规范。这样可以帮助Java程序实现内存保护。但并不是所有的类文件都会经过字节码校验，比如核心类。

类装载器(class loader)

防止恶意代码去干涉善意的代码，比如：双亲委派机制
守护了被信任的类库边界;
将代码归入保护域，确定了代码的权限范围可以进行哪些资源操作

存取控制器(access controller)

存取控制器可以控制核心API对操作系统的存取权限，用户可以设定控制策略。

安全管理器(security manager)

安全管理器主要是核心API和操作系统之间的主要接口。比如实现权限控制，比存取控制器优先级高。

安全软件包(security package) :

java.security下的类和扩展包下的类，允许用户为应用增加所需要安全特性：安全提供者、消息摘要、数字签名keytools、加密、鉴别。

Native与方法区

Native

java 复制代码

package com.linghu;

/**
 * @author linghu
 * @date 2024/1/23 9:53
 */
public class Demo {
    public static void main(String[] args) {
        new Thread(()->{

        },"myThread").start();
    }

    private native void start0();
}

通过以上代码，可以看到有一个 start0方法。该方法用 native来进行修饰。有以下含义：

凡事有 native修饰的，说明Java作用范围达不到了。回去调用C语言的库了~
会进入本地方法栈
调用本地方法接口JNI

java 复制代码

private native void start0();

JNI作用：扩展Java的使用，融合不同的编程语言为Java所用！

Java诞生的时候，正是C和C++大行其道的时候，为了能够在市场上存活，Java在内存中单独开了一个标记区本地方法栈 Native Method Stack，登记Native方法，在最终执行的时候，加载本地方法库中的方法通过JNI。

Java程序驱动打印机、管理系统等等都需要用到这个Native。在企业级应用中较为少见！

方法区

Method Area 方法区。

方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义简单说，所有定义的方法的信息都保存在该区域,此区域属于共享区间;

静态变量、常量、类信息 (构造方法、接口定义)、运行时的常量池 存在方法区中，但是 实例变量 存在堆内存中，和方法区无关
static, final，Class，常量池

深入理解栈

栈：又叫栈内存。主管程序的运行和生命周期、线程同步。

线程结束，栈内存也就释放了。对于栈来说，不存在垃圾回收的说法、一旦线程结束，栈就Over！

栈内存中有：8大基本类型+对象引用+实例的方法。

关于main方法的调用

为什么main先执行，最后结束？

我们调用一个main方法，在main里调用test()，在test()调用a()方法，会出现内存溢出的问题，这个问题用栈表示：

test和a方法循环调用对方，最后会出现栈溢出的问题，也就是内存的问题，因为这个调用是没有限制的，无限循环！

栈运行的原理

栈帧

一个方法对应一个栈帧！其实这个可以理解成一个FCB！下面是两个栈帧！

栈帧(Stack Frame)是用于支持虚拟机进行方法调用和方法执行的数据结构。栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。每一个方法从调用至执行完成的过程，都对应着一个栈帧在虚拟机栈里从入栈到出栈的过程。

HotSpot和堆

我们通过 java -version命令查看：

我们用的虚拟机一般都是 HotSpot！

堆

Heap，一个JVM只有一个堆内存。堆内存的大小是可以调节的。

类加载器读取类文件后，一般会把什么东西放到堆中？

类、方法、常量、变量~保存所有引用类型的真实对象。

堆内存细分三个区域：

新生区（伊甸园区）
养老区
永久区

堆也被称作GC堆

GC垃圾回收，主要是在伊甸园区和养老区~假设内存满了，报错OOM，堆内存不够！

JDK8以后，永久存储区改了个名字，叫元空间。

新生区、老年区、永久区

其实通过上面的图就会发现：

新生区（伊甸园区+幸存者区*2)

类诞生和死亡的地方
伊甸园区：所有对象都是伊甸园区new出来的！
幸存者区（0、1），轻GC定期清理伊甸园区，活下来的放入幸存者区，幸存者区满了以后重GC清理伊甸园区+幸存者区。活下来的放入养老区，都满了就报OOM！

真理：经过研究，99%的对象都是临时对象，直接被清理！

老年区

新生区剩下来的，轻GC杀不死的。

永久区

这个区域常驻内存，用来存放JDK自身携带的Class对象，interface元数据，存储的是java运行时一些环境和类信息，该区域不存在垃圾回收GC。关闭虚拟机就会自动释放这个内存。

jdk1.6之前：永久代，常量池在方法区
jdk1.7：永久代，但是慢慢退化了（去永久代），常量池在堆中
jdk1.8之后：无永久代，常量池在元空间

一个启动类，加载了大量第三方jar包，Tomcat部署了太多应用，大量动态生成的反射类。不断被加载。直到内存满，就会出现OOM。

方法区又称为非堆，本质还是堆，只是为了区分概念。

元空间逻辑上存在，物理上不存在。

堆内存调优

报OOM怎么办？

1、尝试扩大堆内存，如果还报错，说明有死循环代码或者垃圾代码。

2、分析内存，看一下哪个地方有问题（专业工具）

使用Jprofiler工具分析OOM原因

在一个项目中，突然出现了OOM的故障，该如何排除？研究为什么会出错？

能够看到代码第几行出错：内存快照分析工具，MAT，Jprofiler
Debug，一行行分析代码！

MAT，Jprofiler作用：

分析Dump内存文件，快速定位内存泄漏
获得堆中的数据
获得大的对象（大厂面试）
...

看如下代码：

java 复制代码

package com.linghu;

import java.util.ArrayList;

/**
 * @author linghu
 * @date 2024/1/24 10:44
 */
public class Demo03 {
    byte[] array = new byte[1*1024*1024]; //1m

    public static void main(String[] args) {
        ArrayList<Demo03> list = new ArrayList<>();
        int count = 0;

        try {
            while (true){
                list.add(new Demo03()); //不停地把创建对象放进列表，这是问题所在！
                count = count + 1;
            }
        } catch (Exception e) {
            System.out.println("count: "+count);
            e.printStackTrace();
        }

    }
}

报错如下