【深入理解Java虚拟机】读书笔记——Java内存区域与内存溢出异常

最新推荐文章于 2022-07-24 20:51:37 发布

Allen Chou

最新推荐文章于 2022-07-24 20:51:37 发布

阅读量286

点赞数

分类专栏： # JVM 文章标签： jvm java

本文链接：https://blog.csdn.net/Vermont_/article/details/113789069

版权

JVM 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文详细介绍了Java内存区域的五个部分：程序计数器、虚拟机栈、本地方法栈、Java堆和方法区，以及直接内存。讨论了各区域的作用、可能出现的异常，特别是内存溢出（OOM）的情况。Java堆是存放对象实例的主要区域，方法区存储类信息和运行时常量池，直接内存用于NIO。当内存不足时，可能导致Java堆、虚拟机栈和直接内存溢出。处理方法包括使用内存分析工具定位问题、调整虚拟机参数等。

摘要由CSDN通过智能技术生成

Java内存区域与内存溢出异常

一、运行时数据区域

总共也就这么 5 个区（直接内存不属于 JVM 运行时数据区的一部分），除了程序计数器其他的地方都有可能出现 OOM (OutOfMemoryError)，其中像是程序计数器和两个栈（Java 虚拟机栈 & 本地方法栈）都是每个线程要有一个的，所以肯定是线程隔离的。而其他 2 个区就是线程共享的了，也就是说，如果有多个线程要同时访问这两个区的数据，是会出现线程安全问题的。

程序计数器

当前线程所执行的字节码的行号指示器，字节码解释器工作时就是通过改变这个计数器的值来确定下一条要执行的字节码指令的位置
执行 Java 方法和 native 方法时的区别：
- 执行 Java 方法时：记录虚拟机正在执行的字节码指令地址；
- 执行 native 方法时：无定义；
是 5 个区域中唯一不会出现 OOM 的区域。

Java 虚拟机栈

Java 方法执行的内存模型，每个方法执行的过程，就是它所对应的栈帧在虚拟机栈中入栈到出栈的过程；
服务于 Java 方法；
可能抛出的异常：
- OutOfMemoryError（在虚拟机栈可以动态扩展的情况下，扩展时无法申请到足够的内存）；
- StackOverflowError（线程请求的栈深度 > 虚拟机所允许的深度）；
虚拟机参数设置：-Xss.

本地方法栈

服务于 native 方法；
可能抛出的异常：与 Java 虚拟机栈一样。

Java 堆

唯一的目的：存放对象实例；
垃圾收集器管理的主要区域；
可以处于物理上不连续的内存空间中；
可能抛出的异常：
- OutOfMemoryError（堆中没有内存可以分配给新创建的实例，并且堆也无法再继续扩展了）。
虚拟机参数设置：
- 最大值：-Xmx
- 最小值：-Xms
- 两个参数设置成相同的值可避免堆自动扩展。

方法区

存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据；
- 类信息：即 Class 类，如类名、访问修饰符、常量池、字段描述、方法描述等。
垃圾收集行为在此区域很少发生；
- 不过也不能不清理，对于经常动态生成大量 Class 的应用，如 Spring 等，需要特别注意类的回收状况。
运行时常量池也是方法区的一部分；
- Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项是常量池，用于存放编译器生成的各种字面量（就是代码中定义的 static final 常量）和符号引用，这部分信息就存储在运行时常量池中。
可能抛出的异常：
- OutOfMemoryError（方法区无法满足内存分配需求时）。

方法区关键信息介绍

1.类信息：修饰符(public final)

是类还是接口(class,interface)

类的全限定名(Test/ClassStruct.class)

直接父类的全限定名(java/lang/Object.class)

直接父接口的权限定名数组(java/io/Serializable)

　　也就是 public final class ClassStruct extends Object implements Serializable这段描述的信息提取

2.字段信息：修饰符(pirvate)

字段类型(java/lang/String.class)

字段名(name)

　　也就是类似private String name;这段描述信息的提取

3.方法信息:修饰符(public static final)

方法返回值(java/lang/String.class)

方法名(getStatic_str)

参数需要用到的局部变量的大小还有操作数栈大小(操作数栈我们后面会讲)

方法体的字节码(就是花括号里的内容)

异常表(throws Exception)

　　也就是对方法public static final String getStatic_str ()throws Exception的字节码的提取
4.常量池:

4.1.直接常量：

1.1CONSTANT_INGETER_INFO整型直接常量池public final int CONST_INT=0;

1.2CONSTANT_String_info字符串直接常量池 public final String CONST_STR="CONST_STR";

1.3CONSTANT_DOUBLE_INFO浮点型直接常量池

等等各种基本数据类型基础常量池(待会我们会反编译一个类，来查看它的常量池等。)

