JVM之内存管理

一、 JVM内存管理

1.1 JVM内存区域结构

1.1.1 程序计数器

程序计数器(Program Counter Register)是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器。
在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现)，字节码解释器工作时就是通过改变这个计数器的值来选下一条需要执行的字节码指合，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

1.1.2 Java虚拟机栈

与程序计数器一样，Java虚拟机栈(Java Virtual Machine Stacks)也是线程私有的，它的生命周期与线程相同。
虚拟机栈描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧(Stack Frame")用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

1.1.3 本地方法栈

本地方法栈(Native Method Stack)与虚拟机栈所发挥的作用是非常相似的，它们之间的区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的Native:方法服务。
在虚拟机规范中对本地方法栈中方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机（譬如Sun HotSpot虚拟机)直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法栈区域也会抛出StackOverflowError和OutOfMemoryError异常。

1.1.4 Java 堆

对于大多数应用来说，Java堆(Java Heap)是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。
这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配皿，但是随着JIT编译器的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换回优化技术将会导致一些微妙的变化发生，所有的对象都分配在堆上也渐渐变得不是那么“绝对”了。

Java堆是垃圾收器管理的主要区域，很多时候也被称为“GC堆 ”。
Java堆可以分为新生代(Young Generation)和老年代(Old Generation)。新生代又分为Eden Space、Survivor Space1和Survivor Space2三部分。

1.1.5 方法区

方法区(Method Area)与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap(非堆)，目的应该是与Java堆区分开来。
方法区也称为永久代(Permanent Generation)，在JDK8及之后的版本中，永久代已经被元空间(Metaspace)所取代。

1.1.6 运行时常量池

运行时常量池(Runtime Constant Pool)是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池(Constant Pool Table)，,用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后进入方法区的运行时常量池中存放。
运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只有编译期才能产生，也就是并非预置入Clss文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用得比较多的便是String类的intern()方法。

1.1.7 直接内存

直接内存(Direct Memory)并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域。但是这部分内存也被频繁地使用，而且也可能导致DutOfMemoryError异常出现。

使用直接内存

在Java中，直接内存主要通过ByteBuffer类来使用。可以通过ByteBuffer类的allocateDirect()方法来分配直接内存空间，返回一个DirectByteBuffer对象。DirectByteBuffer对象实际上是对直接内存的封装，可以通过它的put()、get()等方法来读写数据。使用完直接内存之后，需要通过调用DirectByteBuffer对象的clean()方法来释放直接内存空间。

import java.nio.ByteBuffer;

public class DirectMemoryExample {
    public static void main(String[] args) {
        int bufferSize = 1024 * 1024; // 1MB
        ByteBuffer buffer = ByteBuffer.allocateDirect(bufferSize);
        buffer.put("Hello, direct memory!".getBytes());
        buffer.flip();
        byte[] bytes = new byte[bufferSize];
        buffer.get(bytes);
        System.out.println(new String(bytes));
        ((sun.nio.ch.DirectBuffer)buffer).cleaner().clean();
    }
}

在这个示例中，我们使用allocateDirect()方法分配了一个大小为1MB的直接内存空间，并将一段文本数据写入到该空间中。然后通过flip()方法将Buffer的读写指针移动到数据的开头，再通过get()方法将数据读取出来，并将其输出到控制台上。最后，我们调用DirectByteBuffer对象的clean()方法释放直接内存空间。需要注意的是，在这个示例中，我们使用了JDK内部的sun.nio.ch.DirectBuffer类来调用clean()方法，这是一种不太推荐的做法，因为这个类不是公开API。

二、对象的内存布局

对象在内存中存储的布局由3部分组成：

1. 对象头 (Header)
2. 实例数据 (Instance Data)
3. 对齐填充 (Padding)

2.1 对象头

对象头包括两部分 ：
第一部分用于存储对象自身的运行时数据，如哈希码、GC分代年龄、锁状态标识 等，在官方称为Mark Word
对象头信息与对象自身定义的数据无关，所以在设计时，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存储尽量多的信息。
HotSpot虚拟机中，如果对象处于未被锁定的状态下，那么Mark Word的32bit空间中的25bit用于存储对象哈希码，4bit用于存储对象分代年龄，2bit用于存储锁标志位，1bit固定为0，而在其他状态（轻量级锁定、重量级锁定、GC标记、可偏向）下对象的存储内容见表2-1

第二部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

2.2 实例数据

实例数据部分是对象真正存储的有效信息，也是在程序代码中所定义的各种类型的字段内容。无论是从父类继承下来的，还是在子类中定义的，都需要记录起来。
这部分的存储顺序会受到虚拟机分配策略参数(FieldsAllocationStyle)和字段在Java源码中定义顺序的影响。HotSpot虚拟机默认的分配策略为longs/doubles、.ints、shorts/chars、bytes/booleans、.oops(Ordinary Object Pointers),从分配策略中可以看出，相同宽度的字段总是被分配到一起。在满足这个前提条件的情况下，在父类中定义的变量会出现在子类之前。如果CompactFields参数值为rue(默认为true),那么子类之中较窄的变量也可能会插入到父类变量的空隙之中。

