JAVA理论第五章-JVM

JVM是什么

Java Virtual Machine java程序的运行环境（java二进制字节码的运行环境），一种能够运行 java 字节码的虚拟机。

好处：

一次编写，到处运行
自动内存管理，垃圾回收机制

JVM由哪些部分组成，运行流程是什么？

什么是程序计数器？

程序计数器：线程私有的，内部保存的字节码的行号。用于记录正在执行的字节码指令的地址。

什么是虚拟机栈？

每个线程运行时所需要的内存，成为虚拟机栈，先进后出
每个栈由多个栈帧组成，对应这每次方法调用时所占的内存
每个栈帧只能有一个活动栈帧，对应着当前正在执行的那个方法

什么是方法区？

方法区是各个线程共享的内存区域
主要存储类的信息、运行时常量池
虚拟机启动的时候创建，关闭虚拟机时释放
如果方法区域中的内存无法满足分配请求，则会抛出OOM

元空间实现了方法区

常量池

可以看作是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息。

运行时常量池

常量池是*.class文件中的，当该类被加载，他的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

直接内存：

并不属于JVM中的内存结构，不由JVM进行管理。是虚拟机的系统内存
常见于NIO操作时，用于数据缓冲区，它分配回收成本较高，但读写性能高

栈：本地方法栈，java虚拟机栈，程序计数器
java虚拟机栈：局部变量表、操作数栈、动态连接、方法出口、栈帧

局部变量表（存放基本数据类型 、和引用数据类型在堆中的地址 、方法的返回地址）
操作数栈：存放计算过程中的中间结果，同时作为计算过程中变量临时的存储空间
动态连接：一个指向运行时常量池中 该栈帧所属方法的引用
方法出口：记录方法结束后，继续运行下一个栈帧对应方法那行代码
栈帧：栈的最小单位 ，用来表达方法与方法之间的调用关系
场景理解：
栈帧是一张数学考试， 局部变量表 （存放 基本数据结构 、 引用数据结构的地址 、还有 方法的返回地址 ）是答题卡， 操作数栈 是草稿纸用来 存放计算过程的中间结果 ， 是一个临时的存储空间 。 动态链接 是向老师借的计算器， 可以调用所属方法 ，用完了之后要还给老师。 方法出口 就是黑板上记录下场考试地点的信息也就是继续运行 下一个栈帧对应的那个方法的那行代码
堆：存放对象

6.1JDK1.8JVM运行时内存

JVM虚拟机数据区：Java虚拟机在运行时用来存储不同类型的程序数据的区域

程序计数器（属于栈）
本地方法栈（属于栈）
java虚拟机栈（属于栈）
堆
本地内存
元数据区
直接内存
程序计数器：线程私有的 （每个线程都有一个自己的程序计数器），是 一个指针 。代码运行，执行命令。而每个命令都是有行号的，会使用程序计数器来记录命令执行到多少行了。 记录正在执行的JVM指令的地址
虚拟机栈 ： 线程私有的 （每个线程都有一个自己的本地方法栈）， 方法运行会为这个方法创建一个栈帧 ，每一个方法就对应着栈帧 执行代码时 栈帧入栈， 执行完毕 之后 出栈。 用于 存储局部变量表（包括基本类型和对象的引用）、操作数栈、动态链接和方法返回地址等信息
本地方法栈 ： 线程私有的 （每个线程都有一个属于自己的） 和java虚拟机栈类似 ， 虚拟机栈加载的是普通方法 ，本地方法加载的是 native修饰的方法
native：在java中有用native修饰的， 表示这个方法不是java原生的，比如c++
堆：线程共享的（所有的线程共享一份） ， 存放对象和常量池，new的对象都存储在这个区域。
元空间（元数据区） ：存储 .class信息，类的信息，方法的定义，静态变量等 。而 常量池放到堆里 存储,JDK1.8和JDK1.7的区别，在1.8中是由 元空间取代了方法区的实现（永久代）

6.1.1元空间与永久代的区别

永久代 属于JVM堆 的一部分、有固定大小 ，性能更差
元空间 属于本地内存 、能动态扩容 、性能更好

6.2JDK1.8堆内存结构

