不是吧做了两年java还没弄懂JVM堆进来看看你就明白了

47次阅读

共计 7217 个字符,预计需要花费 19 分钟才能阅读完成。

堆的核心概述

一个 JVM 实例只存在一个堆内存,堆也是 java 内存管理的核心区域
Java 堆区在 jvm 启动的时候被创建,其空间大小也就确定了。是 jvm 管理的最大一块内存空间。(堆内存的大小可以调节)
《java 虚拟机规范》规定,堆可以处于物理上不连续的内存空间中,但在逻辑上它应该被视为连续的
所有的线程共享 java 堆,在这里还可以划分线程私有的缓冲区
《Java 虚拟机规范》中对 Java 堆的描述是:所有对象实例以及数组都应该运行时分配在堆上
数组和对象可能永远不会存储在栈上,因为栈帧中保存引用,这个引用指向对象或数组在对中的位置
在方法结束后,堆中对象不会马上移除,仅仅在垃圾收集的时候才会被移除
堆是 GC(Garbage Collection)执行垃圾回收的重点区域

内存细分

现代垃圾收集器大部分都基于分代收集理论设计,堆空间分为:

java7 之前堆内存逻辑上分为三部分:新生区 + 养老区 + 永久区
java8 之后堆内存逻辑上分为三部分:新生区 + 养老区 + 元空间

设置堆内存大小与 OOM

设置堆空间大小的参数

设置堆空间大小的参数
-Xms 用来设置堆空间(年轻代 + 老年代)的初始内存大小
-X 是 jvm 的运行参数
ms 是 memory start
-Xmx 用来设置堆空间(年轻代 + 老年代)的最大内存大小
默认堆空间的大小
初始内存大小:物理电脑内存大小 / 64
最大内存大小:物理电脑内存大小 / 4
手动设置:-Xms600m -Xmx600m
开发中建议将初始堆内存和最大的堆内存设置成相同的值。
查看设置的参数:方式一:jps / jstat -gc 进程 id
方式二:-XX:+PrintGCDetails

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];
    }
}
//Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

年轻代与老年代

存储在 JVM 中的 java 对象可以被划分为两类:

一类是生命周期较短的瞬时对象,这类对象的创建和消亡都非常迅速
另外一类对象的生命周期却非常短,在某些极端的情况下还能够与 JVM 的生命周期保持一致
java 堆区进一步细分的话,可以分为年轻代和老年代

其中年轻代又可以划分为 Eden 空间,Survivor0 和 Survivor1 空间(也叫 from,to 区)

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

默认 -XX:NewRation=2, 表示新生代占 1,老年代占 2,新生代占整个堆的 1 /3
在 HotSpot 中,Eden 空间和另外两个 Survivor 空间大小所占比例为 8:1:1

可以通过 -XX:SurvivorRatio 调整空间比例

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

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

可以通过 -Xmn 设置新生代的最大内存大小

对象分配过程

概述:

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

new 的对象先伊甸园 (Eden)。此区有大小限制
当伊甸园的空间填满时,程序有需要创建对象,JVM 的垃圾回收器将对伊甸园区进行垃圾回收 (Minor GC),将伊甸园区中的不在被其他对象所引用的对象进行销毁。在加载新的对象放到伊甸园区
然后将伊甸园中的剩余对象移动到幸存者 0 区
如果再次触发垃圾回收,此时会重新放回幸存者 0 区,接着再去幸存者 1 区
什么时候进入养老区?可以设置次数。默认为 15
可以设置参数:-XX:MaxTenuringThreshold= 进行设置

注意事项

survivor 区满了不会进行垃圾回收,而是在伊甸园区满了之后垃圾回收算法对伊甸园区进行回收的同时,survivor 区会被动的进行垃圾回收

总结

针对幸存者 S0,S1 区的总结:复制之后有交换,谁空谁是 to
关于垃圾回收:频繁在新生区收集,很少在养老区收集,几乎不在永久区 / 元空间收集

Minor GC,Major GC,Full GC 概念

JVM 在进行 GC 时,并非每次都对上面三个内存 (新生代,老年代,方法区) 区域一起回收的,大部分的时候回收都是指新生代

