十二、垃圾回收的一些概念

一、System.gc()的理解

1、System.gc()方法概述

1、在默认情况下，通过System.gc()或者Runtime.getRuntime().gc()的调用，会显式触发Full GC，同时对老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。

2、调用System.gc()无法保证对垃圾收集器的调用（不能确保立即生效）。

3、一般情况下，垃圾回收应该是自动进行的，无须手动触发，否则太过麻烦了。

2、尝试手动触发GC

public class SystemGCTest {
    public static void main(String[] args) {
        new SystemGCTest();
        //提醒JVM的垃圾回收器执行GC，但不确定是否马上执行GC，与Runtime.getRuntime.gc()作用一样
        System.gc();
        //强制调用使用引用的对象的finalize()方法
        // System.runFinalization();
    }
    
    /**
     * 对象被销毁之前会调用
     * @throws Throwable
     */
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("SystemGCTest 执行了 finalize方法");
    }
}

运行之后，有时候会调用finalize()方法，有时候不会调用finalize()方法。

3、不可达对象回收行为

/**
 * 设置JVM启动参数查看GC信息：-XX:+PrintGCDetails
 */
public class LocalVarGC {
    /**
     * 触发Minor GC没有回收对象，然后在触发Full GC将该对象存入old区
     */
    public void localvarGC1() {
        byte[] buffer = new byte[10 * 1024 * 1024];//10MB
        System.gc();
    }

    /**
     * 触发YoungGC的时候，已经被回收了
     */
    public void localvarGC2() {
        byte[] buffer = new byte[10 * 1024 * 1024];
        buffer = null;
        System.gc();
    }

    /**
     * 不会被回收，因为它还存放在局部变量表索引为1的槽中
     */
    public void localvarGC3() {
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        System.gc();
    }

    /**
     * 会被回收，因为它还存放在局部变量表索引为1的槽中，但是后面定义的value把这个槽给替换了
     */
    public void localvarGC4() {
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        int value = 10;
        System.gc();
    }

    /**
     * localvarGC5中的数组已经被回收
     */
    public void localvarGC5() {
        localvarGC1();
        System.gc();
    }

    public static void main(String[] args) {
        LocalVarGC localVarGC = new LocalVarGC();
        localVarGC.localvarGC1();
    }
}

1、调用localvarGC1()方法

• 执行System.gc()方法，触发Minor GC没有回收对象，然后在触发Full GC之后将young区对象放到了old区。

2、调用localvarGC2()方法

• 在执行System.gc()方法之前，将对象引用设置为空，触发Minor GC将young区对象已经回收了。

3、调用localvarGC3()方法

• 执行System.gc()方法，触发Minor GC没有回收对象，然后在触发Full GC之后将young区对象放到了old区。

• 查看字节码之后，局部变量表的大小为2，实例方法中局部变量表的第一个变量是this（索引为0位置上），在调用System.gc()时，栈中还有buffer变量指向堆中的字节数组。

4、调用localvarGC4()方法

• 执行System.gc()方法，触发Minor GC将buffer对象回收了，在localvarGC3()基础上增加了一个变量value，buffer对象还存放在局部变量表索引为1的槽中，但后面value占用了索引为1的槽，导致堆中字节数组没有引用指向它，执行GC时被回收。

5、调用localvarGC5()方法

• 对象已经被回收

二、内存溢出与内存泄漏

1、内存溢出（OutOfMemory）

1、内存溢出：是指程序在申请内存时，没有足够的内存空间供其使用，并且垃圾收集器也无法提供更多内存。

2、导致内存溢出的常见的原因：

• 内存中加载的数据量过于庞大，如一次从数据库取出过多数据。

• 集合类中没有对对象的引用，使用完后未清空，使得JVM不能回收。

• 代码中存在死循环或循环产生过多重复的对象实体。

• 堆空间内存分配不合理，启动参数内存值设置过小。

3、解决方法：

• 修改JVM启动参数，增加内存。（-Xms与-Xmx参数）

• 检查错误日志，查看OutOfMenmory错误前是否有其他异常或错误。

• 检查对数据库查询中，是否有一次获得全部数据的查询。

• 检查代码中是否有死循环或递归调用。

• 检查是否有大循环重复产生新对象实体。

