【JVM原理】内存分配和回收策略

最新推荐文章于 2021-04-08 23:53:45 发布
最新推荐文章于 2021-04-08 23:53:45 发布
阅读量617 收藏
点赞数 1
分类专栏： JVM原理 文章标签： 内存分配 回收策略 eden区 对象年龄 大对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhl_jxy/article/details/80968456
版权

前言

Github：https://github.com/yihonglei/jdk-source-code-reading（java-jvm）

JVM内存结构

JVM类加载机制

JVM内存溢出分析

HotSpot对象创建、内存、访问

如何判定对象可以回收

垃圾收集算法

垃圾收集器

内存分配和回收策略

一 内存分配与回收策略概述

对象的内存分配往大方向讲，就是在堆上分配(但也可能经过JIT编译后被拆散为标量类型

并间接地栈上分配)，对象主要分配在新生代的 Eden 区上，如果启用了本地线程分配缓冲，

将按线程优先在 TLAB 上分配。少数情况下也可能直接分配在老年代中，分配的规则并不是

百分百固定的，分配细节取决于垃圾收集器组合，还有虚拟机中与内存相关的参数设置。

Virtual：为动态收缩区域，当垃圾回收获得高吞吐量或低停顿后，会尽量缩小区域内存，

以获得更好的空间局部性。 以下内容实例分析基于 JVM Server 模式下验证。

二 对象优先在 Eden 区分配

对象通常在新生代 Eden 区中分配，当 Eden 区没有足够空间分配时，虚拟机将发生一次

Minor GC。与 Minor GC 对应的是 Major GC、Full GC。

新生代 GC（Minor GC）：指发生在新生代的垃圾收集动作，因为 Java 对象大多都具备

朝生夕灭的特性，所以 Minor GC 非常频繁，一般回收速度也比较快。

老年代 GC（Major GC/Full GC）：指发生在老年代的 GC，出现 Full GC，经常会伴随至

少一次的 Minor GC（但非绝对的，在 Parallel Scavenge 收集器的可以配置 Full GC 收集策略）。

Full GC 的速度一般会比 Minor GC 慢10 倍以上。Major GC 和 Full GC 概念上目前没有明确

定义，并不是简单的 Major GC 负责清理老年代，Full GC 清理堆空间新生代和老年代，

可以参考这里的解释，从 GC 停顿做出了解释。

Minor GC vs Major GC vs Full GC - DZone Java，如果访问不了，翻下墙。

1、eg1

相关参数：

-verbose:gc 输出显示虚拟机运行信息；

-XX:+PrintGCDetails 打印内存回收日志；

-Xmx20M -Xms20M -Xmn10M 限制堆大小为 20M，不可以扩展，10M 分配给新生代，

剩下 10 分配给老年代；

-XX:SurvivorRatio=8 配置 Eden 区与一个 Survivor 区的比例，这里是默认的 8:1，

不用显示配置也可以；

package com.jpeony.jvm.gc;

/**
 * 【优先分配在 eden 区】
 *
 * JVM 参数配置：
 * -verbose:gc -XX:+PrintGCDetails -Xmx20M -Xms20M -Xmn10M -XX:SurvivorRatio=8
 *
 * JVM 参数说明：
 * -verbose:gc 输出显示虚拟机运行信息；
 * -XX:+PrintGCDetails 打印内存回收日志；
 * -Xmx20M -Xms20M -Xmn10M 限制堆大小为 20M，不可以扩展，10M 分配给新生代，剩下 10M 分配给老年代；
 * -XX:SurvivorRatio=8 配置 Eden 区与一个 Survivor 区的比例，这里是默认的 8:1，不用显示配置也可以；
 *
 * @author yihonglei
 */
public class AllocationTest01 {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        byte[] allocation = new byte[4 * _1MB];
    }
}

运行结果：