Young 年轻区（代）: Eden+S0+S1, S0 和 S1 大小相等, 新创建的对象都在年轻代,主要存放朝生夕灭的对象。被小范围但高频的mini gc回收
Tenured 年老区: 经过年轻代多次垃圾回收存活下来的对象存放在年老代中。
标记清理：先通过引用判断是否是垃圾，再清除，缺点：如果垃圾太多。效率低，有内存空洞的问题
标记复制：将可用的内存分为两部分，标记过程相同，清理过程是将非垃圾挪到另一边，把原有一边全部删除，优点解决垃圾多和空洞问题但是内存利用率不是很高
标记整理：标记一样，整理过程中先将垃圾和非垃圾分类，比如非垃圾放前面垃圾放后面，然后再清理垃圾。解决了空洞问题但是复杂度更高

6.3 Gc 垃圾回收

JVM的垃圾回收动作可以大致分为两大步，首先是【 如何发现垃圾 】，然后是【 如何回收垃圾】。
线程私有的不存在垃圾回收 。只有 线程共享的才会存在垃圾回收，所以堆中存在垃圾回收。

6.3.1 如何发现垃圾

java语言规范并没有明确的说明JVM使用哪种垃圾回收算法，但是常见的用于【发现垃圾】的算法有两种，引用计数算法和根搜索算法。
1.引入计数算法
该方法很古老（了解）。核心思想就是，堆中的对象每被引用一次，则计数器加1，每减少一个引用就减1，当对象的引用计数器为0时可以被当作垃圾收集。
优点：快
缺点：无法检测出循环引用。如两个对象互相引用时，他们的引用计数永远不可能为0。
2.根搜索算法（可达性分析）
根搜索算法是把 所有的引用关系看作一张图 ，从一个节点 GC ROOT 开始，寻找对应的引用节点，找到这个节点以后，继续 寻找这个节点的引用节点，当所有的引用节点寻找完毕之后，
剩余的节点则被认为是没有被引用到的节点，即可以当作垃圾

Java中可作为GC Root的对象有（）线程栈中的本地变量，静态变量，本地方法栈中的变量

虚拟机栈中引用的对象
本地方法栈引用的对象
方法区中静态属性引用 的对象
方法区中常量引用 的对象

6.3.2 如何回收垃圾

java中用于【 回收垃圾】的常见算法有4种：

标记-清除算法（mark and sweep）
分为" 标记 "和" 清除 "两个阶段： 首先标记出所有需要回收的对象 ，在标记完成之后 同一回收掉所有被标记的对象。
缺点：首先，效率问题， 标记和清除效率都不高 。其次，标记清除之后会 产生大量的不联系的内存碎片
标记-整理算法
在 标记清除算法基础上做了改进 ， 标记阶段相同 。但标记完成后不是直接对可回收对象进行清理，而是 让所有存活的对象都向一端移动 ，在 移动过程中清理掉可回收的对象，这个过程叫整理
优点：内存被整理后 不会产生 大量不连续 内存碎片。
复制算法
将 可用内存按容量分为大小相等的两块 ，每次只能使用其中一块 ，当这块内存使用完了 ， 就将还存活的对象复制到另一块内存上去 ，然后 把使用过的内存空间一次清理掉。
缺点：可使用内存只有原来的一半
分代收集算法
当前主流JVM都采用分代收集算法，这种算法会根据对象存活周期的不同将内存划分为 年轻代 、 年老代、永久代（1.8后废弃），不同生命周期的对象可以采取不同的回收算法，以便提高回收效率

（1） 年轻代（复制算法）
所有新生成的的对象首先都是放在年轻代
新生代内存按照8：1：1 的比例分为了一个Eden区 和两个Survivor(survivor0,survivor1)区、也叫幸存者区 。大部分对象在Eden区中生成。回收时先将eden区存活对象复制到survivor0区 ，然后清空eden区 ，当这个survivor0区也存满时 ，则将eden区和survivor0区存活的对象复制到另一个survivor1区 ，然后清空eden区和幸存者0区 ，此时幸存者0区就是空的，然后将幸存者0区和幸存者1区交换内存 ，则保持幸存者1区为空，如此循环操作。
当幸存者1区不足以存放eden区和幸存者0区的存活对象的时候 ，就将存活对象直接放到老年代 ，若是老年代也满了 就会触发一次Major GC ,也就是新生代和老年代都进行垃圾回收。
新生代 发送的GC叫Minor GC ，MinorGc发送频率比较高（不一定等Eden区满了才触发）
（2） 年老代（标记清除标记整理算法）
1.存放在年轻代中经历了 N次垃圾回收后仍然存活的对象 。因此，年老代可以认可年老代中 存放的都是一些生命周期较长的对象
内存比新生代也大很多（大概是2倍） ，当 老年代内存满触发Major GC 即Full GC，Major GC发送 频率比较低 ，老年代 对象存活时间比较长，存活率比较高。
（3）永久代 JDK1.8后废除被本地内存中的元空间取代
用于存放静态文件，如java类，方法等JDK1.8后存放到了元数据区，常量池存在堆里。永久代对垃圾回收没有显著影响。