• 检查List、Map等集合对象是否有使用完后，未清除的问题。List、Map等集合对象会始终存有对对象的引用，使得这些对象不能被GC回收。

• 使用内存查看工具动态查看内存使用情况。

4、说明

• 在抛出OOM之前，通常垃圾收集器会被触发，尽其所能去清理出空间。

• 也有在抛出OOM之前不会触发垃圾收集器，比如分配一个超大对象（超过堆的最大值），JVM可以判断出垃圾收集并不能解决这个问题，所以直接抛出OOM。

2、内存泄漏（Memory Leak）

1、内存泄漏：是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄漏危害可以忽略，但内存泄漏堆积后果狠严重，无论多少内存，迟早会被占光。最终会导致内存溢出。

2、以发生的方式来分类，内存泄漏可以分为4类：

• 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。

• 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。

• 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。

• 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，称这类内存泄漏为隐式内存泄漏。

3、导致内存泄漏的常见原因：

• 循环过多或死循环，产生大量对象。

• 静态集合类引起内存泄漏，因为静态集合的生命周期和JVM一致，所以静态集合引用的对象不能被释放。

• 单例模式，和静态集合导致内存泄漏的原因类似，因为单例的静态特性，它的生命周期和JVM的生命周期一样长，所以如果单例对象如果持有外部对象的引用，那么这个外部对象也不会被回收，那么就会造成内存泄漏。

• 数据连接、IO、Socket连接等等，它们必须显式释放（用代码close掉），否则不会被GC回收。

• 内部类的对象被长期持有，那么内部类对象所属的外部类对象也不会被回收。

4、解决方法：

• 资源性对象在不使用的时候，应该调用它的close()函数将其关闭掉。

• 集合容器中的内存泄漏 ，我们通常把一些对象的引用加入到了集合容器（比如ArrayList）中，当我们不需要该对象时，并没有把它的引用从集合中清理掉，这样这个集合就会越来越大。如果这个集合是static的话，那情况就更严重了。需要在退出程序之前，将集合里的东西clear，然后置为null，再退出程序。

• 内存泄漏也许是因为活动已经被使用完毕，但是仍然在其他地方被引用，导致无法对其进行回收。我们只需要给对活动进行引用的类独立出来或者将其变为静态类，该类随着活动的结束而结束，也就没有了当活动结束但仍然还被其他类引用的情况。

3、内存泄漏官方举例

1、官方举例

• 左边的图：Java使用可达性分析算法，最上面的数据不可达，就是需要被回收的对象。

• 右边的图：后期有一些对象不用了，按道理应该断开引用，但是存在一些链没有断开，从而导致没有办法被回收。

三、Stop The World

1、对Stop The World理解

1、Stop The World简称STW，指的是GC事件发生过程中，会产生应用程序的停顿。停顿产生时整个应用程序线程都会被暂停，没有任何响应，有点像卡死的感觉，这个停顿称为STW。

2、可达性分析算法中枚举根节点（GC Roots）会导致所有Java执行线程停顿，原因如下：

• 分析工作必须在一个能确保一致性的快照中进行。

• 一致性指整个分析期间整个执行系统看起来像被冻结在某个时间点上。

• 如果出现分析过程中对象引用关系还在不断变化，则分析结果的准确性无法保证。

3、被STW中断的应用程序线程会在完成GC之后恢复，频繁中断会给用户造成卡带感觉，因此需要减少STW的发生。

2、注意事项

1、STW事件和使用那种GC无关，所有GC都有这个。

2、哪怕是G1也不能完全避免STW情况发生，只能说垃圾回收器越来越优秀，回收效率越来越高，尽可能地缩短了暂停时间。

3、STW是JVM在后台自动发起和自动完成的。在用户不可见的情况下，把用户正常的工作线程全部停掉。

4、开发中不要用System.gc() ，这会导致STW的发生。

四、垃圾回收的并行与并发

1、并发（Concurrent）

1、在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理器（CPU）上运行。

2、并发不是真正意义上的同时进行，只是CPU把一个时间段划分成几个时间片段（时间区间），然后在这几个时间区间之间来回切换。

3、由于CPU处理的速度非常快，只要时间处理得当，即可让人感觉是多个应用程序同时进行。

2、并行（Parallel）

1、当系统有多个CPU（>1）时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，同时进行，称为并行（Parallel）。

