【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)

目录

  • 1. 什么是垃圾
  • 2. 为什么需要GC
  • 3. C/C++时代(垃圾回收)
  • 4. 自动内存管理
    • 4.1 自动内存管理优点
    • 4.2 自动内存管理缺点
    • 4.3 垃圾回收内存核心区域
  • 5. 垃圾回收相关算法
    • 5.1 引用计数法
    • 5.2 循环依赖
    • 5.3 如何证明Java没有使用引用计数法
    • 5.4 引用计数法解决循环依赖问题
    • 5.5 可达分析算法(GCRoot)
      • 5.5.1 可达性分析算法实现思路
      • 5.5.2 哪些对象可以作为 GC Root 呢?
        • 5.5.2.1 虚拟机栈(栈帧中的本地变量表)中引用的对象
        • 5.5.2.2 方法区中类静态属性引用的对象
        • 5.5.2.3 方法区中常量引用的对象
        • 5.5.2.4 所有被同步锁synchronized持有的对象
      • 5.5.3 (GCRoot)回收过程中stw问题
      • 5.5.4 MAT/分析GC Roots溯源
    • 5.6 对象的 finalize方法
      • 5.6.1 生存还是死亡?
      • 5.6.2 finalize() 细节过程
      • 5.6.3 代码演示 finalize() 方法可复活对象
  • 6. 清除算法
    • 6.1 指针碰撞与空闲列表
      • 6.1.1 指针碰撞
      • 6.1.2 空闲列表
    • 6.2 标记-清除算法
      • 6.2.1 标记清除算法缺点
      • 6.2.2 标记清除算法原理
      • 6.2.3 标记清除算法应用场景
    • 6.3 标记-复制算法
      • 6.3.1 标记-复制原理
      • 6.3.2 标记-复制优缺点
      • 6.3.3 复制算法的应用场景
    • 6.4 标记-压缩算法
      • 6.4.1 标记-压缩算法原理
      • 6.4.2 标记压缩算法与标记清除算法的区别
    • 6.5 垃圾回收算法总结


1. 什么是垃圾

1.垃圾是指在运行程序中没有任何指针指向的对象,这个对象就是需要被回收的垃圾。
外文:An object is considered garbage when it can no longer be reached from any pointer in the running program.
2.如果不及时对内存中的垃圾进行清理,那么,这些垃圾对象所占的内存空间会一直保留到应用程序结束,被保留的空间无法被其他对象使用,甚至可能导致内存溢出。

2. 为什么需要GC