1.垃圾回收是否涉及栈内存

垃圾回收主要指就是堆内存，当栈帧弹栈以后，内存就会释放

2.栈内存分配越大越好吗？

不一定，默认的栈内存通常为1024k

栈帧过大会导致线程数变少，例如，机器总内存为512m，目前能活动的线程数则为512个，如果把栈内存改为2048k，那么能活动的栈帧就会减半

3.方法内的局部变量是否线程安全？

如果方法内局部变量没有逃离方法的作用范围（即没有将局部变量return出去），它是线程安全的
如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

java 复制代码

public class ThreadSafeDemo {
    public static void main(String[] args) {
        // 创建共享的 StringBuilder 对象
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        
        // 启动新线程操作共享的 sb，m2 中对共享资源操作无同步，线程不安全
        new Thread(() -> {
            m2(sb);
        }).start();
    }

    // m1 方法：
    // 线程安全。因为 StringBuilder 是方法内局部变量，每个线程调用 m1 时会创建独立的 sb，不存在多线程共享
    public static void m1() {
        StringBuilder sb = new StringBuilder(); 
        sb.append(1);
        sb.append(2);
        System.out.println(sb.toString());
    }

    // m2 方法：
    // 线程不安全。参数 sb 是多线程共享的（main 线程和新启动线程共用），append 操作非原子且无同步，可能导致线程间干扰
    public static void m2(StringBuilder sb) {
        sb.append(3);
        sb.append(4);
        System.out.println(sb.toString());
    }

    // m3 方法：
    // 线程不安全。虽然 StringBuilder 是局部变量，但方法返回其引用后，若外部多线程获取该引用并操作，会引发线程安全问题（如共享引用被修改）
    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(5);
        sb.append(6);
        return sb; 
    }
}

4.栈内存溢出情况

栈帧过多导致栈内存溢出，典型问题：递归调用

栈帧过大导致栈内存溢出

5.堆栈的区别是什么？

栈内存一般用来存储局部变量和方法调用，但堆内存是用来存储java对象和数组的。堆会GC垃圾回收，而栈不会
栈内存是线程私有的，而堆内存是线程共有的
两者异常错误不同，但如果栈内存或者堆内存不足都会抛出异常。
1. 栈空间不足：java.lang.StackOverFlowError。
2. 堆空间不足：java.lang.OutOfMemoryError。

6.4 JVM调优参数

这里只给出一些常见的性能调优的参数及其代表的含义。

-Xmx3550m :设置JVM 最大可用内存 为 3550M
-Xms3550m ：设置 jvm初始内存 为 3550M 。注意： 此值一般设置成和-Xmx相同 ，以 避免每次垃圾回收完成后 jvm 重新分配内存
-Xmn2g ：设置 年轻代大小为2G.整个JVM内存大小=年轻代大小+年老代大小+永久代大小。此值对系统性能影响较大，Sun官方推荐配置为3/8

Xss256K：设置每个线程的大小。JDK5.0以后每个线程大小为1M，以前每个线程栈大小为256k。根据应用的线程所需内存大小进行调整。在相同物理内存下，减少这个值能生成更多的线程
XX:NewRatio=4 :设置 年轻代（包括Eden区和两个Survivor区）与年老代的比值（除去持久代）。设置为4，则年轻代与年老代所占比值1：4.（该值默认为2）
-XX:SurvivorRatio=4 ： 设置年轻代中eden区域Survivor区的大小比值。设置为4，则两个Survivor区一个Eden区的比值为2:4

什么是类加载器，类加载器有哪些？

什么是类加载器

JVM只会运行二进制文件，类加载器的作用就是将字节码文件加载到JVM中，从而让java程序能够启动起来

2.类加载器有哪些？

