何同昊 Blog 首页文章总览标签分类歌单相册
JVM 深入理解
|Java
字数总计: 5.6k|阅读时长: 18 分钟

前言

  • 你真的研究过JVM吗？JVM的这些知识你深入了解过吗？

JVM版本信息

问题：请你谈谈你认识几种 JVM？（3种）

  • SUN 公司 HotSpot （默认，掌握这个jvm即可）
  • BEA 公司 JRockit
  • IBM 公司 J9VM

问题：jvm除了Service模式是否有Client模式？他们有什么区别？如何修改？（了解即可）

  • Server模式启动时，速度较慢，但是一旦运行起来后，性能将会有很大的提升（64位系统默认）

  • Client模式启动时，启动较快，占用内存少，针对客户端进行优化（32位系统默认，一般用不到）

  • 在路径JAVA_HOME/jre/lib/amd64/jvm.cfg 修改-server和-client的配置即可完成更改。

    修改模式

问题：jvm有几种mode？如何修改?（了解即可）

  • mixed mode（默认）：混合模式执行，编译+执行。 -Xmixed
  • interpreted mode ：解释模式执行。 -Xint
  • compiled mode ：编译模式执行。 -Xcomp

切换mode

JVM的位置

jvm位置

  • 是java程序跨平台，不是jvm跨平台，jvm将java代码编译成不同操作系统能执行的.class字节码。

JVM体系架构

JVM体系架构图

ClassLoader

ClassLoader的层级

ClassLoader的层级

  • 官方提供了3种ClassLoader

BootStrap ClassLoader

称为启动类加载器，处于加载器的最顶层，负责加载rt.jar、resources.jar、charsets.jar等，由于是C写的所以java程序触及不到。

public class JvmDemo {
    public static void main(String[] args) {
        System.out.println(System.getProperty("sun.boot.class.path"));
      	//所有对象的祖宗object是第一个被加载的类，被BootStrap ClassLoader加载，但是我们访问不到
        System.out.println(Object.class.getClassLoader());
    }
}

输出结果

Ext ClassLoader

称为扩展类加载器，父类是BootStrap ClassLoader，负责加载Java的扩展类库，Java 虚拟机会提供一个扩展库目录，该类加载器在此目录里面查找并加载 Java 类。默认加载JAVA_HOME/jre/lib/ext/目下的所有jar。

public class JvmDemo {
    public static void main(String[] args) {
        System.out.println(System.getProperty("java.ext.dirs"));
    }
}

执行结果

App ClassLoader

称为应用程序加载器，父类是Ext ClassLoader，负责加载我们自定义的类，是我们接触最多的加载器，加载classpath下面的类。

public class JvmDemo {
    public static void main(String[] args) {
        System.out.println(JvmDemo.class.getClassLoader());
    }
}

执行结果

双亲委派机制

双亲委派机制 可以保护java的核心类不会被自己定义的类所替代

一层一层的让父类去加载，如果顶层的加载器不能加载，然后再向下类推，直到某个类加载器覆盖到了为止。

类加载的过程

  • 当一个类被第一次加载的时候，jvm会通过类加载器将.class文件载入内存当中（方法区），并将这个类创建一个全局唯一的Class对象作为这个类对象的模板。

  1. 加载.class文件

  2. 连接

    1. 验证：验证.class文件是否正确
    2. 准备：给静态变量分配内存空间并赋予初始值(基本数据类型：0、false，引用类型：null)
    3. 解析：将类中的符号引用替换为为真实引用
    在把java编译为class文件的时候，虚拟机并不知道所引用的地址；助记符：符号引用！
    转为真正的直接引用，找到对应的直接地址！

  3. 静态变量赋予正确的值

静态块

当类被加载时，会执行的代码块:static{}，从基类开始从上至下加载。

package vc.coding.jvm;

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(MyChild1.str2);
        // 运行的结果
        /**
         * MyParent1 static
         * MyChild1 static
         * hello,str2
         */
    }
}

