Java的强引用、软引用、弱引用、虚引用

骑猪看日落 2022-12-10 04:54 255阅读 0赞

**背景**

工程中用到guava的本地缓存。它底层实现和API接口上使用了强引用、软引用、弱引用。所以温故知新下，也夯实下基础。

**预备知识**

先来看下GC日志每个字段的含义

**Young GC示例解释**

\[GC (Allocation Failure) \[PSYoungGen: 273405K->20968K(278016K)\] 480289K->473619K(737792K), 0.1090103 secs\] \[Times: user=0.19 sys=0.27, real=0.11 secs\]

**解释**

\[GC(产生GC的原因，例子中是由于分配内存失败)  \[PSYoungGen: 年轻代回收前空间->年轻代回收后空间(年轻代总空间)\] 堆区的回收前空间->堆区的回收后空间(堆区的总空间), GC耗时\] \[Times: 用户空间耗时 系统空间耗时, 实际耗时\]

**Full GC示例解释 **

\[Full GC (Ergonomics) \[PSYoungGen: 20968K->20805K(278016K)\] \[ParOldGen: 452651K->451654K(864256K)\] 473619K->472460K(1142272K), \[Metaspace: 5793K->5793K(1056768K)\], 0.1565987 secs\] \[Times: user=0.70 sys=0.00, real=0.16 secs\]

**解释**

\[Full GC (产生GC原因，例子中是由于要放入老年代的对象超过了老年代的剩余空间) \[PSYoungGen: ->年轻代回收前空间->年轻代回收后空间(年轻代总空间)\] \[ParOldGen: 老年代回收前空间->老年代回收后空间(老年代总空间)\] 堆区的回收前空间->堆区的回收后空间(堆区的总空间), \[Metaspace: 元空间的回收前空间->元空间的回收后空间(元空间的总空间)\],  GC耗时\] \[Times: 用户空间耗时 系统空间耗时, 实际耗时\]

创建一个10M的大对象，重写finalize方法。finalize()方法会在对象被回收前调用，一个对象只有一次被调用的机会。对象可以在这个方法里进行自救，逃过被垃圾回收。Java设计这个方法可以被覆写是为了让有些对象在回收前做一些检查，完成一些前置条件再被垃圾回收。正式代码不建议使用。因为是测试，所以为了验证效果，这里打印GC日志信息。

byte[] bytes = new byte[10 * 1024 * 1024];
        int index;
        public Ref(int index) {
            this.index = index;
        }
    
        public byte[] getBytes() {
            return bytes;
        }
    
        @Override
        public void finalize() {
            System.out.println("index " + index + "'s " + bytes.length + "is going to be GG");
        }
    }

为了测试，JVM参数统一为-Xms20M -XX:+PrintGCDetails。Xms20M表示堆内存设置最大为20M，-XX:+PrintGCDetails代表打印详细的GC信息。

![format_png][]

**强引用**