启动类加载器（BootStrap ClassLoader）：加载JAVA_HOME/jre/lib目录下的库
扩展类加载器（ExtClassLoader）：主要加载JAVA_HOME/jre/lib/ext目录中的类
应用类加载器（AppClassLoader）：用于加载classPath下的类
自定义类加载器（CustomizeClassLoader）：自定义类继承ClassLoader，实现自定义类加载规则

双亲委派模型

什么是双亲委派模型？

加载某一个类，先委托上一级的加载器进行加载，如果上级加载器也有上级，则会继续向上委托，如果该类委托上级没有被加载，子加载器尝试加载该类。

如果加载的类在上级找到，则子加载器不用加载，例如String类。即优先使用JDK原生的类

JVM为什么采用双亲委派机制？

通过双亲委派机制可以避免某一个类被重复加载，当父类已经加载后则无需重复加载，保证唯一性。
为了安全，保证类库API不会被修改

由于是双亲委派机制，java.lang.String的在启动类加载器得到加载，因为在核心jre库中有其相同名字的类文件，但该类中并没有main方法。这样就能防止恶意篡改核心API库

类装载的执行过程

类从加载到虚拟机中开始，直到卸载为止，它的整个生命周期包括了：加载、验证、准备、解析、初始化、使用和卸载这7个阶段。其中，验证、准备和解析这三个部分统称为连接（linking）

加载

通过类的全名，获取类的二进制数据流
解析类的二进制数据流为方法区内的数据结构（Java类模型）
创建java.lang.Class类的实例，表示该类型。作为方法区这个类的各种数据的访问入口

连接

验证

验证类是否符合JVM规范，安全性检查

格式检查，如：文件格式是否错误，语法是否错误、字节码是否合规
1. 文件格式验证
2. 元数据验证
3. 字节码验证
符号引号验证：Class文件在其常量池会通过字符串记录自己将要使用的其他类或者方法，检查他们是否存在

准备

为类变量分配内存并设置类变量初始值

static变量，分配空间在准备阶段完成（设置默认值），赋值在初始化阶段完成
static变量是final的基本类型，以及字符串常量，值已确定，赋值在准备阶段完成
static变量是final的引用类型，那么赋值也会在初始化阶段完成

解析

把类中的符号引用转换为直接引用

比如：方法中调用了其他方法，方法名可以理解为符号引用，而直接引用就是使用指针直接指向方法。

初始化

对类的静态变量，静态代码块执行初始化操作

如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类
如果同时包含多个静态变量和静态代码块，则按照自上而下的顺序依次执行

使用

JVM开始入口开始执行用户的程序代码

调用静态类成员信息（比如：静态字段、静态方法）
使用new关键字为其创建对象实例

总结

加载：查找和导入class文件
验证：保证加载类的准确性
准备：为类变量分配内存并设置类变量初始值
解析：把类中的符号引用转换为直接引用
初始化：对类的静态变量，静态代码块执行初始化操作
使用：jvm开始从入口方法开始执行用户的程序代码
卸载：当用户程序代码执行完毕后，JVM便开始销毁创建的class对象

强引用、软引用、弱引用、虚引用的区别

强引用 ：被仍一GC Roots对象【强引用】的对象**，该对象都不会被垃圾回收**

java 复制代码

User  user =new User()

2.软引用 ：仅有软引用该对象时，在垃圾回收后，如果内存仍不足会再次触发垃圾回收
需要配合 **SoftReference（软引用）**使用

java 复制代码

User user = new User();
SoftReference softReference = new SoftReference(user);

3. 弱引用 ：仅有弱引用该对象时，垃圾回收无论内存是否充足都会回收弱引用对象
需要配合WeakReference（弱引用）使用

4. 虚引用 ：必须配合引用队列使用，被引用对象回收时 ，会将虚引用入队，由Reference Handler线程调用虚引用相关方法释放直接内存

java 复制代码

User user = new User();
ReferenceQueue queue = new ReferenceQueue();
PhantomReference phantomReference = new PhantomReference(user, queue);

本文部分图片AI生成部分来自互联网

JAVA理论第五章-JVM

JVM由哪些部分组成，运行流程是什么？

6.1JDK1.8JVM运行时内存

6.1.1元空间与 永久代 的区别

6.2JDK1.8堆内存结构

6.3 Gc 垃圾回收

6.3.1 如何发现垃圾

6.3.2 如何回收垃圾

6.4 JVM调优参数

什么是类加载器，类加载器有哪些？

强引用、软引用、弱引用、虚引用的区别

6.1.1元空间与永久代的区别