4.2.方法名、方法描述符、类名、字段名，字段描述符的符号引用

也就是所有编译器能够被确定，能够被快速查找的内容都存放在这里，它像数组一样通过索引访问，就是专门用来做查找的。

编译时就能确定数值的常量类型都会复制它的所有常量到自己的常量池中，或者嵌入到它的字节码流中。作为常量池或者字节码流的一部分，编译时常量保存在方法区中，就和一般的类变量一样。但是当一般的类变量作为他们的类型的一部分数据而保存的时候，编译时常量作为使用它们的类型的一部分而保存

5.类变量(静态变量）：

就是静态字段( public static String static_str="static_str";)

虚拟机在使用某个类之前，必须在方法区为这些类变量分配空间。

6.一个到classLoader的引用，通过this.getClass().getClassLoader()来取得为什么要先经过class呢？思考一下，看一下上面的图，再回来思考。(class A 对象拥有A字节码和加载它的加载器地址引用)

7.一个到class对象的引用，这个对象存储了所有这个字节码内存块的相关信息。所有你能够看到的区域，比如：类信息，你可以通过this.getClass().getName()取得

所有的方法信息，可以通过this.getClass().getDeclaredMethods()，字段信息可以通过this.getClass().getDeclaredFields()，等等，所有在字节码中你想得到的，调用的，通过class这个引用基本都能够帮你完成。因为他就是字节码在内存块在堆中的一个对象

8.方法表，如果学习c++的人应该都知道c++的对象内存模型有一个叫虚表的东西，java本来的名字就叫c++- -，它的方法表其实说白了就是c++的虚表，它的内容就是这个类的所有实例可能被调用的所有实例方法的直接引用。也是为了动态绑定的快速定位而做的一个类似缓存的查找表，它以数组的形式存在于内存中。不过这个表不是必须存在的，取决于虚拟机的设计者，以及运行虚拟机的机器是否有足够的内存。

直接内存

JDK 1.4 的 NIO 类可以使用 native 函数库直接分配堆外内存，这是一种基于通道与缓冲区的 I/O 方式，它在 Java 堆中存储一个 DirectByteBuffer 对象作为堆外内存的引用，这样就可以对堆外内存进行操作了。因为可以避免 Java 堆和 Native 堆之间来回复制数据，在一些场景可以带来显著的性能提高。
虚拟机参数设置：-XX:MaxDirectMemorySize
- 默认等于 Java 堆最大值，即 -Xmx 指定的值。
将直接内存放在这里讲解的原因是它也可能会出现 OutOfMemoryError；
- 服务器管理员在配置 JVM 参数时，会根据机器的实际内存设置 -Xmx 等信息，但经常会忽略直接内存（默认等于 -Xmx 设置值），这可能会使得各个内存区域的总和大于物理内存限制，从而导致动态扩展时出现 OOM。

HotSpot 虚拟机堆中的对象

这一小节将对 JVM 对 Java 堆中的对象的创建、布局和访问的全过程进行讲解。

对象的创建（遇到一条 new 指令时）

检查这个指令的参数能否在常量池中定位到一个类的符号引用，并检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，先把这个类加载进内存；
类加载检查通过后，虚拟机将为新对象分配内存，此时已经可以确定存储这个对象所需的内存大小；
在堆中为新对象分配可用内存；
将分配到的内存初始化；
设置对象头中的数据；
此时，从虚拟机的角度看，对象已经创建好了，但从 Java 程序的角度看，对象创建才刚刚开始，构造函数还没有执行。

第 3 步，在堆中为新对象分配可用内存时，会涉及到以下两个问题：

如何在堆中为新对象划分可用的内存？

指针碰撞（内存分配规整）
- 用过的内存放一边，没用过的内存放一边，中间用一个指针分隔；
- 分配内存的过程就是将指针向没用过的内存那边移动所需的长度；
空闲列表（内存分配不规整）
- 维护一个列表，记录哪些内存块是可用的；
- 分配内存时，从列表上选取一块足够大的空间分给对象，并更新列表上的记录；

如何处理多线程创建对象时，划分内存的指针的同步问题？

对分配内存空间的动作进行同步处理（CAS）；
把内存分配动作按照线程划分在不同的空间之中进行；
- 每个线程在 Java 堆中预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer，TLAB）；
- 哪个线程要分配内存就在哪个线程的 TLAB 上分配，TLAB 用完需要分配新的 TLAB 时，才需要同步锁定；
- 通过 -XX:+/-UseTLAB 参数设定是否使用 TLAB。

对象的内存布局

对象头：
- 第一部分：存储对象自身运行时的数据，HashCode、GC分代年龄等（Mark Word）；
- 第二部分：类型指针，指向它的类元数据的指针，虚拟机通过这个指针来判断这个对象是哪个类的实例（HotSpot 采用的是直接指针的方式访问对象的）；
- 如果是个数组对象，对象头中还有一块用于记录数组长度的数据。
实例数据：
- 默认分配顺序：longs/doubles、ints、shorts/chars、bytes/booleans、oops (Ordinary Object Pointers)，相同宽度的字段会被分配在一起，除了 oops，其他的长度由长到短；
- 默认分配顺序下，父类字段会被分配在子类字段前面。

注：HotSpot VM要求对象的起始地址必须是8字节的整数倍，所以不够要补齐。

对象的访问

Java 程序需要通过虚拟机栈上的 reference 数据来操作堆上的具体对象，reference 数据是一个指向对象的引用，不过如何通过这个引用定位到具体的对象，目前主要有以下两种访问方式：句柄访问和直接指针访问。

句柄访问

句柄访问会在 Java 堆中划分一块内存作为句柄池，每一个句柄存放着到对象实例数据和对象类型数据的指针。

实例数据：对象真正存储的有效信息,即字段内容。

优势：对象移动的时候（这在垃圾回收时十分常见）只需改变句柄池中对象实例数据的指针，不需要修改reference本身。

直接指针访问

直接指针访问方式在 Java 堆对象的实例数据中存放了一个指向对象类型数据的指针，在 HotSpot 中，这个指针会被存放在对象头中。

优势：减少了一次指针定位对象实例数据的开销，速度更快。

OutOfMemoryError异常实战

1. 堆溢出

-Xms：堆最小值
-Xmx：堆最大值
-XX:+HeapDumpOnOutOfMemoryError HeapOOM：在出现内存溢出异常的时候Dump出当前的内存堆转储快照

测试用例：

java -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError HeapOOM

package com.jvm;

import java.util.ArrayList;
import java.util.List;

/**
 * @author ：jhys
 * @date ：Created in 2021/2/11 13:32
 * @Description ：
 */
public class OOM {
    static class OOMObject {

    }

    public static void main(String[] args) {
        List<OOMObject> list = new ArrayList<>();
        while (true) {
            list.add(new OOMObject());
        }
    }
}

在IDEA里面，设置VM options，

输出结果：

java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid11756.hprof ...
Heap dump file created [28176952 bytes in 0.097 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Arrays.java:3210)
	at java.util.Arrays.copyOf(Arrays.java:3181)
	at java.util.ArrayList.grow(ArrayList.java:261)
	at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235)
	at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227)
	at java.util.ArrayList.add(ArrayList.java:458)
	at com.jvm.OOM.main(OOM.java:19)