Heap
 PSYoungGen      total 9216K, used 6414K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 78% used [0x00000000ff600000,0x00000000ffc43b58,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 0K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 0% used [0x00000000fec00000,0x00000000fec00000,0x00000000ff600000)
 Metaspace       used 3235K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 353K, capacity 388K, committed 512K, reserved 1048576K

从 GC 日志可以看到，新生代 eden 区占用 78%，from、to 两个 Survivor 区和 ParOldGen

老年代都没有使用，验证了对象优先在 Eden 区分配的事实。

按理说，eden 区分配只是 4M，应该占 50% 才对，事实分配后占用的比实际分配的要多，

主要是因为 Java 对象并不是一个人在战斗，其它部分也占用了内存。

2、eg2

把上面代码实现修改如下：

package com.jpeony.jvm.gc;

/**
 * 【分配的内存 >=Eden 大小的一半，就直接放入了老年代】
 *
 * JVM 参数配置：
 * -verbose:gc -XX:+PrintGCDetails -Xmx20M -Xms20M -Xmn10M -XX:SurvivorRatio=8
 *
 * JVM 参数说明：
 * -verbose:gc 输出显示虚拟机运行信息；
 * -XX:+PrintGCDetails 打印内存回收日志；
 * -Xmx20M -Xms20M -Xmn10M 限制堆大小为 20M，不可以扩展，10M 分配给新生代，剩下 10M 分配给老年代；
 * -XX:SurvivorRatio=8 配置 Eden 区与一个 Survivor 区的比例，这里是默认的8:1，不用显示配置也可以；
 *
 * @author yihonglei
 */
public class AllocationTest02 {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        byte[] allocation1 = new byte[2 * _1MB];
        byte[] allocation2 = new byte[2 * _1MB];
        byte[] allocation3 = new byte[5 * _1MB];
    }
}

运行结果：

Heap
 PSYoungGen      total 9216K, used 6579K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
  eden space 8192K, 80% used [0x00000000ff600000,0x00000000ffc6ccb8,0x00000000ffe00000)
  from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
  to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
 ParOldGen       total 10240K, used 5120K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  object space 10240K, 50% used [0x00000000fec00000,0x00000000ff100010,0x00000000ff600000)
 Metaspace       used 3333K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 359K, capacity 388K, committed 512K, reserved 1048576K

程序执行后，eden 区用了 80%，from 未占用，to 未占用，而 ParOldGen 老年代占用 50%。

当 allocation1，allocation2 分配的时候，eden 区占用 80%，咱们分配 4M，实际占用了 6.4M，

这个时候再分配 allocation3 是 5M，eden 区剩余内存不够 5M，然后 allocation3 直接分配在

老年代，因为分配的内存 >=Eden 大小的一半，就直接放入了老年代。

三 大对象直接进入老年代

大对象是指需要大量连续内存空间的 Java 对象，最经典的对象就是那种很长的字符串以

及数组。大对象对虚拟机内存分配来说就是一个坏消息，经常出现大对象容易导致内存还有

不少空间时就提前触发垃圾收集以获取足够的连续空间来存储大对象。

虚拟机提供了 -XX:PretenureSizeThreadshold 参数来设置大对象的阈值，超过阈值的对象

直接分配到老年代。这样做的目的是为了避免在 Eden 区和两个 Survivor 区之间发生大量的

内存复制。

1、eg1

相关参数：

-verbose:gc 输出显示虚拟机运行信息；

-XX:+PrintGCDetails 打印内存回收日志；

-Xmx20M -Xms20M -Xmn10M 限制堆大小为 20M，不可以扩展，10M 分配给新生代，

剩下 10M 分配给老年代；

-XX:SurvivorRatio=8 配置 Eden 区与一个 Survivor 区的比例，这里是默认的 8:1，不用显示

配置也可以；

-XX:PretenureSizeThreshold=3145728 （3M）设置大对象的阀值，大于该值，直接进入老年代；

-XX:+UseSerialGC 指定收集器为 Serial；

注意：PretenureSizeThreshold 参数只对 Serial 和 ParNew 两款收集器有效，我这里用的

是 Jdk8，默认使用 Parallel Scavenge，一般不需要设置，如果非得需要，可以考虑 ParNew

和 CMS 收集器组合。

package com.jpeony.jvm.gc;