针对 Hotspot VM 的实现,它里面的 GC 按照回收区域又分为两大种类型:一种是部分收集(Partial GC),一种是整堆收集(FULL GC)

部分收集:不是完整收集 java 堆的垃圾收集。其中又分为:

新生代收集 (Minor GC/Young GC): 只是新生代(Eden/S0,S1) 的垃圾收集
老年代收集 (Major GC/Old GC): 只是老年代的垃圾收集
只有 CMS GC 会有单独收集老年代的行为
注意: 很多时候 Major GC 会和 FULL GC 混淆使用,需要具体分辨是老年代回收,还是整堆回收
混合收集 (Mixed GC): 收集整个新生代以及部分老年代的垃圾收集
目前只有 G1 GC 会有这种行为
整堆收集(FULL GC): 收集整个 java 堆和方法区的垃圾收集

年轻代 GC(Minor GC)触发机制:

当年轻代空间不足时,就会触发 Minor GC,这里的年轻代满指的是 Eden 区满,Survivor 满不会引发 GC(每次 Minor GC 会清理年轻代的内存)
因为 Java 对象大多都是朝生熄灭的特征,所以 Minor GC 非常频繁,一般回收速度比较快。
Minor GC 会引发 STW,暂停其他用户的线程,等垃圾回收结束,用户线程才恢复运行
老年代 GC (Major GC/Full GC)触发机制:

指发生在老 年代的 GC,对象从老年代消失时,我们说“Major GC”或“Fu1l GC”发生了。
出现了 Major GC,经常会伴随至少一. 次的 Minor GC (但非绝对的,在 ParallelScavenge 收集器的收集策略里就有直接进行 MajorGC 的策略选择过程)
也就是在老年代空间不足时,会先尝试触发 Minor GC。如果之后空间还不足,则触发 Major GC
Major GC 的速度一般会比 Minor Gc 慢 10 倍以上,STW 的时间更长。
如果 Major GC 后,内存还不足,就报 00M 了。
Fu11 GC 触发机制
触发 Fu1l GC 执行的情况有如下五种:

调用 System. gc()时,系统建议执行 Full GC,但是不必然执行
老年代空间不足
方法区空间不足
通过 Minor GC 后进入老年代的平均大小大于老年代的可用内存
由 Eden 区、survivor space0 (From Space) 区向 survivor space1 (ToSpace) 区复制时,对象大小大于 To Space 可用内存,则把该对象转存到老年代,且老年代的可用内存小于该对象大小
说明: full gc 是开发或调优中尽量要避免的。这样暂时时间会短一些。

堆空间分代思想

为什么要把 java 堆分代?

经研究表明:不同对象的生命周期不同。70%-99% 的对象都是临时对象
新生代:有 Eden,两块大小相同的 Survivor(from/to 或 S0/S1)构成,其中 to 总为空
不分代能正常工作吗?

其实不分代完全可以,分代的唯一理由就是优化 GC 性能。如果没有分代,那所有的对象都在一块,就如同把一个学校的人都关在一个教室。GC 的时候要找到哪些对象没用这样就会对堆的所有区域进行扫描。而很多对象都是朝生夕死的,如果分代的话,把新创建的对象放到某一地方,当 GC 的时候先把这块存储“朝生夕死”对象的区域进行回收,这样就会腾出很大的空间出来。

内存分配策略

如果对象在 Eden 出生并经过第一次 MinorGC 后仍然存活,并且能被 Survivor 容纳的话,将被移动到 Survivor 空间中,并将对象年龄设为 1。对象在 Survivor 区中每熬过一次 MinorGC,年龄就增加 1 岁,当它的年龄增加到一定程度 (默认为 15 岁,其实每个 JVM、每个 GC 都有所不同) 时,就会被晋升到老年代中。对象晋升老年代的年龄阈值,可以通过选项 -XX : MaxTenuringThreshold 来设置

针对不同年龄段的对象分配原则如下所示:

优先分配到 Eden
大对象直接分配到老年代
尽量避免程序中出现过多的大对象
长期存活的对象分配到老年代
动态对象年龄判断
如果 Survivor 区中相同年龄的所有对象大小的总和大于 Survivor 空间的一半,年龄大于或等于该年龄的对象可以直接进入老年代,无须等到 MaxTenur ingThreshold 中要求的年龄。
空间分配担保
-XX:HandlePromotionFailure

