java 内存回收和四种引用关系_SoftReference,WeakReference,PhantomReference

古城微笑少年丶 2022-03-10 06:42 333阅读 0赞

众所周知java的引用分为四种,分别是强引用，软引用，弱引用，虚引用。 今天就来说一下 他们的区别，以及作用。

## 内存回收 ##

首先，如果你想看懂下面的内容，那么我强烈的推荐你先看一下我的另一篇博客[java内存管理关系及内存泄露原理][java]。如果，你已经看了上篇的文章，那么你对java内存这方面就应该有一些概念了。  
现在，来说一下内存回收。可能有人会说不对啊。java里面有内存回收这东西么？不都是自动的么？**由垃圾收集器（GC）来完成内存回收的工作。****是的，java里面的内存回收都是由垃圾收集器操作的**。**但是垃圾收集器不是万能的，它只会按照自己的规则来判断 ，当前这个内存是否可以被回收，如果可以那么回收内存。**

**垃圾收集器判断内存是否可以回收的规则**  
**1.内存空间当前如果没有强引用，但是有软引用，那么只有在内存耗尽的时候，才可以回收。  
2.内存空间之间如果存在 环形强引用（隔离岛），没有线程可以访问到它，那么可以回收。  
3. 内存空间当前如果没有强引用，没有线程可以访问到它，那么可以回收。**

一共三条规则，GC是从第一条开始验证，直到最后一条。如果有一条满足，那么就是可以回收的内存。

##### 内存空间 #####

有人会好奇 内存空间是什么?

Island one;//声明一个Island类，此时 只是声明，没有实例
            one = new Island();//开辟一个内存空间，并将内存空间和one 建立强引用
            
            one=null;//如果，只有这三行代码，那么上面开辟出来的内存空间，将会被GC回收

内存空间 **就是 new Island() 在内存中开辟出来的 一小块地方**。当我们one=null的时候，**刚刚开辟的内存空间，已经没有任何一个引用了，那么GC就会回收这部分内存。**

有的人会比较疑问 **环形强引用(隔离岛)** 是什么？

public class Island { 
        Island i;//强引用其他对象
    
        public static void main(String[] args) { 
            Island i2 = new Island();
            Island i3 = new Island();
            Island i4 = new Island();
    
            i2.i = i3;//i2引用i3
            i3.i = i4;//i3引用i4
            i4.i = i2;//i4引用i2
    
            i2 = null;//将对象和内存空间 断开引用 
            i3 = null;//将对象和内存空间 断开引用 
            i4 = null;//将对象和内存空间 断开引用 
    
            //这时候 就是隔离岛 
            // 尽管 i2，i3，i4都被强引用了，但是线程已经无法访问到他们了
            // i2 i3 i4 都可以被回收
        }
    }

看上面这段代码，就可以看出来，Island类内部会持有自己同类型的其他类实例。**上面的 i2，i3，i4都被强引用了，但是线程已经无法访问到他们了。**他们之间就像是一个环，一个独立的岛。

好了，接下来 ，就可以看引用关系了。当然不是 先看一个类

## Reference ##

这是 软引用，弱引用和虚引用的父类，大家主要关注这几个方面就行,**源代码不止这些，这些是我挑选出来的代码！！！！！**

public abstract class Reference<T> { 
      private T referent;         /* Treated specially by GC */
     
      volatile ReferenceQueue<? super T> queue;
    
    
       Reference(T referent) { 
            this(referent, null);
        }
    
        Reference(T referent, ReferenceQueue<? super T> queue) { 
            this.referent = referent;
            this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
        }
    }

从上面可以看出 **父类Reference内部持有一个泛型T的强引用referent。****这个是由构造方法传入，也就是 软引用，弱引用，虚引用 要持有的对象。**

是通过内部持有 引用这种方式 实现的。

**方法**