/**
 * JVM 参数配置：
 * -verbose:gc -XX:+PrintGCDetails -Xms20M -Xmx20M -Xmn10M -XX:SurvivorRatio=8 -XX:PretenureSizeThreshold=3145728 -XX:+UseSerialGC
 *
 * JVM 参数说明：
 * -verbose:gc 输出显示虚拟机运行信息；
 * -XX:+PrintGCDetails 打印内存回收日志；
 * -Xms20M -Xmx20M -Xmn10M 限制堆大小为 20M，不可以扩展，10M 分配给新生代，剩下 10M 分配给老年代；
 * -XX:SurvivorRatio=8 配置 Eden 区与一个 Survivor 区的比例，这里是默认的 8:1，不用显示配置也可以；
 * -XX:PretenureSizeThreshold=3145728 （3M）设置大对象的阀值，大于该值，直接进入老年代；
 * -XX:+UseSerialGC 指定收集器为 Serial
 * 注意：PretenureSizeThreshold 参数只对 Serial 和 ParNew 两款收集器有效，我这里用的是 Jdk8，
 * 默认使用 Parallel Scavenge，一般不需要设置，如果非得需要，可以考虑 ParNew 和 CMS 收集器组合。
 *
 * 程序说明：
 * 从结果可以看出 eden 区没怎么使用，from、to 两个 Survivor 去未使用，老年代用了40%。
 * 因为分配对象为 4M，大于设置的 3M 阀值，直接在老年代进行分配。
 *
 * @author yihonglei
 */
public class PretenureSizeThreshold {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        byte[] allocation = new byte[4 * _1MB];
    }
}

运行结果：

Heap

 def new generation   total 9216K, used 2319K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)

  eden space 8192K,  28% used [0x00000000fec00000, 0x00000000fee43d48, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
  to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
 tenured generation   total 10240K, used 4096K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
 the space 10240K,  40% used [0x00000000ff600000, 0x00000000ffa00010, 0x00000000ffa00200, 0x0000000100000000)

 Metaspace       used 3235K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 353K, capacity 388K, committed 512K, reserved 1048576K

从结果可以看出 eden 区没怎么使用，from、to 两个 Survivor 区未使用，老年代用了 40%。

因为分配对象为 4M，大于设置的 3M 阀值，直接在老年代进行分配。

四 长期存活的对象将进入老年代

    虚拟机为每一个对象定义了一个对象年龄（Age）计数器。如果对象在 Eden 区出生经过

第一次 Minor GC 后仍然存活，并能被 Survivor 容纳的话，将被移动到 Survivor 空间中，

并且对象年龄设置为 1。对存活在 Survivor 中的对象，每"熬过"一次 Minor GC，年龄就增加 1，

当它的年龄增加到一定年龄阀值（默认 15 岁），就将会被晋升到老年代中。对老年代年龄

阀值可以通过 -XX:MaxTenuringThreshold 设置。

相关参数：

-verbose:gc 输出显示虚拟机运行信息；

-XX:+PrintGCDetails 打印内存回收日志；

-Xms20M -Xmx20M -Xmn10M 限制堆大小为 20M，不可以扩展，10M 分配给新生代，

剩下 10M 分配给老年代；

-XX:SurvivorRatio=8 配置Eden区与一个 Survivor 区的比例，这里是默认的 8:1，不用显示

配置也可以；

-XX:MaxTenuringThreshold=1 年龄阀值设置，默认为 15 岁。

package com.jpeony.jvm.gc;

/**
 * JVM 参数配置:
 * -verbose:gc -XX:+PrintGCDetails -Xms20M -Xmx20M -Xmn10M -XX:SurvivorRatio=8 -XX:+UseSerialGC -XX:MaxTenuringThreshold=1 -XX:+PrintTenuringDistribution
 *
 * JVM 参数说明:
 * -verbose:gc 输出显示虚拟机运行信息；
 * -XX:+PrintGCDetails 打印内存回收日志；
 * -Xms20M -Xmx20M -Xmn10M 限制堆大小为20M，不可以扩展，10M 分配给新生代，剩下 10M 分配给老年代；
 * -XX:SurvivorRatio=8 配置Eden区与一个Survivor区的比例，这里是默认的8:1，不用显示配置也可以；
 * -XX:MaxTenuringThreshold=1 年龄阀值设置，默认为15岁。
 *
 * 程序说明:
 * 从执行结果可以看出 eden 使用 51%，from、to 两个 Survivor 区未使用，老年代使用 50%。
 * 按照程序内存分配，从上到下分析，allocation1 分配 _1MB/4 进入 eden 区，allocation2 分配 4MB 进入 eden 区，
 * 当第一次分配 allocation3 时，发现 eden 区内存不够，直接触发 Minor GC，allocation1 和 allocation2 按理说都进入
 * Survivor区，但是 Survivor 区只有 1MB，只能容得下 allocation1，allocation1 进入 Survivor 区并且年龄为 1，
 * 将在下一次 GC 时晋升到老年代，而 allocation2 通过担保机制直接进入老年代，allocation3 分配 4MB 则在 eden 区。
 * 当第二次分配 allocation3 时，分配 4M，这样 eden 区不够，因为上一次分配 allocation3 是 4MB，要比实际大，
 * 现在又来 4M，eden 区只有 8MB，当然 eden 区内存就不够了，这个时候又触发了一次 Minor GC，allocation1 年龄加 1，
 * 晋升到老年代，allocation2 也还在老年代，上一次的 allocation3 因为被设置为 null，直接被清除，eden 区变为 8MB 内存，
 * 第二次的 allocation3 被分配到 eden 区。
 * 最终结果就是：allocation1, allocation2 分配在老年区，allocation3 分配在新生代的 eden 区。
 *
 * @author yihonglei
 */
public class TenuringThresholdTest01 {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        byte[] allocation1, allocation2, allocation3;
        allocation1 = new byte[_1MB / 4];
        allocation2 = new byte[4 * _1MB];
        allocation3 = new byte[4 * _1MB];

        allocation3 = null;
        allocation3 = new byte[4 * _1MB];
    }
}