对象分配内存:TLAB(Thread Local Allocation Buffer)

堆区是线程共享的区域,任何线程都可以访问到堆区中的共享数据
由于对象实例的创建在 JVM 中非常频繁,因此在并发环境下从堆区中划分内存空间是线程不安全的
为避免多个线程操作同一地址,需要使用加锁等机制,进而影响分配速度

什么是 TLAB

从内存模型而不是垃圾收集的角度,对 Eden 区域继续进行划分,JVM 为每个线程分配了一个私有缓冲区,它包含在 Eden 空间内
多线程同时分配内存时,使用 TLAB 可以避免一系列的非线程安全问题,同时还能够提升内存分配的吞吐量,因此我们可以将这种内存分配方式称之为快速分配策略

尽管不是所有的对象实例都能够在 TLAB 中成功分配内存,但 JVM 确实是将 TLAB 作为内存分配的首选。
在程序中,开发人员可以通过选项“-XX :UseTLAB”设置是否开启 TLAB 空间。
默认情况下,TLAB 空间的内存非常小,占有整个 Eden 空间的 1%,当然我们可以通过选项“-XX:TLABWasteTargetPercent”设置 TLAB 空间所占用 Eden 空间的百分比大小。
一旦对象在 TLAB 空间分配内存失败时,JVM 就会尝试着通过使用加锁机制确保数据操作的原子性,从而直接在 Eden 空间中分配内存。

分配过程

堆空间的参数配置

测试堆空间常用的 jvm 参数:

-XX:+PrintFlagsInitial : 查看所有的参数的默认初始值
-XX:+PrintFlagsFinal:查看所有的参数的最终值(可能会存在修改,不再是初始值)

 具体查看某个参数的指令:jps:查看当前运行中的进程
 jinfo -flag SurvivorRatio 进程 id

-Xms:初始堆空间内存(默认为物理内存的 1 /64)
-Xmx:最大堆空间内存(默认为物理内存的 1 /4)
-Xmn:设置新生代的大小。(初始值及最大值)
-XX:NewRatio:配置新生代与老年代在堆结构的占比
-XX:SurvivorRatio:设置新生代中 Eden 和 S0/S1 空间的比例
-XX:MaxTenuringThreshold:设置新生代垃圾的最大年龄
-XX:+PrintGCDetails:输出详细的 GC 处理日志
打印 gc 简要信息:① -XX:+PrintGC ② -verbose:gc
-XX:HandlePromotionFailure:是否设置空间分配担保
在发生 MinorGC 之前,虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。

如果大于,则此次 Minor GC 是安全的
如果小于,则虚拟机会查看 -XX: HandlePromotionFailure 设置值是否允许担保失败。
如果 HandlePromotionFailure=true,那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均大小。
如果大于,则尝试进行一次 Minor GC,但这次 Minor GC 依然是有风险的;
如果小于,则改为进行一 - 次 Full GC。
如果 HandlePromotionFailure=false,则改为进行一次 Full GC。
在 JDK6 Update24 之 后,HandlePromotionFailure 参数不会再影响到虚拟机的空间分配担保策略,观察 OpenJDK 中的源码变化,虽然源码中还定义了
HandlePromotionFailure 参数,但是在代码中已经不会再使用它。JDK6 Update24 之后的规则变为只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行 Minor GC,否则将进行 Full GC。

分配对象的选择

在《深入理解 Java 虚拟机》中关于 Java 堆内存有这样一段描述:随着 JIT 编译期的发展与逃逸分析技术逐渐成熟,栈上分配,标量替换优化技术将会导致一些微妙的变化,所有的对象都分配到堆上也渐渐变得不那么绝对了

在 JVM 中,对象是在 java 堆中分配内存的,这是一个普遍的常识,但是,有一种特殊的情况,那就是如果经过逃逸分析 (Escape Analysis) 后发现,一个对象没有逃逸出方法的话,那么久可能被优化成栈上分配。这样就无需在堆上分配内存,也无需进行;垃圾回收了。这也是最常见的堆外存储技术。

