JVM调优基础篇-内存模型

最新推荐文章于 2022-01-16 23:14:56 发布

azhida

最新推荐文章于 2022-01-16 23:14:56 发布

阅读量261

点赞数 4

分类专栏： jvm 文章标签： jvm

本文链接：https://blog.csdn.net/azhida/article/details/106291892

版权

jvm 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

阅读完本文你可以获得什么？

了解JVM调优三步曲
熟悉JVM内存模型
了解方法区、永久代、元空间的区别
知道为什么JDK8后从永久代变成了元空间
了解CLASS文件格式

本文目的

JVM调优，通俗的来讲分为三步：事前、事中、事后。

事前：是项目上线前根据对象大小，和预估流量进行计算，看看新生代、老年代、方法区，应该怎么设置大小

事中：是项目上线期间在还没有发生OOM之前根据GC的情况进一步判断参数配置

事后：是发生OOM后根据“现场”情况,排除代码问题内存泄漏等情况，对多个代的参数配置进行进一步的修改

可以看到调优不管是在哪个阶段，都是优化不同分代的参数，所以有必要带领大家回顾一下JVM内存模型。

本文是JVM调优基础篇第二篇，前一篇文章已经讲述了怎么计算对象的大小怎么计算对象的大小没看过的同学可以自行查看。

本文会先概括讲述一下JVM的数据类型和内存模型都包括什么东西？然后对每个模块一一深入解释

数据类型

primitive types ：原始类型
reference types：引用类型

像Java编程语言一样，Java虚拟机可对两种类型进行操作：原始类型和引用类型。相应地，可以将两种类型的值存储在变量中，作为参数传递，由方法返回并对其进行操作：原始值和引用值。

内存模型概述

JVM内存模型整体上来看分为三部分：类加载子系统、执行引擎、运行时数据区。

JVM内存模型
因为本文的出发点是回顾运行时数据区各代的大小，所以不会详细介绍类加载子系统和执行引擎的相关细节。

类加载子系统

JVM通过类加载器把Class文件从磁盘（一般是）读取到内存中对应的是Class Content ，然后经过JVM虚拟机规范的检查和编译，生成Class对象。

类加载的流程一般都是采用双亲委派模型，然后经历加载、验证、准备、解析、初始化、使用、直到卸载。有关类加载的流程就不在这详细展开了，只说一下Class文件。

在虚拟机规范中只是制定了一个JVM的抽象概念。它没有描述Java虚拟机的任何特定实现。规范中说要正确实现Java虚拟机，我们仅需要能够读取类文件格式并正确执行其中指定的操作，可见Class文件的重要性。

Class文件

Class文件是一组已8位字节为基础长度的二进制字节流，各个数据项目严格按顺序紧凑的排列在 Class 文件中，中间没有添加任何分隔符。

当遇到需要占用超过8字节长度的数据项时，会按照高位在前的方式分割成若干个8个字节来存储

Class 文采用类似于C语言结构体的伪结构存放数据，这种结构只有两种数据类型：无符号数和表

无符号数属于基本数据类型：以 U1 U2 U4 U8 来代表 1 ，2，4，8 个字节的无符号数；无符号数可以用来描述数字，索引引用，数量值或者按照UTF-8编码的字符串值
表是由多个无符号数或其他表作为数据项构成的复合数据类型，所有的表都习惯性的以“_info” 结尾。整个 Class 文件本质上就是一个表。

Class文件格式

1、魔数

每个 Class 文件头的四个字节称为魔数，它的唯一作用是确定一个 Class 文件是否是可以被虚拟机加载的

2、版本号

有两个版本号小版本号、和主版本号，一共使用四字节来表示。Java的版本号是从45开始的

类加载验证时会起作用，高版本可以运行低版本，反之不能。

3、常量池

由于常量池的数量不是固定的，所以在常量池的入口放置一项U2类型的数据，代表常量池的容量计数值

Class文件中只有常量池的文件计数是从1开始的，0有特殊的作用（来表示不引用任何一个常量池的特殊的含义）

常量池中存放两种数据：字面量、符号引用

字面量

字面量比较接近 Java 语言层面的常量的概念

文本字符串，声明为 final 的常量值等

符号引用

类和接口的全限定名

字段的名称和描述符

方法的名称和描述符

4、访问标志

这个标志用于识别一些类或接口层次的访问信息，包括：这个 class 是类还是接口，是否定义为 public 类型，是否定义为 abstract 类型，如果是类的话是否声明为 final 类型等。