结果：

Heap
 def new generation   total 9216K, used 4150K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  50% used [0x00000000fec00000, 0x00000000ff00dbf8, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
  to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
 tenured generation   total 10240K, used 5140K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
   the space 10240K,  50% used [0x00000000ff600000, 0x00000000ffb05210, 0x00000000ffb05400, 0x0000000100000000)
 Metaspace       used 3345K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 361K, capacity 388K, committed 512K, reserved 1048576K

从执行结果可以看出 eden 使用 50%，from、to 两个 Survivor 区未使用，老年代使用 50%。

按照程序内存分配，从上到下分析，allocation1 分配 _1MB/4 进入 eden 区，allocation2 分配

4MB 进入 eden 区，当第一次分配 allocation3 时，发现eden区内存不够，直接触发 Minor GC，

allocation1 和 allocation2 按理说都进入 Survivor 区，但是 Survivo r区只有 1MB，只能容得

下 allocation1，allocation1 进入 Survivor 区并且年龄为1，将在下一次 GC 时晋升到老年代，

而 allocation2 通过担保机制直接进入老年代，allocation3 分配 4MB 则在 eden 区。

当第二次分配 allocation3 时，分配 4M，这样 eden 区不够，因为上一次分配 allocation3

是 4MB，要比实际大，现在又来 4M，eden 区只有 8MB，当然 eden 区内存就不够了，

这个时候又触发了一次 Minor GC，allocation1 年龄加 1，晋升到老年代，allocation2 也还在

老年代，上一次的 allocation3 因为被设置为 null，直接被清除，eden 区变为 8MB 内存，

第二次的 allocation3 被分配到 eden区。

最终结果就是： allocation1, allocation2 分配在老年区，allocation3 分配在新生代的 eden 区。

五 动态对象年龄判断

    对象的年龄到达了 MaxTenuringThreshold 可以进入老年代，同时，如果在 survivor 区中

相同年龄所有对象大小的总和大于 survivor 区的一半，年龄大于等于该年龄的对象就可以

直接进入老年代。无需等到 MaxTenuringThreshold 中要求的年龄。

相关参数：

-verbose:gc 输出显示虚拟机运行信息；

-XX:+PrintGCDetails 打印内存回收日志；

-Xms20M -Xmx20M -Xmn10M 限制堆大小为 20M，不可以扩展，10M 分配给新生代，

剩下 10 分配给老年代；

-XX:SurvivorRatio=8 配置 Eden 区与一个 Survivor 区的比例，这里是默认的 8:1，

不用显示配置也可以；

-XX:MaxTenuringThreshold=15 年龄阀值设置，默认为 15 岁。

package com.jpeony.jvm.gc;

/**
 * JVM 参数配置:
 * -verbose:gc -XX:+PrintGCDetails -Xms20M -Xmx20M -Xmn10M -XX:SurvivorRatio=8 -XX:+UseSerialGC -XX:MaxTenuringThreshold=15 -XX:+PrintTenuringDistribution
 *
 * JVM 参数说明:
 * -verbose:gc 输出显示虚拟机运行信息；
 * -XX:+PrintGCDetails 打印内存回收日志；
 * -Xms20M -Xmx20M -Xmn10M 限制堆大小为20M，不可以扩展，10M分配给新生代，剩下10分配给老年代；
 * -XX:SurvivorRatio=8 配置Eden区与一个Survivor区的比例，这里是默认的8:1，不用显示配置也可以；
 * -XX:MaxTenuringThreshold=1 年龄阀值设置，默认为15岁。
 *
 * 程序说明:
 * 从结果可以看出 eden 使用 51%，from、to 两个 Survivor 未使用，老年代使用了 52%。
 * allocation1、allocation2、allocation3 分配进入 Eden 区。
 * 当第一次给 allocation4 分配内存时，eden 区内存不够，发生一次 Minor GC，
 * 此时 allocation1、allocation2 将会进入 survivor 区，而 allocation3 通过担保机制将会进入老年代。
 * 第二次发生在给 allocation4 分配内存时，此时，survivor 区的 allocation1、allocation2 达到了 survivor 区容量的一半，
 * 将会进入老年代，此次 GC 可以清理出 allocation4 原来的 4MB 空间，并将 allocation4 分配在 Eden 区。
 * 最终，allocation1、allocation2、allocation3 在老年代，allocation4 在 Eden 区。
 *
 * @author yihonglei
 */
public class TenuringThresholdTest02 {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        byte[] allocation1, allocation2, allocation3, allocation4;
        allocation1 = new byte[_1MB / 4];
        allocation2 = new byte[_1MB / 4];
        allocation3 = new byte[4 * _1MB];
        allocation4 = new byte[4 * _1MB];
        allocation4 = null;
        allocation4 = new byte[4 * _1MB];
    }
}

