JVM之深入理解堆空间(一)

JVM之深入理解堆

1. 堆的核心概念

堆针对一个JVM进程来说是唯一的，也就是一个进程只有一个JVM，但是进程包含多个线程，他们是共享同一堆空间的。

1. 一个JVM实例只存在一个堆内存，

   堆也是Java内存管理的核心区域。

2. Java堆区在JVM启动的时候即被创建，其空间大小也就确定了。是JVM管理的最大一块内存空间

• 堆内存的大小是可以调节的。

• // 如果设置最小堆内存和最大堆内存，建议设置成相同值
  -Xms10m：最小堆内存
  
  -Xmx10m：最大堆内存
             

  《Java虚拟机规范》规定，堆可以处于物理上不连续的内存空间中，但在逻辑上它应该被视为连续的。

1. 所有的线程共享Java堆，在这里

   还可以划分线程私有的缓冲区（Thread Local Allocation Buffer，TLAB）。

2. 下图就是使用：

   Java VisualVM查看堆空间的内容。

1. 《Java虚拟机规范》中对Java堆的描述是：

   所有的对象实例以及数组都应当在运行时分配在堆上。

2. 我要说的是：“几乎”所有的对象实例都在这里分配内存。—从实际使用角度看的

   。

因为还有一些对象是在栈上分配的。

1. 组和对象可能永远不会存储在栈上，因为栈帧中保存引用，这个引用指向对象或者数组在堆中的位置。
2. 在方法结束后，堆中的对象不会马上被移除，仅仅在垃圾收集的时候才会被移除。

   • 也就是触发了GC的时候，才会进行回收。

   • 如果堆中对象马上被回收，那么用户线程就会收到影响，因为有stop the word。

3. 堆，是GC（Garbage Collection，垃圾收集器）执行垃圾回收的重点区域。

2. 堆内存细分

现代垃圾收集器大部分都基于

分代收集理论

设计，堆空间细分为：

Java 7 及之前堆内存逻辑上分为三部分：

新生代 + 老年代 + 永久代

• Young Generation Space 新生代 Young/New
  • 又被划分为Eden区和Survivor区
• Tenure generation space 老年代 Old/Tenure
• Permanent Space 永久代 Perm

Java 8

及之后堆内存逻辑上分为三部分：

新生代 + 老年代 + 元空间

• Young Generation Space 新生代 Young/New
  • 又被划分为Eden区和Survivor区
• Tenure generation space 老年代 Old/Tenure
• Meta Space 元空间 Meta

• 堆空间内部结构，JDK1.8 之前从永久代 替换成 元空间

3. 设置堆内存大小与OOM

3.1 设置堆内存大小

1. Java堆区用于存储Java对象实例，那么

   堆的大小在JVM启动时就已经设定好了

   ，大家可以

   通过选项"-Xmx"和"-Xms"来进行设置。

   • “-Xms"用于表示堆区的起始内存，等价于-xx:InitialHeapSize

   • “-Xmx"则用于表示堆区的最大内存，等价于-XX:MaxHeapSize

2. 一旦堆区中的内存大小超过“-Xmx"所指定的最大内存时，将会抛出OutOfMemoryError异常。

3. 通常会将

   -Xms

   和

   -Xmx

   两个参数配置相同的值，其目的是为了能够在Java垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小，从而提高性能。
4. 默认情况下：

   • 初始内存大小：物理电脑内存大小/64；

   • 最大内存大小：物理电脑内存大小/4；

5. 手动设置：-Xms600m -Xmx600m

• 开发中建议将初始堆内存和最大的堆内存设置成相同的值。

/**
 * -Xms 用来设置堆空间（年轻代+老年代）的初始内存大小
 *  	-X：是jvm运行参数
 *  	ms：memory start
 * -Xmx：用来设置堆空间（年轻代+老年代）的最大内存大小
 */

public class HeapSpaceInitial {
    public static void main(String[] args) {
        // 返回Java虚拟机中的堆内存总量
        long initialMemory = Runtime.getRuntime().totalMemory() / 1024 / 1024;
        // 返回Java虚拟机试图使用的最大堆内存
        long maxMemory = Runtime.getRuntime().maxMemory() / 1024 / 1024;
        System.out.println("-Xms:" + initialMemory + "M");
        System.out.println("-Xmx:" + maxMemory + "M");
    }
}
           

输出结果

-Xms : 243M
-Xmx : 3607M
           

如何查看堆内存的内存分配情况？

方法一：
jps  查看程序的进程号
staat -gc  进程id 查看堆内存的内存分配情况
           

方式二：
-XX:+PrintGCDetails
           

3.2 OutOfMemory举例

public class OOMTest {
    public static void main(String[] args) {
        ArrayList<Picture> list = new ArrayList<>();
        while(true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            list.add(new Picture(new Random().nextInt(1024 * 1024)));
        }
    }
}

class Picture{
    private byte[] pixels;

    public Picture(int length) {
        this.pixels = new byte[length];
    }
}
           

我们用上面这个个OOM例子，然后设置启动参数

-Xms600m -Xmx:600m
           

运行后，就出现OOM了，那么我们可以通过 

VisualVM这个工具

查看具体是什么参数造成的OOM。

4. 年轻代与老年代

1. 存储在JVM中的

   Java对象可以被划分为两类：

   • 一类是生命周期较短的瞬时对象，这类对象的创建和消亡都非常迅速。
     • 生命周期短的，及时回收即可
   • 另外一类对象的生命周期却非常长，在某些极端的情况下还能够与JVM的生命周期保持一致。