5、类索引、父类索引与接口索引集合

类索引 “this_class” 和父索引 “super_class” 都是一个U2类型的数据，而接口索引集合是一组U2类型数据的集合，Class 文件通过这三个数据项来确定这个类的继承关系。

和常量池一样接口索引集合的大小也是不固定的，所以前边放置了一个U2类型的数值来表示接口索引的大小。下边的方法表、字段表、属性表都是类似，下边不会再赘述。

6、字段表集合

字段表用来描述接口或者类中声明的变量

7、方法表集合

方法表用来描述接口或者类中声明的方法
方法表集合信息

8、属性表集合

在Class文件、字段表、方法表中都可以携带自己的属性表集合，以用于描述某些场景专有的信息。

属性表集合

字节码指令

Java 虚拟机的指令由一个字节长度的代表着某种特定操作含义的数字（称为操作码），以及紧跟其后的多个代表此操作所需参数（称为操作数）而构成。

由于虚拟机采用面向操作数栈而不是寄存器的架构，所以大多数的指令都不包含操作数，只有一个操作码。

字节码和数据类型

加载和存储指令
用于将数据在栈桢中的局部变量表和操作数栈之间来回传输。
运算指令
运算指令用于对两个操作数栈上的值进行某中特定的运算，并把结果重新存入到操作数栈
类型转换指令
可以将两种不同类型数数值进行相互转换。
对象创建和访问指令
操作数栈管理指令
控制转移指令
方法调用和返回指令
异常处理指令
同步指令
java 虚拟机可以支持方法的同步和方法内部一段指令序列的同步，这两种同步结构都是使用管程（Monitor）来支持的
方法级的同步是隐式的，既无需通过字节码指令来控制。它实现在方法调用和返回的操作之中。
同步一段指令集序列通常是由 java 语言中的 synchronize 语句块来表示的，java 虚拟机指令级中有 monitorenter 和 monitorexist 两条指令来支持 synchronize 语义的

具体的命令可以看我的另一篇文章: JVM指令手册

实例

有如下类

public class APP {

    private static int i = 1;

    private int b = 1;

    public static void main(String[] args) {
        APP app = new APP();
        app.add(1);
        System.out.println(i);
    }

    private void add(int param) {
        i += param;
    }

}

通过 jclasslib 看它的class文件结构：

General info

通过javap -verbose App查看详细信息

警告: 二进制文件App包含org.learn.code.jvm.APP
Classfile ./target/classes/org/learn/code/jvm/App.class
  Last modified 2020-5-23; size 773 bytes
  MD5 checksum fa818076b88cec56e09844e32bfcdfd1
  Compiled from "APP.java"
public class org.learn.code.jvm.APP
  // 次版本
  minor version: 0
  // 大版本
  major version: 49
  //访问标示
  flags: ACC_PUBLIC, ACC_SUPER
  //常量池