返回此引用对象的referent。如果这个引用对象被程序或垃圾收集器清除，那么这个方法返回null。
     public T get() { 
            return this.referent;
        }
    
    
    下面三个方法仅由Java代码调用;当垃圾收集器清除引用时，它直接这么做，而不调用此方法。
    
    清除此引用对象。调用此方法不会导致该对象进入队列。
    public void clear() { 
            this.referent = null;
        }
    
    指示此引用对象是否已被程序或垃圾收集器加入队列。如果这个引用对象在创建队列时没有注册，那么这个方法总是返回false。
    public boolean isEnqueued() { 
        return (this.queue == ReferenceQueue.ENQUEUED);
    }
    
    将此引用对象添加到与其注册的队列中(如果有的话)。
    public boolean enqueue() { 
        return this.queue.enqueue(this);
    }

## 强引用 ##

强引用，重点在**强**上面。对于强引用，我们需要知道是，**如果，一个内存空间被强引用了。那么如果此时内存资源不够了，JVM是宁愿抛出OutOfMemoryError异常，也不会回收有强引用的内存空间。**

**强引用示例**：

Island i2 = new Island();

## 软引用 SoftReference ##

首先来看一下，官方对于软引用的介绍重点。

1 软引用对象，由垃圾收集器根据内存需求自行清除。软引用通常用于实现内存敏感的缓存。
    
    2 在虚拟机抛出OutOfMemoryError错误之前，保证对softly-reachable对象的所有软引用都已被清除。
    
    3 只要软引用的referent是strongly-reachable的，也就是说，它实际上在使用，就不会清除软引用。

###### 解释一下strongly-reachable，和softly-reachable ######

//声明一个strong类的对象 strong，并且开辟一个内存空间（就叫one） 和strong联系起来
            // strong对象和one内存空间 的关系就是 strongly-reachable 强可达
            Island strong = new Island();
    
            //声明一个软引用对象soft，软引用的值是strong（通过strong 最终和one内存空间有联系）
            //soft对象和one内存空间 的关系就是 softly-reachable 软可达
            SoftReference<Island> soft = new SoftReference<>(strong);

上面的注释 很清楚，大体可以这么理解为**强引用 联系的关系 是strongly-reachable，软引用 联系的关系是softly-reachable。**

从上面的文字介绍，还有GC判断法则，我们可以得知，**在内存空间不足的时候，JVM会回收所有的软引用对象 的 referent内存空间（软引用对象的referent内存空间，不能有强引用，否则，不会被回收）。**

## 构造方法 ##

//创建一个软引用对象， 软引用对象的referent内存空间 是referent对应的 内存空间。 
    public SoftReference(T referent)
    
    //创建一个软引用对象， 软引用对象的referent内存空间 是referent对应的 内存空间。 ReferenceQueue 这是一个引用队列，在软引用对象 取消 引用联系的时候，将软引用对象 排入队列中
    public SoftReference(T referent, ReferenceQueue<? super T> q)

第二个构造方法的ReferenceQueue，**就是如果GC将软引用对象取消和 referent内存空间的联系。那么 软引用对象就会被添加到ReferenceQueue队列中。**

**使用示例**

//生成引用队列
    ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
    //创建软引用对象
    SoftReference<String> stringSoftReference = new SoftReference<>("123", referenceQueue);
    //由于不好模拟出内存耗尽，软引用回收 ，到内存耗尽，就爆了异常，还没输出日志，jvm就挂了，，， 所以调用这个方法也是一样的效果。
    // 模拟GC，将软引用对象添加到队列
    stringSoftReference.enqueue();
    //note 注意 referenceQueue.poll().get() 
    System.out.println("队列里面是否有数据 " + referenceQueue.poll().get());
    //模拟GC，将软引用对象回收（其实是软引用对象内部的referent内存空间回收）
    stringSoftReference.clear();
    System.out.println("软引用对象 是否 持有 引用对象" + stringSoftReference.get());