结果：

Heap
 def new generation   total 9216K, used 4235K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  51% used [0x00000000fec00000, 0x00000000ff022828, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400618, 0x00000000ff500000)
  to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
 tenured generation   total 10240K, used 5371K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
   the space 10240K,  52% used [0x00000000ff600000, 0x00000000ffb3ec10, 0x00000000ffb3ee00, 0x0000000100000000)
 Metaspace       used 3339K, capacity 4496K, committed 4864K, reserved 1056768K
  class space    used 360K, capacity 388K, committed 512K, reserved 1048576K

从结果可以看出 eden 使用 51%，from、to 两个 Survivor 未使用，老年代使用了 52%。

allocation1、allocation2、allocation3 分配进入 Eden 区。

当第一次给 allocation4 分配内存时，eden 区内存不够，发生一次 Minor GC，

此时 allocation1、allocation2 将会进入 survivor 区，而 allocation3 通过担保机制将会进入

老年代。第二次发生在给 allocation4 分配内存时，此时，survivor 区的 allocation1、allocation2

达到了 survivor 区容量的一半，将会进入老年代，此次 GC 可以清理出 allocation4 原来的 4MB

空间，并将 allocation4 分配在 Eden 区。最终，allocation1、allocation2、allocation3 在老年代，

allocation4 在 Eden 区。

六 空间分配担保

    在发生 Minor GC 时，虚拟机会检查老年代连续的空闲区域是否大于新生代所有对象的总和，

若成立，则说明 Minor GC 是安全的，否则，虚拟机需要查看 HandlePromotionFailure 的值，

看是否运行担保失败，若允许，则虚拟机继续检查老年代最大可用的连续空间是否大于历次

晋升到老年代对象的平均大小，若大于，将尝试进行一次 Minor GC；

若小于或者 HandlePromotionFailure 设置不运行冒险，那么此时将改成一次 Full GC，

以上是 JDK Update 24 之前的策略，之后的策略改变了，只要老年代的连续空间大于新生代

对象总大小或者历次晋升的平均大小就会进行 Minor GC，否则将进行 Full GC。冒险是

指经过一次 Minor GC 后有大量对象存活，而新生代的 survivor 区很小，放不下这些大量

存活的对象，所以需要老年代进行分配担保，把 survivor 区无法容纳的对象直接进入老年代。

package com.jpeony.jvm.gc;