2. Java堆区进一步细分的话，可以划分为

   年轻代（YoungGen）和老年代（oldGen）

3. 其中

   年轻代又可以划分为Eden空间、Survivor0空间和Survivor1空间（有时也叫做from区、to区）

   • 默认比例

   • Eden：From：to -> 8:1:1

   • 新生代：老年代 - > 1 : 2

下面这参数开发中一般不会调：

1. 配置新生代与老年代在堆结构的占比。

   • 默认-XX:NewRatio=2

     ，表示新生代占1，老年代占2，新生代占整个堆的1/3
   • 可以修改-XX:NewRatio=4，表示新生代占1，老年代占4，新生代占整个堆的1/5

2. 当发现在整个项目中，生命周期长的对象偏多，那么就可以通过调整 老年代的大小，来进行调优。

3. 在HotSpot中，

   Eden空间和另外两个survivor空间缺省所占的比例是8：1：1

   • 当然开发人员可以通过选项“

     -XX:SurvivorRatio

     ”调整这个空间比例。比如

     -xx:SurvivorRatio=8

4. 几乎所有的Java对象都是在Eden区被new出来的。

   绝大部分的Java对象的销毁都在新生代进行了。

   （有些大的对象在Eden区无法存储时候，将直接进入老年代）

   • IBM公司的专门研究表明，新生代中80%的对象都是“朝生夕死”的。

5. 可以使用选项

   "-Xmn"设置新生代最大内存大小，这个参数一般使用默认值就可以了。

5. 图解对象分配过程

5.1 分配过程概述

为新对象分配内存是一件非常严谨和复杂的任务，JVM的设计者们不仅需要考虑内存如何分配、在哪里分配等问题，并且由于内存分配算法与内存回收算法密切相关，所以还需要考虑GC执行完内存回收后是否会在内存空间中产生内存碎片。

1. new的对象先放伊甸园区。此区有大小限制。

2. 当伊甸园的空间填满时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园区进行垃圾回收（

   MinorGC

   ），将伊甸园区中的不再被其他对象所引用的对象进行销毁。再加载新的对象放到伊甸园区
3. 然后将伊甸园中的剩余对象移动到幸存者S0区。
4. 如果再次触发垃圾回收，此时上次幸存下来的放到幸存者S0区的，如果没有回收，就会放到幸存者S1区。
5. 如果再次经历垃圾回收，此时会重新放回幸存者S0区，接着再去幸存者S1区。

6. 啥时候能去老年代呢？可以设置次数。默认是15次。

   • 可以设置参数：

     -XX:MaxTenuringThreshold=N

     进行设置。
7. 在老年代，相对悠闲。当老年代内存不足时，再次触发GC：

   Major GC

   ，进行老年代的内存清理。
8. 若老年代执行了Major GC之后，发现依然无法进行对象的保存，就会产生OOM异常。

5.2 图解过程

我们创建的对象，一般都是存放在Eden区的，当我们Eden区满了后，就会触发GC操作，

一般被称为 YGC / Minor GC操作

1. 当我们进行一次垃圾收集后，红色的将会被回收，而绿色的还会被占用着，存放在S0(Survivor From)区。

   同时我们给每个对象设置了一个年龄计数器，一次回收后就是1。

2. 同时Eden区继续存放对象，当Eden区再次存满的时候，又会触发一个MinorGC操作，此时GC将会把 Eden和Survivor From中的对象 进行一次收集，

   把存活的对象放到 Survivor To区，同时让年龄 + 1

3.

我们继续不断的进行对象生成 和 垃圾回收，当Survivor中的对象的年龄达到15的时候，将会触发一次 Promotion晋升的操作，也就是将年轻代中的对象 晋升到 老年代中。

幸存区区满了后？

1. 特别注意，在Eden区满了的时候，才会触发MinorGC，而幸存者区满了后，不会触发MinorGC操作。
2. 如果Survivor区满了后，将会触发

   一些特殊的规则

   ，也就是可能直接晋升老年代
   • 举例：以当兵为例，正常人的晋升可能是 ： 新兵 -> 班长 -> 排长 -> 连长
   • 但是也有可能有些人因为做了非常大的贡献，直接从 新兵 -> 排长

5.3 对象分配的特殊情况

代码演示对象分配过程

我们不断的创建大对象

/**
 * 代码演示对象创建过程
 */
public class HeapInstanceTest {
    byte[] buffer = new byte[new Random().nextInt(1024 * 200)];

    public static void main(String[] args) {
        
        ArrayList<HeapInstanceTest> list = new ArrayList<HeapInstanceTest>();
        
        while (true) {
            
            list.add(new HeapInstanceTest());
            
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
    }
}
           

然后设置JVM参数

-Xms600m -Xmx600m
           

然后cmd输入下面命令，打开VisualVM图形化界面

jvisualvm
           

然后通过执行上面代码，通过VisualGC进行动态化查看

点击下载动态gif

（这个gif有点c大，所以这里放不下，需要自行下载。。。）

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at com.atguigu.java1.HeapInstanceTest.<init>(HeapInstanceTest.java:10)
	at com.atguigu.java1.HeapInstanceTest.main(HeapInstanceTest.java:15)
           

5.4 常用的调优工具

5.5 总结

1. 针对幸存者s0，s1区的总结：复制之后有交换，谁空谁是to。
2. 关于垃圾回收：频繁在新生区收集，很少在老年代收集，几乎不再永久代和元空间进行收集。

3. 新生代采用复制算法的目的：是为了减少内碎片。