虚引用的使用

虚引用相信大家都知道他的作用，但是由于平时不常用，所以实际上手有点困难。

本文目的通过学习虚引用的使用，敲开 LeakCanary 源码学习的大门。

使用虚引用检测对象被回收

虚引用必须与 ReferenceQueue 一起使用，当 GC 准备回收一个对象，如果发现它有虚引用，就会在回收之前，把这个 虚引用 加入到与之关联的 ReferenceQueue 中。

利用这个原理，我们可以检测到对象何时被回收。

下面通过测试代码，说明如何检测。

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "PhantomReferenceDemo";

    // 1、定义为成员变量 防止PhantomReference被回收
    private ReferenceQueue<String> mQueue = new ReferenceQueue<>();
    private PhantomReference<String> mReference;

    // 2、定义为成员变量 方便手动控制回收
    private String mTest;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 4、开启线程 监控回收情况
        new Thread(() -> {
            while (true) {
                Reference<? extends String> poll = mQueue.poll();
                if (poll != null) {
                    Log.e(TAG, "引用被回收：" + poll);
                }
            }
        }).start();

        // 3、
        // 直接用双引号定义的 存储在方法区
        // new出来的 存储在JVM堆
        // 由于GC回收主要针对堆 所以这儿使用new String才能看到效果
        mTest = new String("test");

        mReference = new PhantomReference<>(mTest, mQueue);
    }

    // click 事件
    public void setEmpty(View view) {
        Log.e(TAG, "手动置空");
        mTest = null;
        // 因为Android的垃圾回收机制 这里最好使用MemoryProfiler手动操作垃圾回收
    }
}

下面序号对应代码注释序号。

1、定义 ReferenceQueue 和 PhantomReference。

这里为了方便测试，将 ReferenceQueue 和 PhantomReference 定义为成员变量，防止虚引用及其队列本身被回收。

2、定义要回收的变量。

这里定义测试回收对象 mTest，定义为成员变量的原因是为了手动置空、随时控制垃圾回收的时机。

3、给回收变量赋值。

注意 mTest = new String("test"); 不能替换为 mTest = "test";，原因是垃圾回收主要针对 JVM 堆，而双引号字符串在方法区，不属于垃圾回收的范畴。

4、开启线程，循环判断 ReferenceQueue 中是否有对象。

上面说到如果对象被回收时，其虚引用会被加入到 ReferenceQueue 中，此时队列不为空， Reference<? extends String> poll = mQueue.poll(); 代码被激活，我们就能知道对象发生了回收。

那么如何测试呢？

看下布局：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="#03A9F4"
        android:onClick="setEmpty" // 对应click
        android:padding="10dp"
        android:text="置空"
        android:textColor="#FFFFFF" />

</LinearLayout>

开启程序后，首先点击置空（即调用 setEmpty 函数），将 mTest 设置为 null。

你会发现，循环监控线程并没有反应，这是因为此时并没有发生 gc，即使你在代码后调用 System.gc();，其回收时机也是不确定的。

更好的办法是，使用 Android Memory Profiler，手动强制垃圾回收。

垃圾回收后，我们即能在 logcat 中，看到如下日志：

手动置空
引用被回收：java.lang.ref.PhantomReference@c053ba5

从日志中，仍然无从得知哪个对象被回收了，因为我们看到的是被回收对象的虚引用。
因此，要想通过虚引用检测内存泄漏，必须建立一个回收对象和虚引用的关联。

使用虚引用检测内存泄漏

这里仅提供思路和演示，直接上代码。

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "PhantomReferenceDemo";

    // 定义为成员变量 防止PhantomReference被回收
    private ReferenceQueue<String> mQueue = new ReferenceQueue<>();
    private PhantomReference<String> mReference;

    // 定义为成员变量 方便手动控制回收
    private String mTest;

    // 1、用于判断是否存在内存泄漏
    private Map<PhantomReference, WeakReference<Object>> mMonitor = new HashMap<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 开启线程 监控回收情况
        new Thread(() -> {
            while (true) {
                Reference<? extends String> poll = mQueue.poll();
                if (poll != null) {
                    // 2、
                    mMonitor.remove(poll);
                    Log.e(TAG, "引用被回收：" + poll);
                }
            }
        }).start();

        // 直接用双引号定义的 存储在方法区
        // new出来的 存储在JVM堆
        // 由于GC回收主要针对堆 所以这儿使用new String才能看到效果
        mTest = new String("test");
        // 4、
//        ReferenceOutside.sTest = mTest;

        mReference = new PhantomReference<>(mTest, mQueue);

        // 1、
        mMonitor.put(mReference, new WeakReference<>(mTest));
    }

    public void setEmpty(View view) {
        Log.e(TAG, "手动置空");
        mTest = null;
        // 因为Android的垃圾回收机制 这里最好使用MemoryProfiler手动操作垃圾回收
    }

    // 3、
    public void judgeMemory(View view) {
        Log.e(TAG, "判断是否内存泄漏：");
        for (WeakReference<Object> weakReference : mMonitor.values()) {
            Log.e(TAG, "内存泄漏对象：" + weakReference.get());
        }
    }
}

思路如下：

创建一个 Map，用于保存虚引用和被回收对象的对应关系，这里要使用 WeakReference 引用对象，原因是首先 WeakReference 不会干扰对象的正常回收，二是假如发生内存泄漏，我们可以通过 WeakReference 拿到内存泄漏的对象，而不是虚引用。

当我们手动触发 gc 时，注释 2 处，map 会将正常回收的对象移除掉。也就是说，gc 结束后，map 中未移除的对象即存在内存泄漏（被强引用无法回收）。所以此时，调用注释 3 处，judgeMemory() 函数即可知道内存泄漏的对象。

下面开始测试：

首先是不存在内存泄漏的情况。照旧置空--MemoryProfiler回收-查看日志。日志如下：

手动置空
引用被回收：java.lang.ref.PhantomReference@1f19940
判断是否内存泄漏：

之后测试内存泄漏的情况，为了测试方便，我在注释 4 处，使用静态变量强引用了 mTest，这里放开注释，继续测试，日志如下：

手动置空
判断是否内存泄漏：
内存泄漏对象：test

由于 gc 触发后，mTest 并不能回收，所以监控线程没有执行。因此 gc 后通过 mMonitor，我们就能知道哪些对象没有被回收。

实际开发中，一般在对象生命周期结束时才加入到监控，上面代码仅仅是为了演示。

总结

以上例子仅提供一个思路，来说明虚引用的使用方式和作用，后续将结合 LeakCanary，进一步分析虚引用的实战用途。