2.3 对齐填充

第三部分对齐填充并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。由于HotSpot VME的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数(1倍或者2倍)，因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。

三、对象的访问定位

建立对象是为了使用对象，我们的Java程序需要通过栈上的reference数据来操作堆上的具体对象。由于reference类型在Java虚拟机规范中只规定了一个指向对象的引用，并没有定义这个引用应该通过何种方式去定位、访问堆中的对象的具体位置，所以对象访问方式也是取决于虚拟机实现而定的。目前主流的访问方式有使用句柄和直接指针两种。

3.1 使用句柄

如果使用句柄访问的话，那么Java堆中将会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息，如图2-2所示。

3.2 直接指针

3.3 对比

这两种对象访问方式各有优势，使用句柄来访问的最大好处就是reference中存储的是稳定的句柄地址，在对象被移动（垃圾收集时移动对象是非常普逼的行为）时只会改变句柄中的实例数据指针，而reference本身不需要修改。
使用直接指针访问方式的最大好处就是速度更快，它节省了一次指针定位的时间开销由于对象的访问在Jva中非常频繁，因此这类开销积少成多后也是一项非常可观的执行成本。就本书讨论的主要虚拟机Sun HotSpotr而言，它是使用第二种方式进行对象访问的，但从整个软件开发的范围来看，各种语言和框架使用句柄来访问的情况也十分常见。

在当前的Java虚拟机实现中，大多数使用直接指针的方式来访问对象。使用直接指针的方式，可以简化对象的访问过程，提高运行效率，并且减少了句柄池带来的内存开销。但是，在使用直接指针的方式时，需要确保对象的地址不会发生变化，否则会导致指针失效，从而影响程序的正确性。

四、内存溢出的几种情况

4.1 java堆溢出

堆内存是Java虚拟机中用于存储对象实例的区域。当程序需要创建对象时，如果没有足够的内存空间分配给对象,就会发生堆内存溢出。常见的导致堆内存溢出的原因有：内存泄漏、对象创建过多、大对象等。
代码模拟

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

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

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

栈内存是用于存储方法执行过程中的局部变量和方法调用信息的区域。当程序需要调用的方法过多或者方法中使用的局部变量过多时，就会发生栈内存溢出。常见的导致栈内存溢出的原因有：递归调用、方法嵌套过深等。

public class StackOOM {
    public static void main(String[] args) {
        stackOverflow();
    }
    
    private static void stackOverflow() {
        stackOverflow();
    }
}

4.3 方法区和运行时常量池溢出

方法区是Java虚拟机中用于存储类信息、常量、静态变量等数据的区域。当程序需要加载的类信息过多或者静态变量的值过大时，就会发生方法区内存溢出。常见的导致方法区内存溢出的原因有：类文件过多、字符串常量池过大等。

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

public class MethodAreaOOM {
    public static void main(String[] args) {
        List<Class<?>> classes = new ArrayList<>();
        while (true) {
            classes.addAll(Metaspace.createClasses());
        }
    }
}

class Metaspace {
    public static List<Class<?>> createClasses() {
        List<Class<?>> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            ClassWriter classWriter = new ClassWriter(0);
            classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
            byte[] code = classWriter.toByteArray();
            Class<?> clazz = new MyClassLoader().defineClass("Class" + i, code, 0, code.length);
            list.add(clazz);
        }
        return list;
    }
}

class MyClassLoader extends ClassLoader {
    public Class<?> defineClass(String name, byte[] b, int off, int len) {
        return defineClass(name, b, off, len, null);
    }
}

4.4 本机直接内存溢出

本地内存是指程序使用的非Java虚拟机内存。当程序需要使用大量的本地内存时，就会发生本地内存溢出。常见的导致本地内存溢出的原因有：文件句柄、Socket连接等。

import java.io.File;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class DirectOOM {
    private static final int BUFFER_SIZE = 1024 * 1024 * 1024;
    
    public static void main(String[] args) throws Exception {
        File file = new File("test.dat");
        RandomAccessFile raf = new RandomAccessFile(file, "rw");
        MappedByteBuffer buffer = raf.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, BUFFER_SIZE);
        while (true) {
            buffer.put(new byte[BUFFER_SIZE]);
        }
    }
}

总结

关于JVM内存管理这部分内容是日常开发中比较常见的，也需要每个人都必须掌握，后面还有包括JVM的垃圾回收、class文件结构、类加载、字节码执行引擎等章节的内容，如果觉得该文章对你有帮助，可以关注我，一起学习进步！