class MyParent1{
    public static String str = "hello,world";
    static {
        System.out.println("MyParent1 static");
    }
}

class MyChild1 extends MyParent1{
    public static String str2 = "hello,str2";
    static {
        System.out.println("MyChild1 static");
    }
}

静态常量

当一个常量的值如果编译期间可以确定的，那这个值就会被加载到调用者类的常量池中！

package vc.coding.jvm;

import java.util.UUID;

/**
 * @author HeTongHao
 * @since 2020/3/11 14:25
 */
public class JvmDemo {
    public static void main(String[] args) {
        System.out.println(StaticBlock.str);
    }
   	/**
     * final 常量在编译阶段的时候 常量池；
     * 调用 str 的过程将常量放到了 JvmDemo 的常量池中,所以静态块没有被执行
     * 调用 str1 的过程加载了StaticBlock类并且执行了UUID.randomUUID().toString() JvmDemo 的常量池			 * 中,所以静态块会被执行
     */
}

class StaticBlock {
    /**
     * 加载类的时候有确定的值
     */
    public static final String str = "123";
    /**
     * 加载类的时候未确定的值
     */
    public static final String str1 = UUID.randomUUID().toString();

    static {
        // 这句话会输出吗？
        System.out.println("StaticBlock static");
    }
}

Native方法

  • JNI ： Java Native Interface （Java 本地方法接口）
  • 凡是带native关键字的方法都是本地方法
  • java触及不到的功能，就会调用C或C++的本地方法库，比如说java不能创建线程：
  • 1995年，java 还未立足所以必须可以去调用 c、c++的库，所以说Java就在内存中专门开辟了一块区域标记为 native 方法。
public class Test {
    public static void main(String[] args) {
        // 底层调用的是 private native void start0();
        new Thread().start();
    }
}

程序计数器

每个线程都有一个程序计数器，是线程私有的。

程序计数器就是一块十分小的内存空间；几乎可以不计

作用： 当前字节码执行的行号指示器

程序计数器

分支、循环、跳转、异常处理！都需要依赖于程序计数器来完成！

bipush 将 int、float、String、常量值推送值栈顶

istore 将一个数值从操作数栈存储到局部变量表

iadd 加

imul 乘

栈 Stack

什么是栈？

  • 对比队列来说

    队列是吃多了拉 = 先进先出 = FIFO（First Input First OutPut）

    栈是喝多了吐 = 后进先出 = LIFO (Last Input First OutPut)

队列与栈

  • 栈是线程私有的（每个线程都有自己的栈）

  • 栈是掌管程序运行的，毎执行一个命令就是往栈中压一层，直到最后上一层执行完毕之后就弹出，栈空了线程就Over了。压栈

  • 存储一些基本类型的值、对象的引用（引用指向堆内存）、方法等…

    问：为什么java的方法传递是值传递而不是引用传递？

    答：因为实参传递到方法形参的过程，就是把栈中对象的引用值（也可以理解为堆的地址）传递过去，形参同样会开辟栈空间存储这个引用。

引用指向堆内存

  • 栈存取速度比堆快！仅次于cpu寄存器。

StackOverFlow

public class Demo01 {
    public static void main(String[] args) {
        a();
    }
    // main  a  a  a   a a  a a a  a a  a  满
    // Exception in thread "main" java.lang.StackOverflowError
    private static void a() {
        a();
    }
}
  • 栈是一定不会存在垃圾回收的问题的，只要线程一旦结束，栈就Over了，与线程的生命周期一致。

Stack 原理

  • java栈的组成元素 ：栈帧
  • 每个栈帧存储着父、子栈帧的引用、方法引用、参数等…

栈帧

方法区

  • 因为物理上不在堆中而逻辑上可以归为堆中（下面👇堆会提到），所以又称：非堆区(Non-Heap space)

  • Method Area 方法区 是 Java虚拟机规范中定义的运行数据区域之一，和堆（heap）一样可以在线程之间共享！