此外,在基于 OpenJdk 深度指定的 TaoBaoVm,其中创新的 GCIH(GC invisible heap)技术实现 off-heap, 将生命周期较长的 Java 对象从 heap 中移至 heap 外,并且 GC 不能管理 GCIH 内部的 java 对象,以此达到降低 GC 的回收频率和提升 GC 的回收率的目的

逃逸分析概述

如何将堆上的对象分配到栈,需要使用逃逸分析手段
这是一种有效减少 Java 程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法
通过逃逸分析,Java HotSpot 编译器能够分析出一个新的对象引用的使用范围从而决定是否要将这个对象分配到堆上
逃逸分析的基本行为就是分析对象动态作用域
当一个对象在方法中被定义后,对象只在方法内部使用,则认为没有发生逃逸
当一个对象在方法中被定义后,被外部方法所引用,则认为发生逃逸。例如作为调用参数专递到其他地方中

参数设置:

在 JDK 6u23 版本之后,HotSpot 中默认就已经开启了逃逸分析。
如果使用的是较早的版本,开发人员则可以通过:
选项“-XX: fDoEscapeAnalysis” 显式开启逃逸分析
通过选项“-XX: +PrintEscapeAnalysis” 查看逃逸分析的筛选结果。

代码优化

栈上分配。将堆分配转化为栈分配,如果一个对象在子程序中被分配,要使指向该对象的指针永远不会逃逸,对象可能是栈分配的候选,而不是堆分配
同步省略。如果一个对象被发现只能从一个线程被访问到,那么对于这个对象的操作可以不考虑同步
分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到,那么对象的部分或全部可以不存储在内存,而是存储在 CPU 的寄存器中

栈上分配

JIT 编译器在编译期间根据逃逸分析的结果,发现如果一个对象并没有逃逸出方法的话,就可能被优化成栈上分配。分配完成之后,继续在调用栈内执行,最后线程结束,栈空间被回收,局部变量对象也被回收,这样就无需进行垃圾回收了。

常见的栈上分配场景:给成员变量赋值,方法返回值,实例引用传递

同步省略

线程同步的代价是相当高的,同步的后果是降低并发性和性能。
在动态编译同步块的时候,JIT 编译器可以借助逃逸分析来判断同步块所使用的锁对象是否能够被同一个线程访问而没有被发布到其他线程。如果没有,那么 JIT 编译器在编译这个同步块的时候就去取消对这部分代码的同步功能,这样就能大大提高并发性和性能,这个取消同步的过程就叫同步省略,也叫锁消除

public void f(){Object hollis = new Object();
    synchronized(hollis){System.out.print(hollis)
    }
}

代码中 hollis 这个对象进行加锁,但是 hollis 对象的生命周期只在 f()方法中,并不会被其他线程所访问,所以在 JIT 编译阶段就会被优化掉。优化成:

public void f(){Object hollis = new Object();
    System.out.print(hollis)
}

标量替换

标量 (Scalar) 是指一个无法在分解成更小的数据的数据。Java 中的原始数据类型就是标重.

相对的,那些还可以分解的数据叫做聚合量(Aggregate),Java 中的对象就是聚合量,因为他可以分解成其他聚合量和标量。

在 JIT 阶段,如果经过逃逸分析,发现一个对象不会被外界访问的话,那么经过 JIT 优化,就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。这个过程就是标量替换。

   public static void main(String[] args) {alloc();
    }
    private static void alloc(){Point point = new Point(1,2);
    }
    class Point{
        private int x;
        private int y;
        public Point(int x,int y){
            this.x = x;
            this.y = y;
        }
    }

以上代码经过标量替换后就会变成

 private static void alloc(){
        int x = 1;
        int y = 2;
  }

可以看到,Point 这个聚合量经过逃逸分析后,发现他并没有逃逸,就被替换成两个聚合量了。

标量替换的好处:可以大大减少堆内存的占用,因为一旦不需要创建了,那么就不需要分配堆内存了

标量替换参数

-XX:+EliminateAllocations: 开启了标量替换(默认打开),允许对象打散分配在栈上

正文完
 0