Constant pool:
   #1 = Methodref          #9.#31         // java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#32         // org/learn/code/jvm/APP.b:I
   #3 = Class              #33            // org/learn/code/jvm/APP
   #4 = Methodref          #3.#31         // org/learn/code/jvm/APP."<init>":()V
   #5 = Methodref          #3.#34         // org/learn/code/jvm/APP.add:(I)V
   #6 = Fieldref           #35.#36        // java/lang/System.out:Ljava/io/PrintStream;
   #7 = Fieldref           #3.#37         // org/learn/code/jvm/APP.i:I
   #8 = Methodref          #38.#39        // java/io/PrintStream.println:(I)V
   #9 = Class              #40            // java/lang/Object
  #10 = Utf8               i
  #11 = Utf8               I
  #12 = Utf8               b
  #13 = Utf8               <init>
  #14 = Utf8               ()V
  #15 = Utf8               Code
  #16 = Utf8               LineNumberTable
  #17 = Utf8               LocalVariableTable
  #18 = Utf8               this
  #19 = Utf8               Lorg/learn/code/jvm/APP;
  #20 = Utf8               main
  #21 = Utf8               ([Ljava/lang/String;)V
  #22 = Utf8               args
  #23 = Utf8               [Ljava/lang/String;
  #24 = Utf8               app
  #25 = Utf8               add
  #26 = Utf8               (I)V
  #27 = Utf8               param
  #28 = Utf8               <clinit>
  #29 = Utf8               SourceFile
  #30 = Utf8               APP.java
  #31 = NameAndType        #13:#14        // "<init>":()V
  #32 = NameAndType        #12:#11        // b:I
  #33 = Utf8               org/learn/code/jvm/APP
  #34 = NameAndType        #25:#26        // add:(I)V
  #35 = Class              #41            // java/lang/System
  #36 = NameAndType        #42:#43        // out:Ljava/io/PrintStream;
  #37 = NameAndType        #10:#11        // i:I
  #38 = Class              #44            // java/io/PrintStream
  #39 = NameAndType        #45:#26        // println:(I)V
  #40 = Utf8               java/lang/Object
  #41 = Utf8               java/lang/System
  #42 = Utf8               out
  #43 = Utf8               Ljava/io/PrintStream;
  #44 = Utf8               java/io/PrintStream
  #45 = Utf8               println
  //方法表
{
//构造方法
  public org.learn.code.jvm.APP();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
    //操作数栈  基部变量表   参数
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_1
         6: putfield      #2                  // Field b:I
         9: return
         //源码行号  ：字节码指令
      LineNumberTable:
        line 3: 0
        line 7: 4
        //局部变量表
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  this   Lorg/learn/code/jvm/APP;
	//main方法
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #3                  // class org/learn/code/jvm/APP
         3: dup
         4: invokespecial #4                  // Method "<init>":()V
         7: astore_1
         8: aload_1
         9: iconst_1
        10: invokespecial #5                  // Method add:(I)V
        13: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        16: getstatic     #7                  // Field i:I
        19: invokevirtual #8                  // Method java/io/PrintStream.println:(I)V
        22: return
      LineNumberTable:
        line 10: 0
        line 11: 8
        line 12: 13
        line 13: 22
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      23     0  args   [Ljava/lang/String;
            8      15     1   app   Lorg/learn/code/jvm/APP;
//静态快
  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: iconst_1
         1: putstatic     #7                  // Field i:I
         4: return
      LineNumberTable:
        line 5: 0
}
//属性信息
SourceFile: "APP.java"

执行引擎

执行引擎分为两种：基于栈的解释执行和基于寄存器的

java 编译器输出的指令流，基本上是一种基于栈的指令集架构，指令流中的指令带部分都是零地址指令，他们依赖操作数栈进行工作。

基于寄存器的指令集，指令中带有地址

基于栈的指令集的优点是：可以移植，寄存器由硬件直接提供，程序直接依赖这些硬件寄存器则不可避免的要收到硬件的约束，

基于栈的指令集的缺点：相对来说慢

运行时数据区

内存结构

概览见上边的整体图示

由于1.6、1.7、1.8 各个版本直间有差异所以再给大家画的具体一点

1.6时

1.6

1.7时

1.7

1.8时

1.8

堆

线程共享，几乎所有对象都在这里分配内存，是垃圾收集的主要区域（“GC 堆”）
最小 1/64 最大 1/4

堆的划分

从内存分配的角度来看

可能会划分出多个线程私有的分配缓冲区TLAB

从内存回收的角度来看

现代的垃圾收集器基本都是采用分代收集算法，其主要的思想是将堆逻辑上分成两块：新生代、老年代，针对不同类型的对象采取不同的垃圾回收算法。

新生代
分为 Surviver和 Eden
Eden与Surviver区域默认比例8:1:1 需要指定比例不然不会走默认。
Surviver：分为平等对称的2块，From Survivor 空间（s0）、To Survivor 空间（s1)

为什么新生代又拆分出两块？且大小不同

在新生代中，每次垃圾收集时都发现有大批对象死去，只有少量存活，
所以使用复制算法进行垃圾回收，如果采用一半一半的配置，那将会有一半的空间浪费，具hotSpot官方调查，新生代大约会有85%的对象时每次都会回收的，所以制定了8:1:1 既可以防止碎片还能节约空间。

老年代
老年代中存活的对象主要有三种：长期存活的对象和大对象（enden区分配不了的）另外还有空间分配担保产生的对象

因为对象存活率高、没有额外空间对它进行分配担保所以内存设置会比新生代大。

控制参数

可以通过 -Xms 和 -Xmx 两个虚拟机参数来指定一个程序的堆内存大小，
第一个参数设置初始值，第二个参数设置最大值。-Xmn:新生代大小

异常情况

会发生OOM

方法区

用于存放已被加载的类信息，静态变量、即时编译器编译后的代码等数据。
1.7及之前：是JVM内存中的一部分数据区成为老年代
1.8之后：从虚拟机内存中移除，在堆外开辟空间，受机物理体内存大小的限制称为元空间

