JVM 虚拟机 ----> Java 内存模型(JMM)

文章目录

    • Java 内存模型(JMM)
      • 一、运行时数据区域划分
      • 二、程序计数器(Program Counter Register)
        • 计数器的作用
      • 三、Java 虚拟机栈(VM Stack)
      • 四、本地方法栈(Native Method Stack)
      • 五、堆(Heap)
        • 1、概述
        • 2、新生代、老年代
        • 3、创建对象的内存分配
      • 六、元空间(Meta Space)
        • 1、作用
        • 2、发展历程
          • (1)JDK 1.6
          • (2)JDK 1.7
          • (3)JDK 1.8
      • 七、字符串常量池
        • 1、字符串的两种创建方式
        • 2、intern() 方法
        • 3、String 的拼接

Java 内存模型(JMM)

JMM ,全称 Java Memory Model ,中文释义 Java 内存模型

一、运行时数据区域划分

  • JVM 虚拟机在执行 Java 程序过程中会把它管理的内存划分成若干个不同的数据区域‘
  • JDK 1.8 之前分为:线程共享Heap堆区、Method Area方法区)、线程私有(虚拟机栈、本地方法栈、程序计数器)
  • JDK 1.8分为:线程共享Heap堆区、MetaSpace 元空间)、线程私有(虚拟机栈、本地方法栈、程序计数器)

JVM 虚拟机 ----> Java 内存模型(JMM)_第1张图片

JVM 虚拟机 ----> Java 内存模型(JMM)_第2张图片

二、程序计数器(Program Counter Register)

程序计数器是一块较小的内存空间,是当前线程所执行的字节码的行号指示器

  • 字节码解释器在解释执行字节码文件工作时,每当需要执行一条字节码指令时,就通过改变程序计数器的值来完成。程序中的分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完成。
  • 程序执行过程中,会不断的切换当前执行线程,切换后,为了能让当前线程恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,并且各线程之间计数器互不影响,独立存储。

计数器的作用

  1. 字节码解释器通过改变程序计数器来依次读取指令,从而实现代码的流程控制,如:顺序执行、选择、循环、异常处理
  2. 在多线程的情况下,程序计数器用于记录当前线程执行的位置,从而当线程被切换回来的时候,能够知道当前线程的运行位置
  3. 程序计数器是唯一一个不会出现 OutOfMemoryError的内存区域,它随着线程的创建而创建,随着线程的结束而死亡

三、Java 虚拟机栈(VM Stack)

与程序计数器一样,VM Stack虚拟机栈也是线程私有的,它的生命周期和线程相同,用于描述 Java 方法执行时的内存模型,每次方法调用的数据都是通过栈传递的。

JMM内存区域可以粗略的区分为堆内存(Heap)和栈内存 (Stack)。其中栈就是VM Stack虚拟机栈,或者说是虚拟机栈中局部变量表部分。

局部变量表主要存放了编译期可知的各种基本数据类型变量值(booleanbytecharshortintfloatlongdouble)、对象引用(reference 类型,它不同于对象本身,可能是一个指向对象起始地址的引用指针,也可能是指向一个代表对象的句柄或其他与此对象相关的位置)

JVM 虚拟机 ----> Java 内存模型(JMM)_第3张图片

Java 虚拟机栈是由一个个栈帧组成,而每个栈帧中都拥有:局部变量表操作数栈动态链接方法出口信息

每一次方法调用都会有一个对应的栈帧被压入 VM Stack虚拟机栈,每一个方法调用结束后,代表该方法的栈帧会从VM Stack虚拟机栈中弹出。

JVM 虚拟机 ----> Java 内存模型(JMM)_第4张图片

在活动线程中, 只有位于栈顶的帧才是有效的, 称为当前活动栈帧,代表正在执行的当前方法。

JVM执行引擎运行时, 所有指令都只能针对当前活动栈帧进行操作。虚拟机栈通过 poppush的方式,对每个方法对应的活动栈帧进行运算处理,方法正常执行结束,肯定会跳转到另一个栈帧上。

JVM 虚拟机 ----> Java 内存模型(JMM)_第5张图片

  • Java 方法有两种返回方式,不管哪种返回方式都会导致当前活动栈帧被弹出

    • return 语句
    • 抛出异常

Java 虚拟机栈会出现两种错误:StackOverFlowErrorOutOfMemoryError

  • StackOverFlowError:当线程请求栈的深度超过 JVM虚拟机栈的最大深度的时候,就抛出 StackOverFlowError 错误。
  • OutOfMemoryErrorJVM的内存大小可以动态扩展, 如果虚拟机在动态扩展栈时无法申请到足够的内存空间,则抛出OutOfMemoryError

四、本地方法栈(Native Method Stack)

本地方法栈用于虚拟机调用的 Native方法