JDK1.7之前

永久代：用于存储一些虚拟机加载类信息，常量，字符串、静态变量等等。。这些东西都会放到永久代中；

永久代大小空间是有限的：如果满了 OutOfMemoryError：PermGen

JDK1.8之后

HotSpot jvm 中彻底将永久代移除，新增了 Meta Spaces (元空间)

元空间就是方法区在 HotSpot jvm 的实现；

方法区主要就是来存：类信息，常量，字符串、静态变量、符号引用、方法代码。。。

元空间和永久代最大的区别：元空间并不在Java虚拟机中，使用的是本地内存！

调整元空间大小：-XX:MetasapceSize10m

堆 Heap

什么是堆？

  • 一个JVM实例只有一个堆，可供所有线程共享数据，堆的大小是可以调节的。

  • 可以存储的内容：对象实例、类、方法、常量。

  • 分为三个部分：

    • 新生区 Young （Eden-from-to）
    • 养老区 Old Tenure
    • 方法区（1.7之前：永久区 Perm，之后：元空间 Meta Space）（逻辑上）

  • GC垃圾回收主要发生在新生区与养老区中，又分为普通GC和Full GC，如果堆满了，则会报出OOM异常（OutOfMemoryError）。

调整堆的大小

  • -Xmx：最大堆大小 (默认为系统内存的1/4)

  • -Xms：初始堆大小 (默认为系统内存的1/64)

  • -Xmn: 年轻代大小 (默认为堆的1/3)

新生区

  • 新生区是一个对象诞生、成长、消亡的地方。

  • 新生区的细分：Eden、s0与s1区（from to），所有的对象Eden被new出来，慢慢当Eden满了，程序还需要创建对象的时候，会触发一次轻量级的GC，清理完后将活下来的对象放入幸存者区（也就是s0与s1），毎执行一次轻GC就会将活着的对象在s0与s1中进行复制、交换、销毁（下面👇GC会详细解释）。

  • 99%的对象在新生区都是临时对象，在这里创建也在这里消亡。

养老区

  • 新生区中清理了很多次之后，如果有一些特别顽强的对象经历了15次垃圾回收（默认也是最大值15，可调参）！则送入养老区！

  • 如果运行了很久之后，养老区也满了，就会触发Full GC。

  • 如果养老区都清理不动了的话，则会出现OOM异常。

方法区（永久区、元空间）

  • 存放类信息、方法、常量。

  • 几乎不会被垃圾回收。

    • 常量回收条件：当没有对象引用一个常量的时候，该常量即可以被回收。

    • 对象回收条件：1.该类的实例都被回收。 2.加载该类的classLoader已经被回收 3.该类不能通过反射访问到其方法，而且该类的java.lang.class没有被引用 当满足这3个条件时，可以被回收。

  • 方法区和堆一样，是共享的区域，是JVM 规范中的一个逻辑的部分，别名：非堆。

JDK1.6之前：有永久代、常量池在方法区;

JDK1.7：有永久代、但是尝试去永久代，常量池在堆中;

JDK1.8之后：永久代没有了，取而代之的是元空间：常量池在元空间中;

标配参数、-X、-XX参数

  • JVM只有三种参数类型：标配参数、X参数、XX参数。

标配参数

  • 以 - 开头的为标配参数

  • 在各种版本之间都很稳定，很少有变化

X参数

  • 以 -X 开头的为标配参数

XX参数

  • 以 -XX 开头的为标配参数
  • 公式：
    • Boolean类型
      • -XX:+开头代表开启某个功能，例如：-XX:+PrintGCDetails。
      • -XX:-开头代表关闭某个功能，例如：-XX:-PrintGCDetails。
    • Key=Value类型
      • -XX:key=value，例如：-XX:InitialHeapSize=268435456。