先来做个实验(代码已经上传github:https://github.com/xiexiaojing/yuna)

@Test
    public void  testRawStrong() {
        List<Ref> list = Lists.newArrayList();
        for(int i=0; i<100; i++) {
            list.add(new Ref(i));
            System.out.println(list.get(i));
        }
    }

这段代码由上线的设置可知，由于最大设置20M堆空间，所以很快触发了GC。

![format_png 1][]

不过Xmx这个值是建议内存最大使用值。如果内存使用超过这个值，jvm认为还有内存可以使用，也会将对象一直往堆里面放。所以2次GC之后JVM自动扩容了，之后就不再频繁GC。最终用到了满足程序需要的内存。

![format_png 2][]

强引用是直接new出来调用的对象，大家都知道。由上面实验可知，在系统内存很富裕的情况下，因为强引用内存不能被释放，所以会多申请了很多内存。

**软引用**

软引用会在系统将要发生内存溢出异常之前，将会把这些软引用对象列进回收范围进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。

用实验说明一下，为了防止JVM自动调整堆大小，我们把堆设置-Xmx200M。

@Test
    public void  testRawSoft() {
        List<SoftReference<Ref>> list = Lists.newArrayList();
        for(int i=0; i<100; i++) {
            list.add(new SoftReference<>(new Ref(i)));
            System.out.println(list.get(i).get());
        }
    }

从下面实验结果可以看到数次的 GC之后，内存要撑不住的时候，Ref的软引用对象触发了finalize方法。这意味着它将要被内存回收了。说明GC会引发软引用里对象的内存回收，即使这个软引用本身还被强引用(list调用)着。

![format_png 3][]

最终回收了这些内存也不能避免OOM的结局：

![format_png 4][]

因为软引用通常情况下就是这样，只有内存马上要溢出了才触发它的GC。就好像扁鹊见蔡桓公的时候，蔡桓公的病已经很深了，马上就没救了。所以有了下面弱引用的方法：有病早治。

**弱引用**

弱引用是发生了一次垃圾回收后，既存的弱引用对象就开始回收。通常，一个弱引用对象仅能生存到下一次垃圾回收前。

用实验说明一下，为了防止JVM自动调整堆大小，我们把堆设置-Xmx200M。

@Test
    public void  testRawWeak() {
        List<WeakReference<Ref>> list = Lists.newArrayList();
        for(int i=0; i<100; i++) {
            list.add(new WeakReference<>(new Ref(i)));
            System.out.println(list.get(i).get());
        }
    }

从下面的实验结果可知在发生了一次GC之后，已经生成的软引用对象都都回收了。下一次GC，这中间产生的软引用对象也都被回收了。

![format_png 5][]

最终，由于GC及时，整个过程没有爆发OOM，平安的结束了。

![format_png 6][]

**虚引用**

虚引用也叫幻影引用。任何时候可能被GC回收，就像没有引用一样。

并且他必须和引用队列一起使用，用于跟踪垃圾回收过程，当垃圾回收器回收一个持有虚引用的对象时，在回收对象后，将这个虚引用对象加入到引用队列中，用来通知应用程序垃圾的回收情况。

先来实验一下，从下面结果可看到从一开始取出来就是空对象，基本上刚创建出来就被回收了。

![format_png 7][]

一个像是从来没有存在过的幻影有什么用呢？Java的Unsafe类和NIO都可以直接访问堆外内存。堆外内存GC管不了，这时候虚引用就排上用场了。我们可以通过引用队列跟踪垃圾回收，做好善后。

**在Guava中使用强软弱引用**

@Test
    public void testStrong() {
        Cache<Integer, Ref> cache = CacheBuilder.newBuilder().expireAfterAccess(1, TimeUnit.DAYS).build();
        for(int i=0; i<100; i++) {
            cache.put(i, new Ref(i));
            System.out.println(cache.getIfPresent(i));
        }
        System.out.println(cache.stats().loadSuccessCount());
    }
    
    @Test
    public void testSoft() {
        Cache<Integer, Ref> cache = CacheBuilder.newBuilder().softValues().build();
        for(int i=0; i<100; i++) {
            cache.put(i, new Ref(i));
            System.out.println(cache.getIfPresent(i));
        }
    }
    
    @Test
    public void testWeak() {
        Cache<Integer, Ref> cache = CacheBuilder.newBuilder().weakKeys().weakValues().build();
        for(int i=0; i<100; i++) {
            cache.put(i, new Ref(i));
            System.out.println(cache.getIfPresent(i));
        }
    }

Guava在没有显示设置强、软、弱引用的情况下默认是强引用。这个结论我没有看任何书，而是通过跟踪源码，debug得到的结论。当显示设置为软引用或者弱引用时，运行时GC触发和对象回收之间的关系和自己手动直接测试的结果是一样的，大家可以动手实践下。

**总结**

Java的强软弱虚引用被回收的时机不同：强引用是引用被释放才会回收；软引用是没释放，但是快OOM了就会被回收；弱引用是引用没释放，但是发生了GC后就会被回收；虚引用随时会回收，好像没有存在过，但是会有一个队列来跟踪它的垃圾回收情况。

**相关阅读**

## [Java异步的2种方式分析][Java_2] ##

## [关于Java两点需要更新的知识][Java] ##

## [阿里巴巴编码规范（Java）证明][Java 1] ##

[format_png]: /images/20221123/f56839ebd63e4bd39cb7fc4de0335659.png
[format_png 1]: /images/20221123/6aad160730a44f9484bbaf53be811748.png
[format_png 2]: /images/20221123/27812f41756a4dedaf7c5ec7b8e3782a.png
[format_png 3]: /images/20221123/53bbe5c2d30d497d9d9b3ed29ad1016d.png
[format_png 4]: /images/20221123/49348197104b456a8d9ac7a42446b5b3.png
[format_png 5]: /images/20221123/1fb284c8644a4d66810dd3a51f1fca2b.png
[format_png 6]: /images/20221123/10805177d587409d87d0a484f699c97c.png
[format_png 7]: /images/20221123/fa6b08e19326441eb4991c5eb6df94b7.png
[Java_2]: http://mp.weixin.qq.com/s?__biz=MzUzNjAxODg4MQ%3D%3D&chksm=fafded0fcd8a6419b90ae0c2f461d81efe87d268676aac4d3ab0fb2c6830fa44a0f4a1dfe4ee&idx=1&mid=2247485345&scene=21&sn=88fa3cd3ddc5ec7fc98ed2548f02060a#wechat_redirect
[Java]: http://mp.weixin.qq.com/s?__biz=MzUzNjAxODg4MQ%3D%3D&chksm=fafdede4cd8a64f21effe09d23efe7adc8d226eb021801a4dcb8f2fb02e2065577eb87bc1474&idx=1&mid=2247485258&scene=21&sn=52a6a62d85e2e1caafcf0a1de46a4860#wechat_redirect
[Java 1]: http://mp.weixin.qq.com/s?__biz=MzUzNjAxODg4MQ%3D%3D&chksm=fafded91cd8a6487ff3a43390b87d7e55e75ca97b26446a4264d93a60b34a8d03378c9f1bca6&idx=1&mid=2247485247&scene=21&sn=62cbc747bea99d91b45104863640f95b#wechat_redirect