2、真正决定并行的因素是CPU的核心数，而不是CPU的个数。比如一个CPU多个核也可以并行。

3、并行并发对比

1、并发，指的是多个事情，在同一时间段内同时发生了。

2、并行，指的是多个事情，在同一时间点上同时发生了。

3、并发的多个任务之间是互相抢占资源的。并行的多个任务之间是不互相抢占资源的。

4、只有在多CPU或者一个CPU多核的情况中，才会发生并行。否则，看似同时发生的事情，其实都是并发执行的。

4、垃圾回收的并行与串行

1、并行（Parallel）指多条垃圾收集线程并行工作，但此时用户线程仍处于等待状态。

• 如：ParNew、Parallel Scavenge、Parallel Old。

2、串行（Serial）

• 相较于并行的概念，单线程执行。

• 如果内存不够，则程序暂停，启动JVM垃圾回收器进行垃圾回收。回收完，在启动程序的线程。

5、垃圾回收的并发

1、并发（Concurrent）是指用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），垃圾回收线程在执行时不会停顿用户程序的运行。

2、比如用户程序在继续运行，而垃圾收集程序线程运行在另一个CPU上。

3、典型的垃圾回收器：CMS、G1。

五、安全点与安全区域

1、安全点（SafePoint）

1、用户程序执行时并非在代码指令流的任意位置都能够停顿下来开始垃圾收集，而是强制要求必须执行到特定的位置才能够停顿下来开始GC，这些位置被称为安全点。

2、安全点的选定原则：

• 如果太少可能导致GC等待时间过长。

• 如果太频繁可能导致运行时的性能问题（内存负荷增大）。

• 安全点位置的选取基本上是以是否具有让程序长时间执行的特征为标准进行选定的，因为每条指令执行的时间都非常短暂，程序不太可能因为指令流长度太长这样的原因而长时间执行。

• 长时间执行的最明显特征就是指令序列的复用，例如方法调用、循环跳转、异常跳转等都属于指令序列复用，因此只有具有这些功能的指令才会产生安全点。

2、安全点的中断实现方式

1、在GC发生时让所有线程（这里其实不包括执行JNI调用的线程）都跑到最近的安全点，然后停顿下来有两种方式：抢先式中断和主动式中断。

2、抢先式中断（Preemptive Suspension）不需要线程的执行代码主动去配合，在GC发生时，系统首先把所有用户线程全部中断，如果发现有用户线程中断的地方不在安全点上，就恢复这条线程执行，让它一会重新中断，直到跑到安全点上。（目前没有虚拟机采用了）。

3、主动式中断（Voluntary Suspension）当GC需要中断线程的时候，不直接对线程操作，而是设置一个标志位，各个线程执行过程时会不停地主动去轮询这个标志。

• 如果中断标志为真时，就自己在最近的安全点上主动中断挂起。

• 轮询标志的地方和安全点是重合的，另外还要加上所有创建对象和其他需要在Java堆上分配内存的地方，这是为了检查是否即将要发生GC，避免没有足够内存分配新对象。

• 轮询操作会频繁出现，这就要求它足够高效，HotSpot使用内存保护陷阱的方式，把轮询操作精简至只有一条汇编指令的程度。

3、安全区域（Safe Region）

1、出现背景

• 使用安全点的设计似乎已经完美解决如何停顿用户线程，让虚拟机进入垃圾回收状态的问题了。

• 安全点机制保证了程序执行时，在不太长的时间内就会遇到可进入垃圾收集过程的安全点。

• 但是程序不执行的时候呢？所谓的程序不执行就是没有分配处理器时间，典型的场景便是用户线程处于Sleep状态或者Blocked状态，这时候线程无法响应虚拟机的中断请求，不能再走到安全的地方去中断挂起自己，虚拟机也显然不可能持续等待线程重新被激活分配处理器时间。因此，安全区域就出现了。

2、安全区域（Safe Region）是指能够确保在某一段代码片段之中，对象的引用关系不会发生变化，在这个区域中任意地方开始GC都是安全的。可以把安全区域看作是被扩展了的安全点。

4、安全区域的执行流程

1、当用户线程运行到安全区域（Safe Region）里面的代码时，首先会标识自己已经进入了安全区域，当这段时间里虚拟机要发起GC时，就不必去管这些已声明自己在安全区域内的线程了。