常用JVM调优参数整理

标配参数

参数 描述
-verbose:class 输出jvm载入类的相关信息，当jvm报告说找不到类或者类冲突时可此进行诊断。
-verbose:gc 输出每次GC的相关情况。
-verbose:jni 输出native方法调用的相关情况，一般用于诊断jni调用错误信息。

-X参数

参数 描述
-Xint 解释执行
-XComp 第一次使用就编译成本地的代码
-Xmixed 混合模式（Java默认）
-Xprof 跟踪正运行的程序，并将跟踪数据在标准输出输出；适合于开发环境调试。

-XX参数

参数 描述
-Xmx8m 最大堆内存8m (-XX:InitialHeapSize=8m缩写)
-Xms8m 初始堆内存8m (-XX:MaxHeapSize=8m缩写)
-Xmn200m 设置年轻代大小为200M。整个堆大小=年轻代大小 + 年老代大小 + 持久代大小。持久代一般固定大小为64m，所以增大年轻代后，将会减小年老代大小。此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。(缩写语法糖)
-Xss128k 设置每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M，以前每个线程堆栈大小为256K。更具应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。(缩写语法糖)
-XX:+PrintGCDetails 打印GC详情
-XX:+HeapDumpOnOutOfMemoryError dump 内存溢出异常
-XX:MetaspaceSize=10m 元空间大小=10m
-XX:MaxMetaspaceSize=10m 最大元空间大小=10m
-XX:+TraceClassLoading 跟踪类加载
-XX:MaxTenuringThreshold = 15 进入老年区的存活阈值
-XX:NewRatio=2 设置年轻代与老年代的占比:NewRatio = 2 新生代1，老年代是2，默认新生代整个堆的 1/3;NewRatio = 4 新生代1，老年代+是4，默认新生代整个堆的 1/5;

Java程序监控、Dump内存快照

  • -XX:+HeapDumpOnOutOfMemoryError可以在内存溢出时，dump内存快照
  • -XX:HeapDumpPath=目录+产生的时间.hprof设置内存快照生成地址
  • 在java程序运行的时候，想测试运行的情况！可以使用一些工具来查看:

Jconsole

  • jps命令：查看当前运行java进程jps命令

  • jconsole 进程号：查看java进程当前运行状况:

    jconsole

    jconsole控制台

IDEA（Jprofiler插件）

Arthas

GC

GC就是java中的垃圾回机制，一直在追求更快且高效的道路中。

随着应用程序所应对的业务越来越庞大、复杂，用户越来越多，没有GC就不能保证应用程序正常进行。而经常造成STW的GC又跟不上实际的需求，所以才会不断地尝试对GC进行优化

GC的作用域

GC作用域

  • 新生代：GC频繁区域！
  • 老年代：GC次数较少！
  • 方法区：GC次数极少！

一个对象的诞生、成长、消亡

一个对象的诞生、成长、消亡

  • GC分为两个类型：
    • 普通垃圾回收：只针对新生代！「 GC 」
    • 完全垃圾回收：主要针对老年代，偶尔伴随新生代或方法区！「 Full GC 」

GC四大算法

复制算法

  • 新生代中就是使用复制算法！
  1. 一般普通GC 之后，差不多Eden几乎都是空的了！

复制算法图解

  1. 每次存活的对象，都会被从 from 区和 Eden区复制到 to区，from 和 to 会发生一次交换；记住一个点就好，谁空谁是to，每当幸存一次，就会导致这个对象的年龄+1；如果这个年龄值大于15（默认也是最大值15，可调参），就会进入养老区！
  • 优点：没有标记的过程、只用扫描一次，效率高！没有内存碎片！
  • 缺点：需要浪费一倍的空间

标记清除算法

  • 老年代一般用的算法，并且和后面的压缩算法一起使用！

标记清除算法

优点：不需要额外的空间！