native关键字修饰的本地方法被执行的时候,在本地方法栈中也会创建一个栈帧,用于存放该native本地方法的局部变量表、操作数栈、动态链接、方法出口信息。方法执行完毕后,相应的栈帧也会出栈并释放内存空间。也会出现 StackOverFlowErrorOutOfMemoryError两种错误

五、堆(Heap)

1、概述

Heap堆区,用于存放对象实例和数组的内存区域

Heap堆是JVM 所管理的内存中最大的一块区域,被所有线程共享的一块内存区域。堆区中存放对象实例,“几乎”所有的对象实例以及数组都在这里分配内存

Java 世界中“几乎”所有的对象都在堆中分配,但是,随着 JIT编译器的发展与逃逸分析技术逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化,所有的对象都分配到堆上也渐渐变得不那么“绝对”了。

JDK 1.7 开始已经默认开启逃逸分析,如果某些方法中的对象引用没有被返回或者未被外面使用(也就是未逃逸出去),那么对象可以直接在栈上分配内存

2、新生代、老年代

Heap 堆是 **垃圾收集器 GC(Garbage Collected)**管理的主要区域,因此堆区也被称为 GC堆(Garbage Collected Heap)

从垃圾回收的角度,由于现在收集器基本都采用分代垃圾收集算法,所以 JVM 中的堆区往往进行分代划分,例如:新生代老年代目的是更好地回收内存,或者更快地分配内存

JVM 虚拟机 ----> Java 内存模型(JMM)_第6张图片

Heap 堆区中的新生代、老年代的空间分配比例,可以通过java -XX:+PrintFlagsFinal -version命令查看

JVM 虚拟机 ----> Java 内存模型(JMM)_第7张图片

上述输出结果结果分析

  • InitialSurvivorRatio = 8

新生代Young(Eden/Survivor)空间的初始比例 = 8:代表Eden占新生代空间的80%

  • uintx NewRatio = 2

老年代Old / 新生代 Young的空间比例 = 2 : 代表老年代Old是新生代Young的2倍

因为新生代是由 Eden + s0 + s1 组成的,所以按照上述默认比例,如果 Eden` 区内存大小是 40M,那么两个 Survivor 区就是 5M,整个新生代区就是 50M,然后可以算出 Old 区内存大小是 100M,堆区总大小就是 150M

3、创建对象的内存分配

  • 创建一个新对象,在堆中分配内存
  • 大部分情况下,对象会在 Eden 区生成,当 Eden 区装满时,会触发 Young Garbage Collection,即 YGC 垃圾回收时,在 Eden 区实现清除策略,没有被引用的对象直接被回收
  • 依然存活的对象会被移送到 Survivor 区
  • Survivor 区分为 s0 和 s1 两块内存区域,每次 YGC 的时候,将存活的对象复制到未使用的 Survivor 空间(s0 或 s1),然后清空正在使用的空间,交换 s0 和 s1 的使用状态,每次交换时, 对象的Age+1
  • 如果 YGC 要移送的对象大于 Survivor 区容量的上限,则直接移交给老年代
  • 一个对象也不可能永远呆在新生代,JVM 中 一个对象从新生代晋升到老年代的阈值默认值是 15,可以在 Survivor区交换 14 次之后,晋升至老年代

JVM 虚拟机 ----> Java 内存模型(JMM)_第8张图片

堆区最容易出现的就是 OutOfMemoryError错误,这种错误的表现形式会有以下两种:

  1. OutOfMemoryError: GC Overhead Limit Exceeded JVM花太多时间执行垃圾回收,并且只能回收很少的堆空间时,就会发生此错误。
  2. OutOfMemoryError: Java heap space**:**假如在创建新的对象时, 堆内存中的空间不足以存放新创建的对象, 就会引发此错误。

此种情况,与配置的最大堆内存有关,且受制于物理内存大小。

六、元空间(Meta Space)

1、作用

用于存放 类信息常量静态变量JIT 即时编译器编译后的机器代码等数据

例如:java.lang.Object类的元信息、Integer.MAX_VALUE常量等

2、发展历程

(1)JDK 1.6

HotSpot JVM 使用Method Area方法区存储,也叫永久代(Permanent Generation)。

  1. 方法区和“永久代(Permanent Generation)”的区别:方法区是JVM 的规范,而永久代(Permanent Generation)是 JVM规范的一种实现,并且只有 HotSpot JVM才有永久代“Permanent Generation”,而对于其他类型的虚拟机,如 JRockit(Oracle)、J9(IBM) 并没有;
  2. 方法区是一片连续的堆空间,当JVM加载的类信息容量超过了最大可分配空间,虚拟机会抛出OutOfMemoryError:PermGenspaceError
  3. 永久代的GC是和老年代(old generation)捆绑在一起的,无论谁满了,都会触发永久代和老年代的垃圾收集。
  4. 可以通过 -XX:PermSize=N 设置 方法区 (永久代) 初始空间,-XX:MaxPermSize=N 设置方法区 (永久代) 最大空间,超过这个值将会抛出错误:java.lang.OutOfMemoryError: PermGen
(2)JDK 1.7

将字符串常量池、静态变量转移到了堆区。

(3)JDK 1.8

正式移除永久代,采用 Meta Space 元空间替代

元空间的本质和永久代类似,都是对JVM规范中方法区的一种具体实现。不过元空间与永久代之间最大的区别在于:元空间并不在虚拟机中,而是使用本地内存。因此,默认情况下,元空间的大小仅受本地内存限制,但可以通过运行参数来指定元空间的大小。

Java 8PermGen永久代为什么被移出 HotSpot JVM

  • 由于 PermGen 内存经常会溢出,容易抛出 java.lang.OutOfMemoryError: PermGen错误;
  • 移除 PermGen 可以促进 HotSpot JVMJRockit VM 的融合,因为 JRockit 没有永久代

**示例1:**不断的生成新的字符串,快速的消耗内存。通过 JDK 1.6JDK 1.7JDK 1.8 分别运行。

public class TestOOM {
  static String base = "ApeSource";
  public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    for (int i=0;i< Integer.MAX_VALUE;i++){
      String str = base + base;
      base = str;
      list.add(str.intern());
    }
  }
}

JVM 虚拟机 ----> Java 内存模型(JMM)_第9张图片

JVM 虚拟机 ----> Java 内存模型(JMM)_第10张图片

JVM 虚拟机 ----> Java 内存模型(JMM)_第11张图片

上述运行结果可以看出,相同的代码,在JDK 1.6 会出现“PermGen Space”的永久代内存溢出,而在 JDK 1.7JDK 1.8 中,会出现"Java heap space"堆内存溢出,并且 JDK 1.8PermSize MaxPermGen 参数已经无效。因此,在 JDK 1.7JDK 1.8 中,已经将字符串常量由永久代转移到堆中,并且 JDK 1.8 中已经完全移除了永久代,采用元空间来代替。

**示例2:**在 JDK 8下重新运行一下运行测试代码TestOOM,指定 MetaSpaceSizeMaxMetaSpaceSize的大小,输出结果如下:

JVM 虚拟机 ----> Java 内存模型(JMM)_第12张图片

  • -XX:MetaspaceSize**参数:主要控制Meta Space GC发生的初始阈值,也就是最小阈值,当使用的Meta Space 空间到达MetaspaceSize`**的时候,就会触发Metaspace的GC。
  • -XX:MaxMetaspaceSize参数:最大空间,默认是没有限制的。在jvm启动的时候,并不会分配MaxMetaspaceSize这么大的一块内存出来,metaspace是可以一直扩容的,直到到达MaxMetaspaceSize