/**
 * JVM 参数配置:
 * -verbose:gc -XX:+PrintGCDetails -Xms20M -Xmx20M -Xmn10M -XX:SurvivorRatio=8 -XX:+HandlePromotionFailure
 *
 * 程序说明：
 * 一开始 allocation1、allocation2、allocation3 分配在 eden 区，同时 allocation1 被置为无效。
 * 当第一次给 allocation4 分配内存时，eden 区内存不够，发生一次 Minor GC，
 * 由于老年代的连续可用空间大于存活的对象总和，所以 allocation2、allocation3 将会进入老年代，
 * allocation1 的空间将被回收，此时整个 eden 区被清空，又变为 8MB，有空间让 allocation4 分配在 eden 区；
 * 接下来 allocation5、allocation6 接着往 eden 区分配，同时 allocation4、allocation5、allocation6 被置为无效。
 * 当第二次给 allocation7 分配内存时，eden 区内存不够，发生一次 Minor GC，allocation4、allocation5、
 * allocation6 所占的内存全部回收，把整个 eden 区清空，变为 8MB，然后将 allocation7 分配在新生代 eden 区。
 * 最后，allocation2、allocation3 在老年代，allocation7 在新生代。
 *
 * @author yihonglei
 */
public class HandlePromotion {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        byte[] allocation1, allocation2, allocation3, allocation4,
                allocation5, allocation6, allocation7, allocation8;
        allocation1 = new byte[2 * _1MB];
        allocation2 = new byte[2 * _1MB];
        allocation3 = new byte[2 * _1MB];
        allocation1 = null;
        allocation4 = new byte[2 * _1MB];
        allocation5 = new byte[2 * _1MB];
        allocation6 = new byte[2 * _1MB];
        allocation4 = null;
        allocation5 = null;
        allocation6 = null;
        allocation7 = new byte[2 * _1MB];
    }
}

运行结果：

Heap
 def new generation   total 9216K, used 2130K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
  eden space 8192K,  26% used [0x00000000fec00000, 0x00000000fee14930, 0x00000000ff400000)
  from space 1024K,   0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000)
  to   space 1024K,   0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000)
 tenured generation   total 10240K, used 4611K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
   the space 10240K,  45% used [0x00000000ff600000, 0x00000000ffa80d58, 0x00000000ffa80e00, 0x0000000100000000)
 Metaspace       used 2568K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 275K, capacity 386K, committed 512K, reserved 1048576K

一开始 allocation1、allocation2、allocation3 分配在 eden 区，同时 allocation1 被置为无效。

当第一次给 allocation4 分配内存时，eden 区内存不够，发生一次 Minor GC，

由于老年代的连续可用空间大于存活的对象总和，所以 allocation2、allocation3 将会进入老年代，

allocation1 的空间将被回收，此时整个 eden 区被清空，又变为 8MB，有空间让 allocation4

分配在 eden 区；

接下来 allocation5、allocation6 接着往 eden 区分配，同时 allocation4、allocation5、allocation6

被置为无效。当第二次给 allocation7 分配内存时，eden 区内存不够，发生一次 Minor GC，

allocation4、allocation5、allocation6 所占的内存全部回收，把整个 eden 区清空，变为 8MB，

然后将 allocation7 分配在新生代 eden 区。最后，allocation2、allocation3 在老年代，

allocation7 在新生代。

参考文献

《深入理解Java虚拟机》 (第二版) 周志明 著；

