别再找了,一文彻底解析Java 中的弱引用(参考官网)

4,852 阅读8分钟

概览

本文会通过对弱引用的定义讲起,然后通过案例的使用一步一步的深入源码进行分析其原理,从而让读者深刻的理解什么是弱引用,如何使用弱引用,什么场景下会使用弱引用,弱引用可以解决什么样的问题,以及它的源码实现是怎样的,其中会涉及的内存溢出,垃圾回收原理

作用:

jdk 官网解释:

弱引用主要应用在不阻止它的key或者value 被回收的mapping。直接贴英文吧,翻译水平有限(weak references are for implementing canonicalizing mappings that do not prevent their keys (or values) from being reclaimed)

个人理解:

弱引用的出现就是为了垃圾回收服务的。它引用一个对象,但是并不阻止该对象被回收。如果使用一个强引用的话,只要该引用存在,那么被引用的对象是不能被回收的。弱引用则没有这个问题。在垃圾回收器运行的时候,如果一个对象的所有引用都是弱引用的话,该对象会被回收

案例深度解析:

理想的情况下,我们希望当我们不再使用一个对象的时候,能够在gc 发生的时候就把它回收掉。但是有些时候,由于我们的粗忽,在坏的情况下会导致内存溢出。这种案例尤其发生在一个生命使用周期很长的map 存放了很多实际使用生命周期短的对象。请看下面这个例子


public class StrongRefenceDemo {


    static Map<String, String> map;

    public static void main(String[] args) throws Exception {

        StrongRefenceDemo demo = new StrongRefenceDemo();
        demo.strongTest();
        System.out.println("gc 发生前:" + map.size());
        System.out.println("开始通知GC");
        //注意,这里只是通过垃圾回收器进行垃圾回收,并不一定马上执行
        System.gc();
        Thread.sleep(1000 * 5);
        System.out.println("gc 发生后:" + map.size());

    }


    /**
     * 强引用测试
     */
    public void strongTest() {
        map = new HashMap<>();
        String key = new String("key");
        String value = new String("value");
        map.put(key, value);
        key = null;
        value = null;
    }

}

运行后输出结果:

gc 发生前:1
开始通知GC
gc 发生后:1

从输出的结果可以看到,即使我们通过把key和value 设置为null 来告诉jvm,我们不再使用这个对象了,map 里面对象依然没有被GC 回收,因为key和value 被一个强引用map 指向,根据可达性判断,垃圾回收器是不能回收掉key和value 这个对象的。map 被定义为statis 的静态变量,是一个使用生命周期很长的对象。在strongTest()方法中存在了一个key和value 的局部变量,它随着方法的执行完,这个变量的生命使用周期就结束了,但是粗糙的程序员忘记remove 了,这个时候垃圾回收器是不能回收它的。如果这种生命周期相对短的对象很多,最终就有可能消耗掉JVM中全部的内存。

但是这里我有一个好奇,假如这里的key和value 指向的对象在执行完strongTest()方法 以后用不着了,但是我可能又不是很好的判断去主动调用remove 来移除它。想要垃圾回收器自己判断回收掉可不可以呢?答案其实是可以的,这个时候就是弱引用上场了,请看下面程序


public class WeakRefenceDemo {

    static Map<WeakReference<String>, String> map;

    public static void main(String[] args) throws Exception {

        WeakRefenceDemo demo = new WeakRefenceDemo();
        demo.weakTest();
        System.out.println("gc 发生前:" + map.size());
        System.out.println("开始通知GC");
        //注意,这里只是通过垃圾回收器进行垃圾回收,并不一定马上执行
        System.gc();
        Thread.sleep(1000 * 5);
        System.out.println("gc 发生后:" + map.size());


    }


    /**
     * 若引用测试
     */
    public void weakTest() {
        map = new WeakHashMap<>();
        String key = new String("key");
        String value = new String("value");
        map.put(new WeakReference<>(key), value);
        key = null;
        value = null;
    }
}

运行上面代码输出结果

gc 发生前:1
开始通知GC
gc 发生后:0

从输出结果0,我们可以判断已经成功被垃圾回收了。what?整个过程我们只是把HashMap 换成了WeakHashMap,并且key 由String 换成了WeakReference。其实就是由于字符串只有弱引用指向,所以可以被垃圾回收掉。是不是很简单,如果到这里你就停止研究弱引用了,那就太暴殄天物了

WeakHashMap 深度解析