2、当线程要离开安全区域时，它要检查虚拟机是否已经完成了根节点枚举（或者垃圾收集过程中其他需要暂停用户线程的阶段），如果完成了，线程就继续执行，否则就一直等待，直到收到可以离开安全区域的信号为止。

六、对象引用

1、概述

1、我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存中；如果内存空间在进行垃圾收集后还是很紧张，则可以抛弃这些对象。

2、在JDK1.2版之后，Java对引用的概念进行了扩充，将引用分为：

• 强引用（Strong Reference）

• 软引用（Soft Reference）

• 弱引用（Weak Reference）

• 虚引用（Phantom Reference）

3、这4种引用强度依次逐渐减弱。除强引用外，其他3种引用均可以在java.lang.ref包中找到它们的身影。如下图，显示了这3种引用类型对应的类，开发人员可以在应用程序中直接使用它们。

2、对四种引用的理解

1、强引用（StrongReference）：最传统的引用定义，是指在程序代码之中普遍存在的引用赋值，即类似Object obj = new Object()这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。

2、软引用（SoftReference）：是用来描述一些还有用，但非必须的对象。只被软引用关联着的对象，在系统将要发生内存溢出（OOM）之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常。在JDK 1.2版之后提供了SoftReference类来实现软引用。

3、弱引用（WeakReference）：是用来描述那些非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集之前。当垃圾收集器开始工作，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK 1.2版之后提供了WeakReference类来实现弱引用。

4、虚引用（PhantomReference）：称为幽灵引用或者幻影引用，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的只是为了能在这个对象被收集器回收时收到一个系统通知。在JDK 1.2版之后提供 了PhantomReference类来实现虚引用。

3、强引用（StrongReference）

1、在Java应用程序中，最常见的引用类型是强引用（普通系统99%以上都是强引用），也就是最常见的普通对象引用，也会默认的引用类型。

2、当在Java中使用new操作符创建一个新的对象，并将其赋值给一个变量的时候，这个变量就成为指向该对象的一个强引用。

3、强引用的对象是可触及的，垃圾收集器就永远不会回收掉被引用的对象。

4、对于一个普通的对象，如果没有其他引用关系，只要超过了引用的作用域或者显式地将相应强引用赋值为null，就是可以当做垃圾被收集了。当然具体的回收还是要看垃圾回收策略。

5、相对的，软引用、弱引用和虚引用的对象是软可触及、弱可触及和虚可触及的，在一定条件下，都是可以被回收的。

6、因此，强引用是造成Java内存泄漏的主要原因之一。

/**
 * 强引用测试
 */
public class StrongReferenceTest {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer("strong reference test");
        StringBuffer str1 = str;

        str = null;
        System.gc();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(str1);
    }
}
/**
 * 运行结果
 */
strong reference test

1、局部变量str指向StringBuffer实例所在堆空间，通过Str可以操作该实例，那么str就是StringBuffer实例的强引用。

2、此时，又运行一个赋值语句str1=str，那么这个时候就有两个局部变量指向堆中同一个StringBuffer实例。

3、将str设置为null，原来堆中的对象不会被回收，因为还有str1指向它。

4、强引用特点：

• 强引用可以直接访问目标对象。

• 强引用所指向的对象在任何时候都不会被系统回收，虚拟机宁愿抛出OOM异常，也不会回收强引用所指向的对象。

• 强引用可能导致内存泄漏。

4、软引用（SoftReference）

1、软引用是用来描述一些还有用，但非必需的对象。只被软引用关联着的对象，在系统将要发生内存溢出（OOM）之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常。

2、软引用通常用来实现内存敏感的缓存。如：高速缓存就有用到软引用。如果还有空闲内存，就可以暂时保留缓存，当内存不足时清理掉，这样就保证了使用缓存的同时，不会耗尽内存。

3、垃圾回收器在某个时刻决定回收软可达的对象的时候，会清理软引用，并可选地把引用存放到一个引用队列（Reference Queue）。

4、类似弱引用，只不过Java虚拟机会尽量让软引用的存活时间长一些，迫不得已才清理。

5、一句话概括：当内存足够时，不会回收软引用可达的对象；内存不够时，会回收软引用的可达对象

6、在JDK1.2版之后提供了SoftReference类来实现软引用。