方法区、老年代、元空间的区别？

方法区是JVM中定义的规范，该规范只定义了这个区中一般放什么，并没有规定这块内存要放在什么位置，回收策略是什么。

老年代和元空间只是他们的一种具体的实现。

为什么从老年代替换成元空间？

个人感觉有很多种原因

sun和hotspot合并 sun原来是元空间所以合并之后hotspot 改成了元空间
早期受机器内存大小的限制，后来可使用的内存大小变大了
早期都是32位机，能使用的最大内存是2³²=4G，如果老年代不放在堆中受控制，那么加载的时候可能会无限的使用这块有限的内存，最终会影响其他的应用程序。
现在大多数都是64位机，除了16字节的保留位，能使用的最大内存是2⁴⁸ 这都是好几T的数据了，一般类加载是大到不了的所以不用太关心这块内存的使用
还有一个可能是业务的发展，需要加载的class文件越来越多

控制参数

1.7及之前配置老年代
-XX:PermSize 设置最小空间 -XX:MaxPermSize 设置最大空间。

1.8及之后配置元空间
变为元空间后如果不设置大小理论上只受物理机内存大小限制
最小是 20.75 M
-XX:MetaspaceSize=N和 -XX:MaxMetaspaceSize=N 来指定最大最小值

和堆区一样，为了防止动荡一般建议在JVM参数中将MetaspaceSize和MaxMetaspaceSize设置成一样的值。

异常情况

动态扩展失败一样会抛出 OutOfMemoryError 异常。

运行时常量池

1.6时：运行时常量池存在堆中
1.7时：运行时常量池放在方法区中
1.8时：运行时常量池放在堆中方法区从JVM内存中移除，在堆外开辟了空间（元空间）存放方法区中的数据
除了在编译期生成的常量，还允许动态生成，例如 String 类的 intern()。
Class 文件中的常量池（编译器生成的各种字面量和符号引用）会在类加载后被放入这个区域。

虚拟机栈

虚拟机栈，每个线程所独有，存放的是局部变量和对象的引用。

栈里面存放的是栈帧方法的执行和调用就是一个栈针出栈入栈的过程。

对象也可以在栈上分配，看我的这篇文章怎么计算对象的大小

栈帧

栈帧按虚拟机规范分为：操作数栈、局部变量表、动态链接、返回地址、其他信息。
在hotspot中没有其他信息，上面的图中用虚线标示

操作数栈

JVM是基于栈的解释执行，每条指令没有地址，是通过操作数和局部变量表来进行操作。

局部变量表

包括入参和局部变量

动态链接

代表的是方法的直接地址，方法调用是需要拿到直接地址进行调用

返回地址

返回地址的作用，用来恢复操作数栈的指针和局部变量表的指针，并且如果有返回值，也会把返回值入另一方法的局部变量表

寄存器的值应该也会恢复（存疑）。

控制参数

默认大小为1M 最小为160K 可以通过 -Xss 来控制

异常情况

会发生OOM 分两种情况

栈深度不够，一般是递归调用
没有内存给新创建的栈

本地方法栈

本地方法栈和虚拟机栈类似，也会有OOM只不过是在运行Native方法时使用的。

程序计数器/PC寄存器

如果执行的方法不是本地方法，则计数器包含当前正在执行的Java虚拟机指令的地址。如果线程当前正在执行的方法是本地方法，则Java虚拟机的pc寄存器的值未定义。

Java虚拟机的pc寄存器足够宽，可以在特定平台上保存returnAddress或本机指针。

字节码解释器工作时，就是通过改变这个计数器的值来选取下一条需要执行的字节码指令
是唯一一个不会产生OOM的区域

azhida

关注

4
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JVM调优基础篇-内存模型

JVM内存模型阅读完本文你可以获得什么？本文目的内存模型概述类加载子系统阅读完本文你可以获得什么？了解JVM调优三步曲熟悉JVM内存模型了解方法区、永久代、元空间的区别知道为什么JDK8后从永久代变成了元空间了解CLASS文件格式本文目的JVM调优，通俗的来讲分为三步：事前、事中、事后。事前：是项目上线前根据对象大小，和预估流量进行计算，看看新生代、老年代、方法区，应该怎么设置大小事中：是项目上线期间在还没有发生OOM之前根据GC的情况进一步判断参数配置事后：是发生OOM后根据“
复制链接

扫一扫