**输出结果：**  
![在这里插入图片描述][20190309215000775.]  
要特别注意**ReferenceQueue队列添加的是软引用对象本身。****当内存不足的时候，软引用对象的referent内存空间，又只有软引用这一个 引用。那么，referent内存空间就会被回收了。**  
**note：**  
**当软引用内部的referent内存空间被回收后，软引用对象本身并不会被回收。**

## 弱引用 WeakReference ##

弱引用和软引用还是比较类似的，只有一点不同**软引用是内存不足时候起效果，弱引用对象是GC线程运行时候，发现弱引用对象就会起效果。**

构造方法和弱引用类似 略，

直接上实例：

//生成引用队列
    ReferenceQueue<String> referenceQueue = new ReferenceQueue<>();
    String strong = "Strong";
    WeakReference<String> weakReference = new WeakReference<>(strong,referenceQueue);
    //入列
    weakReference.enqueue();
    System.out.println("队列里面是否有数据 "+referenceQueue.poll().get());
    ///清除该引用对象，就是 弱引用对象 不再持有 引用对象的引用
    weakReference.clear();
    System.out.println("弱引用对象 是否持有 引用对象 " + weakReference.get());
    System.out.println("strong 是否被回收 " + strong);

运行结果：  
![在这里插入图片描述][20190309220505107.]

和软引用对象类似，这里，我们还可以发现 **弱引用对象不持有引用对象的引用，也并一定说明，引用对象被回收了，因为还有强引用。**

## 虚引用 PhantomReference ##

虚引用 要注意的一个地方是 **get()方法 总是返回null。**  
**虚引用对象，更多的通知我们，referent对象传入时候的内存空间，被回收了。**

ReferenceQueue<String> phantomQueue = new ReferenceQueue<>();
    PhantomReference<String> stringPhantomReference = new PhantomReference<>("456", phantomQueue);
    //入列
    stringPhantomReference.enqueue();
    System.out.println(phantomQueue.poll()==null);

运行结果：  
![在这里插入图片描述][20190309221735843.]  
当“456”被回收后，phantomQueue队列就会虚引用对象 ，这样我们就知道“456”被回收啦。

## 总结 ##

首先，在我的上面的例子中，都是用字符串做referent引用对象的。其实，**如果深究到底的话，字符串并未被回收。这涉及到java String的特性 。即在jvm堆中会有 字符串常量池**。所有的String都会被放在那里。 当然这个不影响我们弱引用关系。**这些都是jvm更深一层来维护的。在上面具体表现上来说 String 和普通对象 并没有什么区别。**

最后总结一下，我对强引用，软引用，弱引用，虚引用的理解总结。

**强引用：**  
**强引用就是jvm宁愿报异常，也不会回收内存空间。**

**软引用和弱引用**  
就是在构造软引用对象时刻，**传入的referent对应的内存空间之间 ，加上一个特殊的引用**。 根据引用的不同。表现也不同。  
软引用： **内存不足的情况下，如果内存空间，仅有软引用，那么这个内存空间会被回收。**  
弱引用：**GC线程运行，发现内存空间，仅有弱引用，那么这个内存空间会被回收**。

**虚引用**  
**对内存空间 ，注册一个通知，当内存空间被回收了。通过虚引用的队列就可以知道。**

还有 **ReferenceQueue添加的都是弱引用 ，软引用，虚引用对象本身**。

note：  
**软引用，弱引用，虚引用都是在内存空间上面再加一个引用，只不过这个引用在符合条件后，不会阻止内存空间被回收**

总感觉写的不太好，等以后 再有新的认识，修改吧。如果 有错误，欢迎评论指出。

[java]: https://blog.csdn.net/a1064072510/article/details/83148538
[20190309215000775.]: /images/20220310/395fc600c737435a856ac9747bd9f04f.png
[20190309220505107.]: /images/20220310/d451412ea07c4bc2b6bf67f2d0917582.png
[20190309221735843.]: /images/20220310/59d8071ba75744dc88aa8ca5acf2cb9e.png