/**
 * 软引用创建方式
 */
public class SoftReferenceCreate {
    public static void main(String[] args) {
        //声明强引用
        Object obj = new Object();
        //创建一个软引用
        SoftReference<Object> sf = new SoftReference<>(obj);
        //销毁强引用，这是必须的，不然会存在强引用和软引用
        obj = null;
    }
}

/**
 * 软引用的测试
 * 设置JVM启动参数：-Xms10m -Xmx10m
 */
public class SoftReferenceTest {
    public static class Users {
        public int id;
        public String name;

        public Users(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "[id=" + id + ", name=" + name + "] ";
        }
    }

    public static void main(String[] args) {
        //创建对象，建立软引用
        SoftReference<Users> softRef = new SoftReference<Users>(new Users(1, "zhangsan"));
        /**
         * 上面的一行代码，等价于如下的三行代码
         * Users u1 = new Users(1, "zhangsan");
         * SoftReference<Users> sf = new SoftReference<Users>(u1);
         * u1 = null;//取消强引用
         */
        //从软引用中重新获得强引用对象
        System.out.println(softRef.get());
        System.gc();
        System.out.println("After GC：");
        /**
         * 垃圾回收之后获得软引用中的对象
         * 由于堆空间内存足够，所以不会回收软引用的可达对象。
         */
        System.out.println(softRef.get());

        try {
            //创建大对象，让系统认为内存资源紧张、不够
            byte[] b = new byte[1024 * 1024 * 7];
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            /**
             * 再次从软引用中获取数据
             * 在内存不够，报OOM之前，垃圾回收器会回收软引用的可达对象。
             */
            System.out.println(softRef.get());
        }
    }
}

当JVM内存不够时，会清理软引用对象。

5、弱引用（WeakReference）

1、弱引用也是用来描述那些非必需对象，只被弱引用关联的对象只能生存到下一次垃圾收集发生为止。在系统GC时，只要发现弱引用，不管系统堆空间使用是否充足，都会回收掉只被弱引用关联的对象。

2、由于垃圾回收器的线程通常优先级很低，因此并不一定能很快地发现持有弱引用的对象。在这种情况下，弱引用对象可以存在较长的时间。

3、弱引用和软引用一样，在构造弱引用时，也可以指定一个引用队列，当弱引用对象被回收时，就会加入指定的引用队列，通过这个队列可以跟踪对象的回收情况。

4、软引用、弱引用都非常适合来保存那些可有可无的缓存数据。如果这么做，当系统内存不足时，这些缓存数据会被回收，不会导致内存溢出。而当内存资源充足时，这些缓存数据又可以存在相当长的时间，从而起到加速系统的作用。

5、弱引用对象与软引用对象的不同之处在于，当GC在进行垃圾回收时，需要通过算法检查是否回收软引用对象；而对于弱引用对象，GC总是进行回收。弱引用对象更容易、更快被GC回收。

6、在JDK1.2版之后提供了WeakReference类来实现弱引用。

/**
 * 弱引用创建方式
 */
public class WeakReferenceCreate {
    public static void main(String[] args) {
        //声明强引用
        Object obj = new Object();
        //创建一个软引用
        WeakReference<Object> wf = new WeakReference<>(obj);
        //销毁强引用，这是必须的，不然会存在强引用和弱引用
        obj = null;
    }
}

WeakHashMap：用来存储图片信息，可以在内存不足的时候，及时回收，避免了OOM

WeakHashMap类中同样也维护了一个Entry[]数组。Entry类继承了WeakReference类。

/**
 * 弱引用的测试
 */
public class WeakReferenceTest {
    public static class Users {
        public int id;
        public String name;

        public Users(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "[id=" + id + ", name=" + name + "] ";
        }
    }

    public static void main(String[] args) {
        //创建对象，建立弱引用
        WeakReference<Users> weakRef = new WeakReference<Users>(new Users(1, "zhangsan"));
        /**
         * 上面的一行代码，等价于如下的三行代码
         * Users u1 = new Users(1, "zhangsan");
         * SoftReference<Users> sf = new SoftReference<Users>(u1);
         * u1 = null;//取消强引用
         */
        //从弱引用中重新获得强引用对象
        System.out.println(weakRef.get());
        System.gc();
        //不管当前内存空间足够与否，都会回收它的内存
        System.out.println("After GC：");
        //重新从弱引用中获取对象
        System.out.println(weakRef.get());
    }
}
/**
 * 运行结果
 */