JVM 虚拟机 ----> Java 内存模型(JMM)_第13张图片

七、字符串常量池

1、字符串的两种创建方式

  • 第一种方式是在常量池中获取字符串对象;
  • 第二种方式是直接在堆内存空间创建一个新的字符串对象
// 先检查字符串常量池中有没有"abcd",如果字符串常量池中没有,则创建一个,然后 str1 指向字符串常量池中的对象,如果有,则直接将 str1 指向"abcd"
String str1 = "apesource"; 
String str2 = new String("apesource"); //堆中创建一个新的对象
String str3 = new String("apesource"); //堆中创建一个新的对象

System.out.println(str1==str2); //false
System.out.println(str2==str3); //false

2、intern() 方法

  • 检查指定字符串在常量池中是否存在?如果存在,则返回地址,如果不存在,则在常量池中创建
String s1 = new String("Apesource");
String s2 = s1.intern(); // 查看字符串常量池中是否存在"Apesource",如果存在则返回地址,如果不存在,则在常量池中创建
String s3 = "Apesource"; // 使用常量池中的已有字符串常量"Apesource"

System.out.println(s2 == s3); // true,地址相同

3、String 的拼接

String str1 = "str";
String str2 = "ing";

String str3 = "str" + "ing"; // 常量池中的新字符串对象
String str4 = str1 + str2; // 在堆中创建的新字符串对象
String str5 = "string"; // 常量池中的已有字符串对象

System.out.println(str3 == str4); //false
System.out.println(str3 == str5); //true
System.out.println(str4 == str5); //false

JVM 虚拟机 ----> Java 内存模型(JMM)_第14张图片

  • String s1 = new String("abc");这句代码创建了几个字符串对象?

创建 12 个字符串。如果常量池中已存在字符串常量“abc”,则只会在堆空间创建一个字符串常量“abc

如果常量池中没有字符串常量“abc”,那么它将首先在池中创建,然后在堆空间中创建,因此将创建总共2 个字符串对象

你可能感兴趣的:(jvm,java,开发语言)