上面的程序片段中,其实只有key 设置了为弱引用new WeakReference<>(key),那正常也就只有这个key 对应的内存被回收而已,由于没有调用remove ,里面的value 和entry 也是不会回收掉的,那为什么最后输出的size 是0 呢? 很好的问题,我们深入去看WeakHashMap 的源码,我们发现了一个神奇的方法expungeStaleEntries()。在看源码之前先解析下引用队列的概念: 在弱引用被回收的时候会把该对象放到引用队列中,也就意味着从引用队列中获取的对象都是被回收的对象,先解释到这里,足以满足我们下面的源码分析了,接下来会做详细的解析


    /**
     * Expunges stale entries from the table.
     */
    private void expungeStaleEntries() {
    //这里从引用队列里面取出一个已经被回收的对象
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) {
                @SuppressWarnings("unchecked")
                    Entry<K,V> e = (Entry<K,V>) x;
                int i = indexFor(e.hash, table.length);

                Entry<K,V> prev = table[i];
                Entry<K,V> p = prev;
                //下面就是通过遍历链表来设置值为null 来告诉垃圾回收器回收掉
                //注意WeakHashMap 和HashMap 的数据结构都是通过数组+链表组成的,只有理解了这点才知道下面的代码做了什么
                while (p != null) {
                    Entry<K,V> next = p.next;
                    //相等的时候,就意味着这个就是要回收的对象
                    if (p == e) {
                    //下面就是让回收对象不再被引用
                        if (prev == e)
                   
                            table[i] = next;
                        else
                        
                            prev.next = next;
                        // Must not null out e.next;
                        // stale entries may be in use by a HashIterator
                        //这里通过设置value 为null 来告诉垃圾回收
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
    }

从上面的代码片段,大概的意思就是从引用队列里面取出被回收的对象,然后和WeakHashMap 中的对象查找,找到之后就把对应的value 也设置为null,并且把对应的entry 设置为null,来告诉GC 去回收它。从源码可以看到expungeStaleEntries() 这个方法在执行WeakHashMap中的任何方法的时候都会被调用到的

    /**
     * Returns the table after first expunging stale entries.
     */
    private Entry<K,V>[] getTable() {
    //被调用
        expungeStaleEntries();
        return table;
    }
    
        /**
     * Returns the number of key-value mappings in this map.
     * This result is a snapshot, and may not reflect unprocessed
     * entries that will be removed before next attempted access
     * because they are no longer referenced.
     */
    public int size() {
        if (size == 0)
            return 0;
            //被调用
        expungeStaleEntries();
        return size;
    }

到这里也就完全明白为什么value 不设置为弱引用和没有显性的调用remove 方法也可以回收掉了

引用队列

从上面的的源码中,我们大概知道了引用队列的使用,那为什么要使用引用队列呢?假如没有引用队列,上面的例子我们就需要遍历全部的元素一个一个的去找,如果数量少那还好,如果数量多的时候,肯定就会出现一些性能问题。有了引用队列那就轻松可以解决上面的问题了。从WeakReference 源码中我们可以看到有两个构造函数,第二个是需要传入引用队列的

    public WeakReference(T referent) {
       super(referent);
   }
   
   public WeakReference(T referent, ReferenceQueue<? super T> q) {
       super(referent, q);
   }

引用队列hello word

Object referent = new Object();
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();

WeakReference weakReference1 = new WeakReference<>(referent);
WeakReference weakReference2 = new WeakReference<>(referent, referenceQueue);

使用中需要注意的细节: 由于弱引用的对象在GC 发生的时候都可能会被回收掉,所以在使用之前我们都需要判断下是否为null 来避免空指针异常

Object referent3 = weakReference2.get();
if (referent3 != null) {
    // GC hasn't removed the instance yet
} else {
    // GC has cleared the instance
}

总结

  1. 弱引用的出现是为了垃圾回收的
  2. 一个对象只有弱引用指向它的时候,它是可以被回收的
  3. 弱引用是在GC 发生的时候就进行回收,不管当时内存是否充足
  4. 如果你在创建弱引用指定一个引用队列的话,弱引用对象被回收的时候,会把该对象放入引用队列中
  5. 为了安全使用,每次都要判断下是否为空来判断该对象是否已经被回收,来避免空指针异常

看完两件事

如果你觉得这篇内容对你挺有启发,我想邀请你帮我2个小忙:

  1. 点赞,让更多的人也能看到这篇内容(收藏不点赞,都是耍流氓 -_-)
  2. 关注公众号「面试bat」,不定期分享原创知识,原创不易,请多支持(里面还提供刷题小程序哦)。

jdk8官方文档解析弱引用