街灯下的小草
关注
专栏目录
浅谈JVM内存分配与垃圾回收
jmysql的博客
04-01 335
Java技术体系中所提倡的自动内存管理最终应该可以归结为自动化的解决两个问题，即给对象动态分配内存和回收分配给对象的内存。通常情况下Java对象在JVM堆上分配内存，但也可以在JVM堆外分配内存。这是因为JVM堆作为最主要的存储对象实例的内存区，同时也是垃圾回收（GC）的重点区域。GC的频率和效率就很可能成为虚拟机性能上的瓶颈。为了降低GC的频率和提升GC的效率，逃逸分析、栈上分配等优化技术就出现了，JVM堆区便不再是Java对象动态内存空间分配的唯一选择。扯的有点远了，先了解一下就行。 从生命周...
jvm内存分配与回收策略
ZMPRESS
05-09 256
文章目录内存分配与回收策略GC触发时机minorgc触发时机fullgc触发时机jvm默认垃圾收集器查看当前使用的垃圾收集器jdk默认垃圾收集器 内存分配与回收策略 对象优先在Eden分配 大对象直接进入老年代 长期存活的对象将进入老年代,默认15 动态对象年龄判定 如果在Survivor空间中相同年龄所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代 空间分配担保 在发生Minor GC之前，虚拟机必须先检查老年代最大可用的连续空间是否大于新生代所有对象总空
jvm 内存分配与垃圾回收
Tanbin_的博客
12-04 428
一般粗略的可以把内存的分配分为栈区和堆区，但是对于理解垃圾回收和分配还要分得细一点。如下图： 分为堆和方法区，虚拟机栈和本地方法栈，程序计数器。 前两个是多线程共享的，后面三个是每个线程单独的。方法区保存的是加载的类信息，常量（有常量池）,静态变量等与实例无关与类有关的信息。里面还包括运行常量池，会在类加载时，把class文件常量池的字面量，符号引用等装进运行常量池。使用String的int
JVM内存分配与垃圾回收详解
07-06
个人整理 jvm相关知识 包括内存分配机制 垃圾回收机制 垃圾收集器相关 及 垃圾收集算法
JVM垃圾回收与内存分配
weixin_45516590的博客
04-08 135
JVM垃圾回收与内存分配 垃圾回收判断算法： 1. 引用计数法 给对象添加一个计数器，当引用时计数器就加1，如果引用失效时，则计数器则减1。如果计数器为0时，则表示该对象不被引用。从而判定可以回收。 2. 可达性分析算法 GCROOTS为起点，向下搜索，搜索过程的路径作为引用链，当一个对象没有任何一个引用链，则表明对象不可被引用。 GCRoot的对象： 2.1 虚拟机栈中引用的对象 2.2 方法区中的类静态属性引用对象 2.3 方法区中常量引用对象 2.4 本地方法栈中JNI引用的对象 引用: 引用可以分为
java中引用的种类
xuqiaobo的博客
08-26 515
1）强引用，就是指在程序代码中普遍存在的，类似于Object obj=new Object()这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。 2）软引用是用来描述一些还有用但并非必要的对象，对于软引用关联的对象，在系统将要发生溢出异常之前，将会把这些对象列进回收范围之中进行二次回收。如果这次回收还没有足够内存，才会抛出内存溢出异常。 3）弱引用也用来描述非必须对象的，但是
JVM堆内存分配与回收策略
西瓜游侠的博客
07-29 782
1、堆划分在JDK1.7以及之前的版本中，堆内存通常被分为三块区域：新生代、老年代、永久代。 新生代又分为：Eden区、From Survivor区（S0）、To Survivor区（S1）。默认8:1:1。 而在JDK1.8中情况发生了变化，把存放元数据中的永久内存从堆内存中移到了本地内存(native memory)中。 JDK1.8也提供了一个新的设置Matespace（元空间）内存大小
JVM对象创建和内存分配原理解析
08-24
JVM 对象创建和内存分配原理解析 摘要：本文主要介绍了 JVM 对象创建和内存分配的原理，通过示例代码详细地介绍了对象创建和内存分配的过程。文章从 JVM 对象创建的过程开始，介绍了检查参数、类加载、内存分配和...
JVM内存分配与回收策略详解
作为Java程序员，了解JVM内存分配与回收策略的原理和机制，可以帮助我们写出更高效、更稳定的程序。同时，当出现内存溢出、内存泄漏等问题时，理解JVM内存分配与回收策略也能帮助我们更好地进行故障排查和优化。 ##...
【JVM和性能优化】2.垃圾回收器和内存分配策略
12-22
在Java开发中，理解JVM（Java Virtual Machine）的内存管理，特别是垃圾回收器（Garbage Collector, GC）和内存分配策略，对于优化应用性能至关重要。这篇文章将探讨这些核心概念。 内存回收主要目的是自动释放不再...
笔记，2、内存分配与回收策略~深入理解垃圾回收器1
08-08
内存分配与回收是编程语言...总的来说，理解Java的内存分配与回收策略对于优化程序性能和避免内存问题至关重要。开发者应关注GC的工作原理，合理设置内存参数，并善用不同类型的引用，以实现更高效、更稳定的程序运行。
Java内存模型解析：JVM原理、内存分配及垃圾回收策略
# 1. I. 简介 ### A.... Java内存模型（Java Memory Model，JMM）是一种抽象规范，用来描述Java虚拟机（JVM）中多线程并发访问内存的方式。这个模型决定了一个线程如何... 为什么需要了解JVM原理、内存分配及垃圾回收策略
JVM(三)-垃圾回收机制与内存分配策略
haoxin963的专栏
08-23 280
上一篇博客介绍了java内存运行时的各个区域，其中程序计数器，虚拟机栈，本地方法栈这3个区域随着线程而生，随着线程而灭。栈中的栈帧随着方法的进入和退出有条不紊执行着出栈和入栈操作。每一个栈帧中分配多少内存基本上是在类结构确定下来时就已知的，因此这几个区域的内存分配和回收都具备确定性，方法结束或者线程退出时，内存自然就跟着回收了。而java的堆个方法区则不一样。我们只有在程序运行时才知道会创建多少对...
JVM内存结构和垃圾回收机制
不吃学习的苦， 就要吃生活的苦
05-18 137
JVM内存结构包括程序计数器、虚拟机、本地方法栈、堆、方法区。 1.程序技术器 占用很少的内存，取下一条执行的指令。 2.虚拟机栈 保存基础数据类型和对象引用，当前线程执行每个方法的时候会在栈上申请一个栈帧，每个栈帧包括局部变量区和操作数栈，用来存放本地方法调用过程中的临时变量，参数和结果。 3.本地方法栈 用于支持native方法的执行，存储了每个native方法调用的状态。 4....
JVM垃圾回收与内存分配策略
To be a great coder
07-01 262
Java 技术体系中所提倡的自动内存管理最终可以归结为自动化地解决了两个问题： 给对象分配内存 回收分配给对象的内存 堆区内存结构图（JDK1.8 之后移除了永久代，GC 只需要对堆区的新生代和老年代负责） 其中，Eden 区（就是伊甸园的意思，所有对象的起源，在后面介绍分配策略的时候你会更加明白为什么这么命名），From 区和 To 区是两块 Survivor 区（幸存者空间）。 相关性能...
JVM之垃圾回收器和内存分配策略
瘦子没有夏天
02-09 791
三、垃圾回收器和内存分配策略 3.1 概述 那些内存需要回收？什么时候进行回收？如何进行回收？ 程序计数器、虚拟机栈、本地方法栈这三部分随着线程而生，随着线程而灭。栈中的栈帧随着方法有序的进出。每一个栈帧中分配内存是在类结构确定下来就已知（JIT会在编译时进行些许优化） 因此程序计数器、虚拟机栈、本地方法栈这三者内存分配和回收都具备确定性，垃圾回收再这几块不需要你过多的考虑。他们会随着线程的回收...
【JVM】used/capacity/commited/reserved
厚积薄发者，轻舟万重山
04-05 2987
问题来源：https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/considerations.html 问题详情： Example 11-1 Typical Heap Printout Heap PSYoungGen total 10752K, used 4419K [0xffffffff6ac00000, 0xffffffff6b800000, 0xffffffff6b800000)
JVM-垃圾收集机制与内存分配策略
我真是小学生的博客
10-21 619
本文参考《深入理解java虚拟机》周志明一书，如需深入jvm学习，极力推荐此书
JVM--垃圾对象判定与垃圾回收算法
神韵
08-14 613
垃圾判定标准 引用计数法，Java不使用 可达性分析算法（根搜索法），Java采用这种方法判断对象是否可回收 两种垃圾判定标准参考博客对象的访问定位两种方式 垃圾回收算法/策略 1、标记-清除算法 jvm会扫描所有的对象实例，通过可达性分析算法，将活跃对象进行标记，jvm再一次扫描所有对象，将未标记的对象进行清除，只有清除动作，不作任何的处理，这样导致的结果会...
"深度解析JVM垃圾回收器与内存分配策略
除了了解垃圾回收器外，了解内存分配与回收策略也同样重要。内存泄漏和内存溢出是常见的问题，而JDK提供了一些自带工具，比如Profiler、JConsole、VisualVM等，可以帮助我们检测和解决这些问题。 综上所述，了解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值