缺点：两次扫描、耗时比较严重，并且会产生内存碎片，内存不连续！（如果再来存东西会多判断这个地址是否存的下）

标记清除压缩算法

  • 就是在标记清除算法后面加了一次压缩，去内存碎片！

内存压缩

优点：不需要额外的空间！无内存碎片！

缺点：耗时同样比较严重！

在我们这个要使用算法的空间中，假设这个空间中对象较少，不经常发生GC，那么可以考虑使用这个算法！

小总结

  • 内存效率：复制算法 > 标记清除算法 > 标记压清除缩算法（时间复杂度）

  • 内存整齐度：复制算法=标记清除压缩算法>标记清除算法

  • 内存利用率：标记清除压缩算法 = 标记清除算法 > 复制算法

效率上来说复制算法最好，但是浪费空间较多！为了兼顾所有指标，标记清除压缩算法比较平滑，但是也不太完美！

难道没有一种最优的算法吗？

答案：没有！没有最好的只有最合适的！—–>分代收集算法：不同的区域使用不同的算法！

分代收集算法

新生代：相对于老年代，存活率较低、GC次数较多、99%的对象在这里被清理、区域小！推荐使用：复制算法！

老年代：相对于新生代，存活率高、GC次数较少、区域比较大! 推荐使用：标记清除压缩算法!

JVM 如何确定垃圾？

什么是垃圾：简单来说，就是不再被引用的对象！

Person person = new Person();
Person person = null;

引用计数法（了解即可）

  • JVM一般不采用这种方式，现在一般使用可达性算法，GC Root。
  • 引用计数法就是每个对象有一个引用计数器，被几个对象所引用count就是几，如果为0，则这个对象可以被清理。

引用计数法

如此可知每次发生GC时，上图A对象count=0，所以会被清理，而其他对象则不会被清理，这里有一个严重的问题，比如C与D对象是互相引用的关系，这两个对象可能永远无法被清理。

  • 缺点：
    • 引用计数器维护麻烦！
    • 循环引用无法解决！

可达性算法

  • 一切都是从 GC Root 这个对象开始遍历的，只要在GC Root的引用链中就不是垃圾！

可达性算法

什么是GC Root（4种）

  1. 虚拟机栈中引用的对象。

  2. 在类中静态属性引用的对象。

  3. 在方法区中的常量。

  4. 本地方法栈中Native方法引用的对象（JNI了解即可）。

    public class GCRoots{
        // private static GCRoots2 t2; // GC root;
        // private static final GCRoots3 t3 = new GCRoots3(); // GC root;
        public static void m1(){
            GCRoots g1 = new GCRoots(); //GC root;
            System.gc();
        }

        public static void main(String[] args){
            m1();
        }
    }

不同的垃圾收集器

  • 垃圾收集器工作方式分为四大类：串行、并发、并行、G1。

STW：Stop the World：代表JVM准备GC时，所有的线程都停止!

串行收集器

  • 单线程收集，会STW

串行收集器

并发收集器

  • 多线程工作，也会STW
  • 并发：一个cpu同时处理多个任务

并发收集器

并行收集器

  • 在回收垃圾的同时，其它线程可以执行，并行处理，但是如果是单核CPU，只能交替执行！
  • 并行：多个cpu同时处理多个任务

并行收集器

G1收集器 (待深入研究)

  • G1（Garbage-First）收集器，面向服务器端的应用的收集器；
  • 将堆内存分割成不同的区域，然后并发的对其进行垃圾回收。
  • -XX:MaxGCPauseMillis=100 调整最大的GC停顿时间单位：毫秒，JVM尽可能的保证停顿小于这个时间！

G1收集器

G1的优点：

  1. 没有内存碎片。
  2. 可以精准控制垃圾回收时间。

七种垃圾收集器

JDK7/8中，HotSpot虚拟机所有收集器及组合（连线），如下图：

