堆（尚硅谷自学笔记）

最新推荐文章于 2023-04-02 22:17:38 发布

ForEverJavalife

最新推荐文章于 2023-04-02 22:17:38 发布

阅读量110

点赞数

文章标签： java jvm

本文链接：https://blog.csdn.net/qq_46004291/article/details/119511139

版权

1 堆的核心概述

一个JVM实例只存在一个堆内存，堆也是Java内存管理的核心区域。

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

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

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

所有的线程共享Java堆，在这里还可以划分线程私有的缓冲区（ ThreadLocal Allocation Buffer,TLAB)。

《Java虚拟机规范》中对Java堆的描述是:所有的对象实例以及数组都应当在运行时分配在堆。(The heap is the run-time data area fromwhich memory for all class instances and arrays is allocated )

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

数组和对象可能永远不会存储在栈上，因为栈帧中保存引用，这个引用指向对象或者数组在堆中的位置。

在方法结束后，堆中的对象不会马上被移除，仅仅在垃圾收集的时候才会被移除。

堆，是GC ( Garbage collection，垃圾收集器）执行垃圾回收的重点区域。

代码理解：

public class simpleHeap{
private int id;
public simpleHeap(int id) {
	this.id = id;
}
public void show() {
	system.out.println( "My ID is " + id);
}
public static void main(string[] args) {
	simpleHeap sl = new simpleHeap(1);
    simpleHeap s2 = new simpleHeap(2);
}

上图是反编译字节码文件后的图片，new代表的就是我们new了一个对象并且开辟空间，newarray就代表new了一个数组

堆的细分

public class HeapDemo {
    public static void main(String[] args) {
        System.out.println("start...");
        try{
            Thread.sleep(1000000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("end....");
    }
}

以上是jvm的参数配置

然后我们用visualvm打开刚才的程序发现确实参数配置进去了

也就是说我们设置的参数只会设置新生代和老年代而不会设置原空间的大小

关于堆空间大小的设置

Java堆区用于存储Java对象实例，那么堆的大小在JVM启动时就已经设定好了，大家可以通过选项"-Xmx"和"-Xms"来进行设置。

①“-Xms"用于表示堆区的起始内存，等价于-XX: InitialHeapsize

②“-xmx"则用于表示堆区的最大内存，等价于- XX:MaxHeapsize

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

通常会将-Xms和一Xmx两个参数配置相同的值，其目的是为了能够在java垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小，从而提高性能。

默认情况下，初始内存大小:物理电脑内存大小 / 64

最大内存大小:物理电脑内存大小 / 4

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 +""");
	System.out.println("-xmx : " + maxMemory + “"");
 }

为其设置空间大小

jps查看当前进程和其进程id，用jstat查看gc当前各程序所用内存情况，按命令行中的情况和配置情况都应该是内存为600才对，

但是输出的却不是600

这是因为伊甸园会存放数据，但是servive0和servive1只能选择一个空间来存放，他们两个始终有一个是空的，导致idea输出的是575。

OOM的举例

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)));
        }
    }
}

新生代和老年代

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

①一类是生命周期较短的瞬时对象，这类对象的创建和消亡都非常迅速。

②另外一类对象的生命周期却非常长，在某些极端的情况下还能够与JVM的生命周期保持一致。

Java堆区进一步细分的话，可以划分为年轻代(YoungGen）和老年代（oldGen)其中年轻代又可以划分为Eden空间、Survivor0空间和survivor1空间（有时也叫做from区、to区)。

一般来说新生代和老年代的空间比例是1：2，而新生代中会细分出伊甸区和存活者0，1区的比例按8：1：1

对象分配过程

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

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

2.当伊甸园的空间填满时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园区进行垃圾回收(Minor GC)，将伊甸园区中的不再被其他对象所引用的对象进行销毁。再加载新的对象放到伊甸园区.

3.然后将伊甸园中的剩余对象移动到幸存者0区。

4.如果再次触发垃圾回收，此时上次幸存下来的放到幸存者0区的，如果没有回收，就会放到幸存者1区。

5.如果再次经历垃圾回收，此时会重新放回幸存者0区，接着再去幸存者1区。

6．啥时候能去养老区呢?可以设置次数。默认是15次。

·可以设置参数:-XX:MaxTenuringThreshold=进行设置。

图片解释：

当我们在创建对象的时候，是会放在Eden（伊甸园区）的，然后当Eden满了之后就会触发YGC，

此时就会判断Eden区中是否有垃圾，有的话GC会将这部分空间释放掉，若有仍被引用的空间，则不是垃圾需要转移到幸存者区（0区或者1区，特别的是0区和1区有一个from区有一个to区），此时0区就是to区，并且会给两个对象加上年龄标签（s中两个绿色的方块表示移动了1次）

清空Eden区后，若此时再往Eden区里创建对象开辟空间又达到满的状态，此时会再次出发YGC，

和第一步差不多(有效对象也是丢到to区去)，但是不同的是会判断幸存者0区的空间中，是否有垃圾需要回收，如果有则释放，没有则讲幸存者0区的有效对象移动到to区，此时的to区是上涨图片空着的s1区，然后经过这些操作后Eden区和S0区又空了，这个时候to区又变成了s0

特殊情况，当Eden又满了，但此时有年龄标签达到15（阈值）的了，就得将达到15的对象进行一个晋升，将他们送到老年代。（该阈值可以被参数修改）

总过程的程序框图

MinorGC，MajorGC，FullGC

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

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

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

①新生代收集(Minor GC / Young Gc) :只是新生代的垃圾收集。

②老年代收集（Major GC / Old GC):只是老年代的垃圾收集。

√目前，只有CMS GC会有单独收集老年代的行为。

√注意，很多时候Major GC会和Full GC混淆使用，需要具体分辨是老年代回收还是整堆回收。

③混合收集(Mixed GC):收集整个新生代以及部分老年代的垃圾收集。

√目前，只有G1 GC会有这种行为

·整堆收集**（Full GC):收集整个java堆和方法区的垃圾收集。**

GC触发条件

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

①当年轻代空间不足时，就会触发Minor Gc，这里的年轻代满指的是Eden代满，Survivor满不会引发Gc。(每次Minor Gc会清理年轻代的内存。)

②因为Java 对象大多都具备朝生夕灭的特性，所以 Minor GC非常频繁，一般回收速度也比较快。这一定义既清晰又易于理解。

③Minor GC会引发STW，暂停其它用户的线程，等垃圾回收结束,用户线程才恢复运行。

·老年代GC (Major GC/Fu1l GC）触发机制:

①指发生在老年代的Gc，对象从老年代消失时，我们说“Major GC”或"Full GC"发生了。

②出现了Major GC，经常会伴随至少一次的Minor Gc（但非绝对的，在ParallelScavenge收集器的收集策略里就有直接进行Major Gc的策略选择过程

√也就是在老年代空间不足时，会先尝试触发Minor Gc。如果之后空间还不足，则触发Major Gc

③Major GC的速度一般会比Minor GC慢10倍以上，STw的时间更长。如果Major GC后，内存还不足，就报OOM了。

④Major GC的速度一般会比Minor GC慢10倍以上。

·Full GC触发机制

触发Full GC执行的情况有如下五种:

(1）调用System.gc()时，系统建议执行Full GC，但是不必然执行

(2）老年代空间不足

(3）方法区空间不足

(4）通过Minor GC后进入老年代的平均大小大于老年代的可用内存

(5）由Eden区、survivor spacee (From Space）区向survivor space1（ToSpace)区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小。(老年代空间不足)

说明: full gc是开发或调优中尽量要避免的。这样暂时时间会短一些。

堆空间分代思想

内存分配策略

对象提升规则

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

对象晋升老年代的年龄阈值，可以通过选项-XX:MaxTenuringThreshold来设置。

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

①优先分配到Eden

②大对象直接分配到老年代

尽量避免程序中出现过多的大对象。

③长期存活的对象分配到老年代(默认阈值15)

④动态对象年龄判断

如果survivor区中相同年龄的所有对象大小的总和大于survivor空间的一半，年龄大于或等于该年龄的对象可以直接进入老年代，无须等到MaxTenuringThreshold中要求的年龄。

·空间分配担保

-XX: HandlePromotionFailure

看看这个例子

根据设置的虚拟机参数，我们可以知道Eden : s0 : s1 = 8 : 1 : 1,Young : Old = 1 : 2

可以得知新生代总共也就20M，还不算幸存者的空间，所以光Eden空间无法容纳buffer，所以会直接放到老年代。

堆空间为每个线程分配TLAB

什么是TLAB?

·从内存模型而不是垃圾收集的角度，对Eden区域继续进行划分JVM为每个线程分配了一个私有缓存区域，它包含在Eden空间内。

.多线程同时分配内存时，使用TLAB可以避免一系列的非线程安全问题，同时还能够提升内存分配的吞吐量，因此我们可以将这种内存分配方式称之为快速分配策略。

·据我所知所有OpenJDK衍生出来的JVM都提供了TLAB的设计。

为什么有TLAB ( Thread Local Allocation Buffer ) ?

·堆区是线程共享区域，任何线程都可以访问到堆区中的共享数据

·由于对象实例的创建在JVM中非常频繁，因此在并发环境下从堆区中划分内存空间是线程不安全的

·为避免多个线程操作同一地址，需要使用加锁等机制，进而影响分配速度。

开启TLAB的参数是-XX:UseTLAB是默认开启的

①尽管不是所有的对象实例都能够在TLAB中成功分配内存，但JVM确实是将TLAB作为内存分配的首选。

②在程序中，开发人员可以通过选项“-XX:UseTLAB”设置是否开启TLAB空间。

③默认情况下，TLAB空间的内存非常小，仅占有整个Eden空间的1%，当然我们可以用XX:TLABwasteTargetPercent设置TLAB空间所占用Eden空间的百分比大小。

一旦对象在TLAB空间分配内存失败时，JVM就会尝试着通过使用加锁机制确保数据操作的原子性，从而直接在Eden空间中分配内存。

对象分配过程

堆空间的参数设置

在发生Minor Gc之前，虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间。

·如果大于，则此次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编译期的发展与逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化，所有的对象都分配到堆上也渐渐变得不那么“绝对”了。

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

此外，前面提到的基于openJDK深度定制的TaoBaoVM，其中创新的GCIH ( GCinvisible heap）技术实现off-heap，将生命周期较长的Java对象从heap中移至heap外，并且cc不能管理ccIH内部的Java对象，以此达到降低cc的回收频率和提升GC的回收效率的目的。

逃逸分析概述

·如何将堆上的对象分配到栈需要使用逃逸分析手段。

·这是一种可以有效减少Java程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法。

·通过逃逸分析，Java Hotspot编译器能够分析出一个新的对象的引用的使用范围从而决定是否要将这个对象分配到堆上。

·逃逸分析的基本行为就是分析对象动态作用域:

>当一个对象在方法中被定义后，对象只在方法内部使用，则认为没有、发生逃逸。

>当一个对象在方法中被定义后，它被外部方法所引用，则认为发生逃逸。例如作为调用参数传递到其他地方中。

逃逸示例

非逃逸

参数设置:

·在JDK 6u23版本之后，Hotspot中默认就已经开启了逃逸分析。

如果使用的是较早的版本，开发人员则可以通过:

-xx:+DoEscapeAnalysis 显式开启逃逸分析

-xx: +PrintEscapeAnalysis”查看逃逸分析的结果

对于透彻的逃逸分析，我们就可以对目标代码进行优化了

一、栈上分配。将堆分配转化为栈分配。如果一个对象在子程序中被分配，要使指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。

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

public class stackAllocation {
public static void main(string[] args){
    long start = system.currentTimeMillis();
    for (int i = o; i < 10000000; i++){
        alloc();
    }
    //查看执行时间
    long end = system.currentTimeMillis();
    System.out.println("花费的时间为:“ +(end - start) + " ms");//为了方便查看堆内存中对象个数，线程sLeep
        try {
        	Thread.sleep( millis: 1000000);
        } catch ( InterruptedException e1) {
    		e1.printstackTrace();
        }              
                       
       }
  	private static void alloc() {
       User user = new User();//未发生逃逸
    }

}

对下方代码，循环快中创建的User显然没有发生逃逸，开启逃逸分析后，则会将new出来的对象放到栈中，时间大幅减少并且不需要gc

常见的栈上分配的场景

在逃逸分析中，已经说明了。分别是给成员变量赋值、方法返回值、实例引用传递。

二、同步省略,如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步。

三、分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分(或全部）可以不存储在内存，而是存储在CPU寄存器中。

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

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

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

标量替换参数设置:

参数-xx:+EliminateAllocations:开启了标量替换(默认打开)，允许将对象打散分配在栈上。

对象还是只能存在于堆上！！

关于逃逸分析的论文在1999年就已经发表了，但直到JDK 1.6才有实现，而且这项技术到如今也并不是十分成熟的。

其根本原因就是无法保证逃逸分析的性能消耗一定能高于他的消耗。虽然经过逃逸分析可以做标量替换、栈上分配、和锁消除。但是逃逸分析自身也是需要进行一系列复杂的分析的，这其实也是一个相对耗时的过程。

一个极端的例子，就是经过逃逸分析之后，发现没有一个对象是不逃逸的。那这个逃逸分析的过程就白白浪费掉了。

虽然这项技术并不十分成熟，但是它也是即时编译器优化技术中一个十分重要的手段。注意到有一些观点，认为通过逃逸分析，JVM会在栈上分配那些不会逃逸的对象，这在理论上是可行的，但是取决于JVM设计者的选择。据我所知，oracle HotspotJVM中并未这么做，这一点在逃逸分析相关的文档里已经说明，所以可以明确所有的对象实例都是创建在堆上。

目前很多书籍还是基于JDK 7以前的版本，JDK已经发生了很大变化，intern字符串的缓存和静态变量曾经都被分配在永久代止，而永久代已经被元数据区取代。但是，intern字符串缓存和静态变量并不是被转移到元数据区，而是直接在堆上分配，所以这一点同样符合前面一点的结论:对象实例都是分配在堆上。

总结

年轻代是对象的诞生、成长、消亡的区域，一个对象在这里产生、应用最后被垃圾回收器收集、结束生命。

老年代放置长生命周期的对象，通常都是从survivor区域筛选拷贝过来的Java对象。当然，也有特殊情况，我们知道普通的对象会被分配在TLAB上;如果对象较大，JVM会试图直接分配在Eden其他位置上;如果对象太大，完全无法在新生代找到足够长的连续空闲空间，JVM就会直接分配到老年代。当Gc只发生在年轻代中，回收年轻代对象的行为被称为MinorGC。

当GC发生在老年代时则被称为MajorGC或者FullGC。一般的，MinorGC的发生频率要比MajorGC高很多，即老年代中垃圾回收发生的频率将大大低于年轻代。