Java垃圾回收，首先要知道怎么判断对象是否存活

发表于

这是我参与11月更文挑战的第22天，活动详情查看：2021最后一次更文挑战

  1. 引言

Java 的垃圾回收主要是针对 JVM 中的栈区、堆区、常量区进行的一系列的操作，回收(格式化)掉已经不会被使用到的对象占用的内存，合理化的利用内存资源。

  1. 对象已死？

想要进行垃圾回收，首先要做的，就是如何判断对象是否已经不再被引用。目前有两种常见的算法。

  • 引用计数算法
  • 可达性分析算法

引用计数算法比较简单。其实就是给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1。如果在某个时间段计数值为 0 ，那说明该对象已经不再被引用，可以被回收。

但是引用计数算法有一个非常致命的问题，就是它很难解决双向引用(循环引用)的问题。比如，

1
2
3
4
5
6
7
8
9
ini复制代码
ObjA objA = new ObjA();
ObjB objB = new ObjB();

objA.next = objB;
objB.next = objA;

objA = null;
objB = null;

这种情况下，objA 和 objB 对象的引用计数都不是 0，但是已经没办法使用 objA 和 objB 的对象了。因为出现循环引用，导致引用计数不为 0 ，无法被 GC。

由于引用计数算法存在这样的问题，目前主流的 JVM 均没有采用这种方式，而是采用的是可达性分析算法。

可达性分析算法的核心思想是，通过一系列称之为“GC Roots”的对象作为起始节点，通过这些节点搜索所有可达的节点。当发现某些对象不可达，即说明此对象不可用。可以被回收。

在 Java 中可以作为 GC Roots 的对象包括：

  • 虚拟机栈中引用的对象
  • 方法区中类静态属性引用的对象
  • 方法区中常量引用的对象
  1. finalize() 方法

finalize() 方法是在对象被回收之前调用的方法。但是 finalize() 方法的调用具有不确定性。

当进行完可达性分析之后，某个对象被标记为不可达时，会判断当前对象是否重写了 finalize() 方法，是否已经执行过对象的 finalize() 方法，如果没有覆盖，或者已经执行过，则不再执行，对象将被回收。

如果有必要执行 finalize() 方法，则会将这个对象放到一个 F-Queue 的低优先级队列里等待执行。之后 GC 将对 F-Queue 中的对象再次进行可达性分析。

所以，如果对象可以在 finalize() 方法中再次复活，即将自己的 this 指针，重新赋值到某个可达的对象的引用上。

下面的代码演示了如何在 finalize() 方法中复活对象。（PS:虽然可以这样做，但是一直没有遇到过这样的场景）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
java复制代码public class MyGC {
    private static GCTest gcTest = null;

    private static class GCTest{
        public String name;

        public GCTest(String name) {
            this.name = name;
        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("finalize 被执行");
            //将自身的引用赋值到其他可达 GC Roots 上
            gcTest = this;
        }
    }
    public static void main(String[] args) {
        gcTest = new GCTest("myGc");
        // GCTest 对象不可达
        gcTest = null;
        System.gc();

        //等待 5s
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //对象可达
        System.out.println(gcTest.name);
    }
}

我们定义了一个 MyGC 类，这个类有一个静态属性，类型是一个内部类（GCTest），GCTest 重写了 finalize() 方法，在 finalize() 方法中进行了自救，将自身的引用赋值到了 外部的属性上。所以在 main 方法中，即便是我们显示的将 gcTest 对象置为 null 但是还是可以引用得到。

关于对象的引用，在 Java 1.2 之后，对象的引用分为四大类：

  • 强引用（Strong Reference）

类似”Object obj=new Object()”这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。

  • 软引用（Soft Reference）

对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收

  • 弱引用（Weak Reference）

被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象

  • 虚引用（Phantom Reference）

它是最弱的一种关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%