七大垃圾收集器组合

  • 图中一共有7中收集器

    Serial、ParNew、Parallel Scavenge、Serial Old、Parallel Old、CMS、G1。

  • 它们每个收集器都有自己负责的区域：

    • 新生代收集器：Serial、ParNew（串行的多线程版本）、Parallel Scavengez
    • 老年代收集器：Serial Old、Parallel Old、CMS
    • 整堆收集器：G1

哪个是默认的垃圾收集器？

  • 垃圾收集器一直在更新换代，到了jdk8默认的是Parallel Scavenge + Serial Old，而到了jdk9则默认为G1收集器了。

查看默认的垃圾收集器

java -XX:+PrintCommandLineFlags -version

查看默认垃圾收集器

如何选择/设置垃圾回收器

  • 设置了任何一个新生代收集器默认会匹配一个对应的老年代收集器

  1. 单CPU，单机程序，内存小。

    -XX:+UseSerialGC

  2. 多CPU，大吞吐量，后台计算!

    -XX:+UseParNewGC

  3. 多CPU，但是不希望有时间停顿，快速响应！

    XX:+UseParallelGC、-XX:+UseG1GC

摘自 《深入理解 Java 虚拟机》第二版 P90

参数 描述
UseSerialGC 虚拟机运行在Client模式下的默认值，打开此开关后，使用 Serial + Serial Old 的收集器组合进行内存回收
UseParNewGC 打开此开关后，使用 ParNew + Serial Old 的收集器组合进行内存回收
UseConcMarkSweepGC 使用 ParNew + CMS + Serial Old 的收集器组合进行内存回收。Serial Old 收集器将作为 CMS 收集器出现 Concurrent Mode Failure 失败后的后备收集器使用
UseParallelGC 虚拟机运行在 Server 模式下的默认值， 使用 Parallel Scavenge + Serial Old(PS MarkSweep) 的收集器组合进行内存回收
UseParallelOleGC 使用 Parallel Scavenge + Parallel Old 的收集器组合进行回收内存
ServivorRatio 新生代中 Eden 区域与 Survivor 区域的容量比值，默认为8，代表 Eden : Survivor=8 : 1
PretenureSizeThreshold 直接晋升老年代的对象大小，设置这个参数后，大于这个参数的对象将直接在老年代分配
MaxTenuringThreshold 晋升到老年代的对象年龄。每个对象在坚持过一次 Minor GC 之后，年龄旧增加1，当超过这个参数值就进入老年代
UseAdaptiveSizePolicy 动态调整 Java 堆中各个区域的大小以及进入老年代的年龄
HandlePromotionFailiure 是否允许分配担保失败，即老年代的剩余空间不足以应付新生代的整个 Eden 和 Survivor 区的所有对象都存活的极端情况
ParallelGCThreads 设置并行 GC 时进行内存回收的线程数
GCTimeRatio GC 时间占总时间的比率，默认值为99，即允许1%的 GC 时间。仅在使用 Parallel Scavenge 收集时生效
MaxGCPauseMillis 设置 GC 的最大停顿时间。仅在使用 Parallel Scavenge 收集器时生效
CMSInitiatingOccupancyFraction 设置 CMS 收集器在老年代空间被使用多少后触发垃圾收集。默认值68%，尽在使用CMS 收集器时生效
UseCMSCompactAtFullCollection 设置 CMS 收集器在完成垃圾收集后是否要进行一次内存碎片整理。仅在使用 CMS 收集器时生效
CMSFullGCsBeforeCompaction 设置 CMS 收集器在进行若干次垃圾收集后再启动一次内存碎片整理。仅在使用 CMS 收集器时生效
UseG1GC 使用 G1 (Garbage First) 垃圾收集器
文章作者: 何同昊
文章链接: http://hetonghao.cn/2020/03/jvm/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 何同昊 Blog！
Java8JVMJVM调优诊断、监控GC
支付宝超级火箭🚀
微信超级火箭🚀