处理方法：常规的处理方法是首先通过内存映像分析工具(如Eclipse Memory Analyzer)对Dump出来的堆转储快照进行分析。
首先应确认内存中导致OOM的对象是否是必要的,也就是要先分清楚到底是出现了内存泄漏(Memory Leak)还是内存溢出(Memory Overflow)。

内存泄漏：可进一步通过工具查看泄漏对象到GC Roots的引用链,找到泄漏对象是通过怎样的引用路径、与哪些GC Roots相关联,才导致垃圾收集器无法回收它们。
内存溢出：检查Java虚拟机的堆参数(-Xmx与-Xms)设置,与机器的内存对比,看看是否还有向上调整的空间。再从代码上检查是否存在某些对象生命周期过长、持有状态时间过长、存储结构设计不合理等情况,尽量减少程序运行期的内存消耗。

Java 堆溢出

出现标志：java.lang.OutOfMemoryError: Java heap space
解决方法：
- 先通过内存映像分析工具分析 Dump 出来的堆转储快照，确认内存中的对象是否是必要的，即分清楚是出现了内存泄漏还是内存溢出；
- 如果是内存泄漏，通过工具查看泄漏对象到 GC Root 的引用链，定位出泄漏的位置；
- 如果不存在泄漏，检查虚拟机堆参数（-Xmx 和 -Xms）是否可以调大，检查代码中是否有哪些对象的生命周期过长，尝试减少程序运行期的内存消耗。
虚拟机参数：
- -XX:HeapDumpOnOutOfMemoryError：让虚拟机在出现内存泄漏异常时 Dump 出当前的内存堆转储快照用于事后分析。

Java 虚拟机栈和本地方法栈溢出

单线程下，栈帧过大、虚拟机容量过小都不会导致 OutOfMemoryError，只会导致 StackOverflowError（栈会比内存先爆掉），一般多线程才会出现 OutOfMemoryError，因为线程本身要占用内存；
如果是多线程导致的 OutOfMemoryError，在不能减少线程数或更换 64 位虚拟机的情况，只能通过减少最大堆和减少栈容量来换取更多的线程；
- 这个调节思路和 Java 堆出现 OOM 正好相反，Java 堆出现 OOM 要调大堆内存的设置值，而栈出现 OOM 反而要调小。