1.对于高级语言(java、python、c#)来说,一个基本认知是如果不进行垃圾回收,内存迟早都会被消耗完,因为不断地分配内存空间而不进行回收,就好像不停地生产生活垃圾而从来不打扫一样。
2.除了释放没用的对象,垃圾回收也可以清除内存里的记录碎片。碎片整理将所占用的堆内存移到堆的一端,以便JVM将整理出的内存分配给新的对象。
3.随着应用程序所应付的业务越来越庞大、复杂,用户越来越多,没有GC就不能保证应用程序的正常进行。而经常造成STW的GC又跟不上实际的需求,所以才会不断地尝试对GC进行优化。

3. C/C++时代(垃圾回收)

  1. 在早期的C/C++时代,垃圾回收基本上是手工进行的。开发人员可以使用new关键字进行内存申请,并使用delete关键字进行内存释放。
  2. 这种方式可以灵活控制内存释放的时间,但是会给开发人员带来频繁申请和释放内存的管理负担。倘若有一处内存区间由于程序员编码的问题忘记被回收,那么就会产生内存泄漏,垃圾对象永远无法被清除,随着系统运行时间的不断增长,垃圾对象所耗内存可能持续上升,直到出现内存溢出并造成应用程序崩溃。
    3.C#、Python、Ruby等语言都使用了自动垃圾回收的思想,也是未来发展趋势,可以说这种自动化的内存分配和来及回收方式已经成为了现代开发语言必备的标准。

4. 自动内存管理

4.1 自动内存管理优点

  1. 我们使用动内存管理,无需开发人员手动参与内存的分配与回收,这样降低内存泄漏和内存溢出的风险
  2. 自动内存管理机制,将程序员从繁重的内存管理中释放出来,可以更专心地专注于业务开发

4.2 自动内存管理缺点

  1. 使用自动内存管理,太过度依赖“自动”,程序员开发者需要掌握 jvm垃圾回收原理,方便在后期定位程序内存溢出的问题。

4.3 垃圾回收内存核心区域

堆和元空间(方法区)

回收次数:

  1. 频繁的回收新生代;
  2. 较少的回收老年代;
  3. 基本不回收元空间(方法区);

5. 垃圾回收相关算法

5.1 引用计数法

使用一个计数器来记录每个对象被引用的次数。当对象被引用时,计数器加1;当对象的引用被解除时,计数器减1;当引计数器为0时,对象会被回收。
注意:在java中是没有使用引用计数法
优点:实现简单,垃圾对象便于辨识;判定效率高,回收没有延迟性。
缺点:从空间/时间复杂度考虑:
1.它需要单独的字段存储计数器,这样的做法增加了存储空间的开销。
2.每次赋值都需要更新计数器,伴随着加法和减法操作,这增加了时间开销。
3.引用计数器有一个严重的问题,即无法处理循环引用的情况。

5.2 循环依赖

相关图:
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第1张图片

当栈空间中 demo1、demo2==null时,demo1对象与demo2对象
内部实现相互引用形成相互引用,导致该对象无法被回收,最终导致内存泄漏
的问题。

【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第2张图片

public static void main(String[] args) {
    Demo demo1 = new Demo("demo", 22);
    Demo demo2 = new Demo("xiaowang", 22);
    demo1.reference = demo2;
    demo2.reference = demo1;

}

static class Demo {
    private String name;
    private Integer age;

    public Demo(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    private Demo reference;
}


5.3 如何证明Java没有使用引用计数法

/**
 * -XX:+PrintGCDetails
 * 证明:java使用的不是引用计数算法
 */
public static void main(String[] args) {
    Demo demo1 = new Demo("demo", 22);
    Demo demo2 = new Demo("xiaowang", 22);
    demo1.reference = demo2;
    demo2.reference = demo1;
    demo1 = null;
    demo2 = null;
    //这里发生GC,demo1和demo2能否被回收?
    System.gc();

}

static class Demo {
    private String name;
    private Integer age;
    //这个成员属性唯一的作用就是占用一点内存
    private byte[] bigSize = new byte[5 * 1024 * 1024];//5MB

    public Demo(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    private Demo reference;
}


如果使用的是引用计数法不小心直接把demo1.reference和demo2.reference置为null。则在Java堆中的两块内存依然保持着互相引用,无法被回收。
但是java没有使用引用计数法。
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第3张图片

5.4 引用计数法解决循环依赖问题

在Python中使用到引用计数法
为了解决循环依赖问题:

  1. 手动解除 解决对象之间依赖关系;
  2. 使用弱引用weakref,weakref是Python提供的标准库,解决循环引用。

5.5 可达分析算法(GCRoot)

可达性分析算法概念:也可以称为根搜索算法、追踪性垃圾收集
1.相对于引用计数算法而言,可达性分析算法不仅同样具备实现简单和执行高效等特点,更重要的是该算法可以有效地解决在引用计数算法中循环引用的问题,防止内存泄漏的发生。
2.相较于引用计数算法,这里的可达性分析就是Java、C#选择的。这种类型的垃圾收集通常也叫作追踪性垃圾收集(Tracing Garbage Collection)

5.5.1 可达性分析算法实现思路

所谓"GCRoots”根集合就是一组必须活跃的引用

其基本思路如下:
1.可达性分析算法是以根对象集合(GCRoots)为起始点,按照从上至下的方式搜索被根对象集合所连接的目标对象是否可达。
2.使用可达性分析算法后,内存中的存活对象都会被根对象集合直接或间接连接着,搜索所走过的路径称为引用链(Reference Chain)
3.如果目标对象没有任何引用链相连,则是不可达的,就意味着该对象己经死亡,可以标记为垃圾对象。
4.在可达性分析算法中,只有能够被根对象集合直接或者间接连接的对象才是存活对象。
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第4张图片

5.5.2 哪些对象可以作为 GC Root 呢?

1.虚拟机栈(栈帧中的本地变量表)中引用的对象
2.本地方法栈中 JNI(即一般说的 Native 方法)引用的对象
3.方法区中类静态属性引用的对象
4.方法区中常量引用的对象 比如:字符串常量池(StringTable)里的引用
5.所有被同步锁synchronized持有的对象
6.Java虚拟机内部的引用。
基本数据类型对应的Class对象,一些常驻的异常对象(如:NullPointerException、OutofMemoryError),系统类加载器。
7.反映java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。
虚拟机栈中引用的对象

5.5.2.1 虚拟机栈(栈帧中的本地变量表)中引用的对象

如下代码所示,o 是栈帧中的本地变量,当 o= null 时,由于此时 o充当了 GC Root 的作用,o 与原来指向的实例 new Object() 断开了连接,所以对象会被回收。

public static void main(String[] args) {
    Object o = new Object();
    o = null;
}

5.5.2.2 方法区中类静态属性引用的对象

如下代码所示,当栈帧中的本地变量 a = null 时,由于 a 原来指向的对象与 GC Root (变量 a) 断开了连接,所以 a 原来指向的对象会被回收,而由于我们给 s 赋值了变量的引用,s 在此时是类静态属性引用,充当了 GC Root 的作用,它指向的对象依然存活!

//方法区中类静态属性引用的对象
private static Test05 s;

public static void main(String[] args) {
    Test05 t = new Test05();
    t.s = new Test05();
    t = null;
}


5.5.2.3 方法区中常量引用的对象

如下代码所示,常量 s 指向的对象并不会因为 a 指向的对象被回收而回收

//方法区中常量引用的对象
private static final Test06 s = new Test06();

public static void main(String[] args) {
    Test06 a = new Test06();
    a = null;
}

5.5.2.4 所有被同步锁synchronized持有的对象

private Object object = new Object();


//-XX:+PrintGCDetails
public static void main(String[] args) {
    Test07 test07 = new Test07();
    test07.cal();


}

public void cal() {
    DemoLock demoLock = new DemoLock();
    synchronized (demoLock) {
        demoLock = null;
        System.gc();
        try {
            Thread.sleep(50000000);
        } catch (Exception e) {
             e.printStackTrace();
        }
    }
}

class DemoLock {
    private byte[] bytes = new byte[5 * 1024 * 1024];
}


5.5.3 (GCRoot)回收过程中stw问题

如果要使用可达性分析算法来判断内存是否可回收,那么分析工作必须在一个能保障一致性的快照中进行。这点不满足的话分析结果的准确性就无法保证。
这点也是导致GC进行时必须“Stop The World”的一个重要原因。即使是号称(几乎)不会发生停顿的CMS收集器中,枚举根节点时也是必须要停顿的。

5.5.4 MAT/分析GC Roots溯源

MAT是Memory Analyzer的简称,它是一款功能强大的Java堆内存分析器。用于查找内存泄漏以及查看内存消耗情况。
MAT是基于Eclipse开发的,是一款免费的性能分析工具。
大家可以在http://www.eclipse.org/mat/下载并使用MAT

1.获取 dump 文件方式
这些文件记录了JVM运行期间的内存占用、线程执行等情况,这就是我们常说的dump文件。常用的有heap dump和thread dump(也叫javacore,或java dump)。我们可以这么理解:heap dump记录内存信息的,thread dump是记录CPU信息的。

5.6 对象的 finalize方法

finalize()是Object中的方法,当垃圾回收器将要回收对象所占内存之前被调用,即当一个对象被虚拟机宣告死亡时会先调用它finalize()方法,让此对象处理它生前的最后事情(这个对象可以趁这个时机挣脱死亡的命运)。要明白这个问题,先看一下虚拟机是如何判断一个对象该死的。

1.对象销毁前的回调方法:finalize()
2.Java语言提供了对象终止(finalization)机制来允许开发人员提供对象被销毁之前的自定义处理逻辑。
3.当垃圾回收器发现没有引用指向一个对象,即:垃圾回收此对象之前,总会先调用这个对象的finalize()方法。
4.finalize() 方法允许在子类中被重写,用于在对象被回收时进行资源释放。通常在这个方法中进行一些资源释放和清理的工作,比如关闭文件、套接字和数据库连接等。

5.6.1 生存还是死亡?

1.由于finalize()方法的存在,虚拟机中的对象一般处于三种可能的状态。
2.如果从所有的根节点都无法访问到某个对象,说明对象己经不再使用了。一般来说,此对象需要被回收。但事实上,也并非是“非死不可”的,这时候它们暂时处于“缓刑”阶段。一个无法触及的对象有可能在某一个条件下“复活”自己,如果这样,那么对它立即进行回收就是不合理的。为此,定义虚拟机中的对象可能的三种状态。
3.如下:
3.1可触及的:从根节点开始,可以到达这个对象。
3.2可复活的:对象的所有引用都被释放,但是对象有可能在finalize()中复活。
3.3不可触及的:对象的finalize()被调用,并且没有复活,那么就会进入不可触及状态。不可触及的对象不可能被复活,因为finalize()只会被调用一次。

5.6.2 finalize() 细节过程

1.判定一个对象objA是否可回收,至少要经历两次标记过程:
2.如果对象objA到GC Roots没有引用链,则进行第一次标记。
3.进行筛选,判断此对象是否有必要执行finalize()方法
4.如果对象objA没有重写finalize()方法,或者finalize()方法已经被虚拟机调用过,则虚拟机视为“没有必要执行”,objA被判定为不可触及的。
5.如果对象objA重写了finalize()方法,且还未执行过,那么objA会被插入到F-Queue队列中,由一个虚拟机自动创建的、低优先级的Finalizer线程触发其finalize()方法执行。
6.finalize()方法是对象逃脱死亡的最后机会,稍后GC会对F-Queue队列中的对象进行第二次标记。如果objA在finalize()方法中与引用链上的任何一个对象建立了联系,那么在第二次标记时,objA会被移出“即将回收”集合。之后,对象会再次出现没有引用存在的情况。在这个情况下,finalize()方法不会被再次调用,对象会直接变成不可触及的状态,也就是说,一个对象的finalize()方法只会被调用一次。

5.6.3 代码演示 finalize() 方法可复活对象

public class Test08 {
    public static Test08 obj;//类变量,属于 GC Root

    @Override
    protected void finalize() throws Throwable {
        System.out.println("我Test08类重写了 父类中的 finalize 方法 ");
        obj = this;//当前待回收的对象在finalize()方法中与引用链上的一个对象obj建立了联系
    }

    public static void main(String[] args) throws InterruptedException {
        try {
            obj = new Test08();
            obj = null;
            System.gc();//调用垃圾回收器
            System.out.println("第1次 gc");
            // 因为Finalizer线程优先级很低,暂停2秒,以等待它
            Thread.sleep(2000);
            if (obj == null) {
                System.out.println("该obj 对象 是为null的呢");
            } else {
                System.out.println("该obj 对象 还活着");
            }
            System.out.println("第2次 gc");
            // 下面这段代码与上面的完全相同,但是这次自救却失败了
            obj = null;
            System.gc();
            // 因为Finalizer线程优先级很低,暂停2秒,以等待它
            Thread.sleep(2000);
            if (obj == null) {
                System.out.println("该obj 对象 是为null的呢");
            } else {
                System.out.println("该obj 对象 还活着");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


6. 清除算法

6.1 指针碰撞与空闲列表

6.1.1 指针碰撞

假设Java堆中内存是绝对规整的,所有用过的内存都放在一边,空闲的内存放在另一边,中间放着一个指针作为分界点的指示器,那所分配内存就仅仅是把那个指针向空闲空间那边挪动一段与对象大小相等的距离,这种分配方式称为“指针碰撞”(Bump thePointer)
指针碰撞:
1.假设java堆中的内存是绝对规整的,指针作为已分配内存和未分配内存的分界线;
2.给变量分配内存的过程就是将作为分界线的指针未分配内存空间挪动一个变量的大小。
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第5张图片

6.1.2 空闲列表

如果Java堆中的内存并不是规整的,已使用的内存和空闲的内存相互交错,那就没有办法简单地进行指针碰撞了,虚拟机就必须维护一个列表,记录上哪些内存块是可用的,在分配的时候从列表中找到一块足够大的空间划分给对象实例,并更新列表上的记录,这种分配方式称为“空闲列表”(FreeList)
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第6张图片
1.如果java堆中的内存分配不是很规整,虚拟机就会
维护一个空闲列表,用来记录剩余可用的内存空间;
2.每次为变量分配内存后动态的去维护这个列表。

如果区分出内存中存活对象和死亡对象后,GC接下来的任务就是执行垃圾回收,释放掉无用对象所占用的内存空间,以便有足够的可用内存空间为新对象分配内存。目前在JVM中比较常见的三种垃圾收集算法是
标记-清除算法(Mark-Sweep)
复制算法(Copying)
标记-压缩算法(Mark-Compact)

6.2 标记-清除算法

1.标记:从引用根节点开始遍历,标记所有被引用的对象。一般是在对象的Header中记录为可达对象。
2.清除:对堆内存从头到尾进行线性的遍历,如果发现某个对象在其Header中没有标记为可达对象,则将其清除
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第7张图片
回收后:
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第8张图片

6.2.1 标记清除算法缺点

1.标记清除算法的效率不是很高
2.在进行GC的时候,需要停止整个应用程序,stw问题严重
3.会产生空闲内存不连续的,产生大量的碎片问题,需要维护一个空闲列表

6.2.2 标记清除算法原理

这里所谓的清除并不是真的置空,而是把需要清除的对象地址保存在空闲的地址列表里。下次有新对象需要加载时,判断垃圾的位置空间是否够,如果够就存放从空闲列表查找内存地址存放。(也就是覆盖原有的地址)。

6.2.3 标记清除算法应用场景

标记清除算法的老年代垃圾回收器

6.3 标记-复制算法

为了解决标记-清除算法在垃圾收集效率方面的缺陷,M.L.Minsky于1963年发表了著名的论文,“使用双存储区的Lisp语言垃圾收集器CA LISP Garbage Collector Algorithm Using Serial Secondary Storage)”。M.L.Minsky在该论文中描述的算法被人们称为复制(Copying)算法,它也被M.L.Minsky本人成功地引入到了Lisp语言的一个实现版本中。

6.3.1 标记-复制原理

将活着的内存空间分为两块,每次只使用其中一块(s0/s1 两块空间是相等的),在垃圾回收时将正在使用的内存中的存活对象复制到未被使用的内存块中,之后清除正在使用的内存块中的所有对象,交换两个内存的角色,最后完成垃圾回收,将存活的对象拷贝到另外区间,内存地址可能会发生变化的。

【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第9张图片
【JVM】JVM内存结构之——垃圾回收算法(引用计数法/ 可达分析算法/ 标记清除算法/ 标记复制算法/ 标记压缩算法)_第10张图片
s0/s1区交换来回拷贝

6.3.2 标记-复制优缺点

1.优点
1.1复制过去以后保证空间的连续性,解决了“碎片”问题。
1.2.没有标记和清除过程,实现简单,运行高效
2.缺点
2.1此算法的缺点也是很明显的,就是需要两倍的内存空间(s0/s1)。
2.2以空间换时间的形式 提高效率上的问题。
2.3将存活的对象拷贝到另外区间,内存地址可能会发生变化的。

6.3.3 复制算法的应用场景

标记复制算法应用在新生代比较多,因为新生代触发gc回收频率是非常高的
所以最好使用效率比较高的回收算法—标记复制算法

老年代为什么不推荐使用标记复制算法呢?缺点 老年代中的对象是大对象、拷贝效率很低
标记复制算法适合于拷贝一些较小的对象

6.4 标记-压缩算法

  1. 复制算法的高效性是建立在存活对象少、垃圾对象多的前提下的。这种情况在新生代经常发生,但是在老年代,更常见的情况是大部分对象都是存活对象。如果依然使用复制算法,由于存活对象较多,复制的成本也将很高
  2. 标记-清除算法的确可以应用在老年代中,但是该算法不仅执行效率低下,而且在执行完内存回收后还会产生内存碎片,所以JVM的设计者需要在此基础之上进行改进。标记-压缩(Mark-Compact)算法由此诞生。

6.4.1 标记-压缩算法原理

第一阶段和标记清除算法一样,从根节点开始标记所有被引用对象
第二阶段将所有的存活对象压缩到内存的另一端,按顺序排放,之后,清理边界外所有的空间。

6.4.2 标记压缩算法与标记清除算法的区别

  1. 标记-压缩算法的最终效果等同于标记-清除算法执行完成后,再进行一次内存碎片整理,因此,也可以把它称为标记-清-压缩(Mark-Sweep-Compact)算法。
  2. 标记-清除 不会移动内存地址、标记-压缩算法会进行整理碎片会发生移动内存地址
  3. 标记-压缩算法采用指针碰撞、标记-清除采用空闲列表;

6.5 垃圾回收算法总结

  标记清除 标记整理 复制算法
速率 中等(1. 不会移动存活对象2. 标记清除 垃圾对象存放空闲列表中) 最慢(1. 标记清除2. 移动存活对象3. 解决碎片化问题) 快(1. 将存活对象拷贝到另外一个区间2. 发生了移动对象3. 栈帧中引用内存地址发生变化)
空间开销 少(会发生碎片化) 少(不堆积碎片) 通常需要存活对象的2倍空间(不堆积碎片) s0 s1 来回拷贝
移动对象
应用场景 老年代 老年代 新生代

你可能感兴趣的