[id=1, name=zhangsan] 
After GC：
null

6、虚引用（PhantomReference）

1、也称为幽灵引用或者幻影引用，是所有引用类型中最弱的一个。

2、一个对象是否有虚引用的存在，完全不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它和没有引用几乎是一样的，随时都可能被垃圾回收器回收。

3、它不能单独使用，也无法通过虚引用来获取被引用的对象。当试图通过虚引用的get()方法取得对象时，总是null。

4、为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程。如：能在这个对象被收集器回收时收到一个系统通知。

5、虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象后，将这个虚引用加入引用队列，以通知应用程序对象的回收情况。

6、由于虚引用可以跟踪对象的回收时间，因此，也可以将一些资源释放操作放置在虚引用中执行和记录。

7、在JDK1.2版之后提供了PhantomReference类来实现弱引用。

/**
 * 虚引用创建方式
 */
public class PhantomReferenceCreate {
    public static void main(String[] args) {
       	//声明强引用
        Object obj = new Object();
        //声明引用队列
        ReferenceQueue phantomQueue = new ReferenceQueue();
        //声明虚引用（还需要传入引用队列）
        PhantomReference<Object> pf = new PhantomReference<>(obj, phantomQueue);
        //销毁强引用，这是必须的，不然会存在强引用和虚引用
        obj = null;
    }
}

/**
 * 虚引用测试
 */
public class PhantomReferenceTest {
    //当前类对象的声明
    public static PhantomReferenceTest obj;
    //引用队列
    static ReferenceQueue<PhantomReferenceTest> phantomQueue = null;

    @Override
    protected void finalize() throws Throwable {//此方法只能被调用一次，在进行GC之前调用
        super.finalize();
        System.out.println("调用当前类的finalize方法");
        obj = this;
    }

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while(true) {
                if (phantomQueue != null) {
                    PhantomReference<PhantomReferenceTest> objt = null;
                    try {
                        objt = (PhantomReference<PhantomReferenceTest>) phantomQueue.remove();
                    } catch (Exception e) {
                        e.getStackTrace();
                    }
                    if (objt != null) {
                        System.out.println("追踪垃圾回收过程：PhantomReferenceTest实例被GC了");
                    }
                }
            }
        }, "t1");
        //设置为守护线程：当程序中没有非守护线程时，守护线程也就执行结束
        thread.setDaemon(true);
        thread.start();

        phantomQueue = new ReferenceQueue<>();
        obj = new PhantomReferenceTest();
        //构造了PhantomReferenceTest对象的虚引用，并指定了引用队列
        PhantomReference<PhantomReferenceTest> phantomReference = new PhantomReference<>(obj, phantomQueue);
        try {
            //无法通过虚引用获取被引用的对象，因为为null
            System.out.println(phantomReference.get());
            //去除强引用
            obj = null;
            //第一次进行GC，由于对象可复活，GC无法回收该对象
            System.out.println("第一次GC操作");
            System.gc();
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 不是 null");
            }
            System.out.println("第二次GC操作");
            obj = null;
            //一旦将obj对象回收，就会将此虚引用存放到引用队列中
            System.gc();
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 不是 null");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/**
 * 运行结果
 */
null
第一次GC操作
调用当前类的finalize方法
obj 不是 null
第二次GC操作
追踪垃圾回收过程：PhantomReferenceTest实例被GC了
obj 是 null

从上面运行结果来看：

• 第一次尝试获取虚引用的值，发现无法获取的，这是因为虚引用是无法直接获取对象的值；然后进行第一次GC，因为会调用finalize方法，将对象复活了，所以对象没有被回收。

• 但是调用第二次GC操作的时候，因为finalize方法只能执行一次，所以就触发了GC操作，将对象回收了，同时将会触发第二个操作就是将回收的值存入到引用队列中。

7、终结器引用(FinalReference)

1、它用于实现对象的finalize()方法，也可以称为终结器引用。

2、无需手动编码，其内部配合引用队列使用。

3、在GC时，终结器引用入队。由Finalizer线程通过终结器引用找到被引用对象调用它的finalize()方法，第二次GC时才回收被引用的对象。