强引用、软引用、弱引用、虚引用

日拱一卒ZHD

于 2024-09-14 14:57:45 发布

阅读量676

点赞数 21

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/qq_41163858/article/details/142256381

版权

java基础专栏收录该内容

18 篇文章 0 订阅

订阅专栏

如果不停的创建对象，总有一个时刻会占满内存空间，为了避免这种现象的发生，jvm会主动的将未使用的内存空间进行回收（GC）。java中基本数据类型分为两大类：1、基本数据类型；2、引用数据类型。JDK1.2中又将引用数据类型分为4类：强引用、软引用、弱引用、虚引用，引入的目的是为了更好的管理内存空间。
在这里插入图片描述入图片描述](https://i-blog.csdnimg.cn/direct/98269c44aa78437aa71fc2f694444be9.png)
其中，FinalReference 被设计出来的目的是给 JVM 用的,这里暂时不学习。下面从强到弱学习四种引用类型。

1、强引用

 Reference_Learn r1 = new Reference_Learn();
 Reference_Learn r2 = r1;   
 System.out.println(r1);

在这里插入图片描述
上述的r1、r2就是强引用类型。
强引用类型：一般把一个对象赋给一个引用变量，这个引用变量就是强引用。
a.当内存不足，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会对该对象进行回收，死都不收。
b.强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。
当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到，JVM也不会回收，因此强引用是造成Java内存泄漏的主要原因之一。
c.对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为null，一般认为就是可以被垃圾收集的了〈当然具体回收时机还是要看垃圾收集策略）。

2、软引用

a.软引用是用来描述一些还有用但并非必需的对象，需要用java.lang.ref.SoftReference类来实现。

b.对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK1.2之后，提供了Soft Reference类来实现软引用。

c.软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收！
概念比较抽象，看具体案例：
前置条件，设置jvm内存大小为20M;
在这里插入图片描述
-Xms20m -Xmx20m

  public static void softReference1() {
        //查看jvm参数是否配置成功！
        long totalMemory = Runtime.getRuntime().totalMemory(); // 当前堆内存总大小
        long maxMemory = Runtime.getRuntime().maxMemory();     // 最大堆内存大小
        long freeMemory = Runtime.getRuntime().freeMemory();   // 当前可用堆内存
        // 输出信息
        System.out.println("总堆内存: " + (totalMemory >> 20) + " MB");
        System.out.println("最大堆内存: " + (maxMemory >> 20) + " MB");
        System.out.println("可用堆内存: " + (freeMemory >> 20) + " MB");
        // 创建一个大对象
        byte[] largeObject = new byte[10 * 1024 * 1024]; // 10 MB
        SoftReference<byte[]> softReference = new SoftReference<>(largeObject);

        long freeMemory1 = Runtime.getRuntime().freeMemory();   // 当前可用堆内存
        System.out.println("可用堆内存: " + (freeMemory1 >> 20) + " MB");
        int f = (int) (freeMemory1 >> 20) - 1;
        // 释放强引用
        largeObject = null;

        System.out.println("Before GC: " + (softReference.get() != null ? "存活" : "被回收"));
        // 强制垃圾回收
        System.gc();
        try {
            Thread.sleep(1000); // 睡眠一秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 再次检查软引用
        System.out.println("After GC: " + (softReference.get() != null ? "存活" : "被回收"));

        // 再次占用大量内存 
        byte[] anotherLargeObject = new byte[f * 1024 * 1024];
        System.out.println("再次分配大对象之后:");

        // 再次检查软引用
        System.out.println("After GC: " + (softReference.get() != null ? "存活" : "被回收"));
    }

结果：

总堆内存: 19 MB
最大堆内存: 19 MB
可用堆内存: 17 MB
可用堆内存: 7 MB
Before GC: 存活
After GC: 存活
再次分配大对象之后:
After GC: 被回收

详细解释：

  byte[] largeObject = new byte[10 * 1024 * 1024]; // 10 MB
  SoftReference<byte[]> softReference = new SoftReference<>(largeObject);

在这里插入图片描述
首先创建了一个大数组，变量largeObject指向该内存空间的首地址，new SoftReference<>(largeObject); 创建一个软引用对象，并且这个对象指向数据对象，软引用的构造方法中会使用referent变量指向一个引用（红线）。
构造方法如下：

Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}

 largeObject = null;//将强引用断开

在这里插入图片描述

         System.out.println("Before GC: " + (softReference.get() != null ? "存活" : "被回收"));  
        // 强制垃圾回收
        System.gc();
        try {
            Thread.sleep(1000); // 睡眠一秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 再次检查软引用
        System.out.println("After GC: " + (softReference.get() != null ? "存活" : "被回收"));

Before GC: 存活
After GC: 存活

即使手动调用gc, 内存对象没有被回收，因为内存够用。

        // 再次占用大量内存
        byte[] anotherLargeObject = new byte[f * 1024 * 1024];
        System.out.println("再次分配大对象之后:");

        // 再次检查软引用
        System.out.println("After GC: " + (softReference.get() != null ? "存活" : "被回收"));

再次分配大对象之后:
After GC: 被回收

再次申请一大块内存（大小=可用内存大小-1M）; 会导致弱引用被回收。
在这里插入图片描述

软引用被回收，这个过程是jvm自动进行的，外界如何感知？
SoftReference提供了两个构造方法：

//构造方法1：
    public SoftReference(T referent) {
        super(referent);
        this.timestamp = clock;
    }
//构造方法2
  public SoftReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
        this.timestamp = clock;
    }

构造方法2中，传入一个ReferenceQueue, 如果发生了软引用被回收，会将SoftReference引用加入到该队列中。也即：ReferenceQueue有值，肯定有软引用被回收了。

 public static void softReference2() {
        //查看jvm参数是否配置成功！
        long totalMemory = Runtime.getRuntime().totalMemory(); // 当前堆内存总大小
        long maxMemory = Runtime.getRuntime().maxMemory();     // 最大堆内存大小
        long freeMemory = Runtime.getRuntime().freeMemory();   // 当前可用堆内存

        // 输出信息
        System.out.println("总堆内存: " + (totalMemory >> 20) + " MB");
        System.out.println("最大堆内存: " + (maxMemory >> 20) + " MB");
        System.out.println("可用堆内存: " + (freeMemory >> 20) + " MB");


        ReferenceQueue referenceQueue = new ReferenceQueue();

        // 创建一个大对象
        byte[] largeObject = new byte[10 * 1024 * 1024]; // 10 MB
        SoftReference<byte[]> softReference = new SoftReference<>(largeObject, referenceQueue);

        long freeMemory1 = Runtime.getRuntime().freeMemory();   // 当前可用堆内存
        System.out.println("可用堆内存: " + (freeMemory1 >> 20) + " MB");
        int f = (int) (freeMemory1 >> 20) - 1;
        // 释放强引用
        largeObject = null;

        System.out.println("Before GC: " + (softReference.get() != null ? "存活" : "被回收"));
        // 强制垃圾回收
        System.gc();
        System.out.println("队列中的值: " + referenceQueue.poll());
        try {
            Thread.sleep(1000); // 睡眠一秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 再次检查软引用
        System.out.println("After GC: " + (softReference.get() != null ? "存活" : "被回收"));

        // 再次占用大量内存
        byte[] anotherLargeObject = new byte[f * 1024 * 1024];
        System.out.println("再次分配大对象之后:");

        // 再次检查软引用
        System.out.println("After GC: " + (softReference.get() != null ? "存活" : "被回收"));
        System.out.println("队列中的值: " + referenceQueue.poll());
    }

总堆内存: 19 MB
最大堆内存: 19 MB
可用堆内存: 17 MB
可用堆内存: 7 MB
Before GC: 存活
队列中的值: null
After GC: 存活
再次分配大对象之后:
After GC: 被回收
队列中的值: java.lang.ref.SoftReference@74a14482

3、弱引用

弱引用的使用和软引用类似，只是关键字变成了 WeakReference。

public static void weakReference() {
        Reference_Learn r1 = new Reference_Learn();
        WeakReference<Reference_Learn> weakReference = new WeakReference<>(r1);
        
        System.out.println(r1);
        System.out.println(weakReference.get());
        //-------------------------------------------------------------------
        System.gc();   //强引用没有被取消  发生gc
        System.out.println(r1);
        System.out.println(weakReference.get());
        //-------------------------------------------------------------------
        r1 = null;  //取消强引用  发生gc
        System.gc();
        System.out.println(r1);
        System.out.println(weakReference.get());
    }

com.thread.other.Reference_Learn@74a14482
com.thread.other.Reference_Learn@74a14482

com.thread.other.Reference_Learn@74a14482
com.thread.other.Reference_Learn@74a14482

null
null

注意:强引用没有被取消，发生gc,弱引用不会被回收；
取消强引用，发生gc,弱引用被回收。
在这里插入图片描述

r1 = null;

在这里插入图片描述

        System.gc();
        System.out.println(r1);
        System.out.println(weakReference.get());

在这里插入图片描述
同样的 WeakReference对象提供了两个构造方法，如果需要知道弱引用对象被回收，传递一个队列进入即可，弱引用对象被回收以后，会将弱引用对象加入到队列中。


  public WeakReference(T referent) {
        super(referent);
    }

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

3、虚引用

虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
虚引用也称为“幽灵引用”或者“幻影引用”，它是最弱的一种引用关系。
虚引用需要java.lang.ref.PhantomReference 来实现：

A a = new A();
ReferenceQueue<A> rq = new ReferenceQueue<A>();
PhantomReference<A> prA = new PhantomReference<A>(a, rq);

虚引用主要用来跟踪对象被垃圾回收器回收的活动。
虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

参考链接1
参考链接2

日拱一卒ZHD

关注

21
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录