一文带你搞懂Java的四大引用：强引用，软引用，弱引用以及虚引用

天选的爪哇

已于 2022-10-19 20:11:26 修改

阅读量823

点赞数 3

文章标签： java jvm

于 2022-10-16 20:00:34 首次发布

本文链接：https://blog.csdn.net/xjx666666/article/details/127352204

版权

Java中的引用

强引用Reference

Reference类以及继承派生的类。
当内存不足，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会对该对象进行回收，死都不收。
这样定义的默认就是强应用Object obj1 = new Object();
强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。在Java中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，也就是说它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一。
对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为 null一般认为就是可以被垃圾收集的了(当然具体回收时机还是要看垃圾收集策略)。

强引用代码演示

public class StrongReferenceDemo {
        public static void main(String[] args) {
			// 这样定义的默认就是强应用
            Object obj1 = new Object();
			// 使用第二个引用，指向刚刚创建的 Object 对象
            Object obj2 = obj1;
			// 置空
            obj1 = null;
			// 垃圾回收
            System.gc();
            System.out.println(obj1);
            System.out.println(obj2);
        }
}

输出结果如下：

null
java.lang.Object@14ae5a5

输出结果我们能够发现，即使 obj1 被设置成了 null，然后调用 gc 进行回收，但是也没有回收实例出来的对象，obj2还是能够指向该地址，也就是说垃圾回收器，并没有将该对象进行垃圾回收。

软引用SoftReference

软引用是一种相对强引用弱化了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。

对于只有软引用的对象来说：

当系统内存充足时它不会被回收
只有当系统内存不足时它才会被回收

软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收!

软引用代码演示

下面的代码我们写了两个方法，一个是内存够用的时候，一个是内存不够用的时候。

public class SoftReferenceDemo {
    /**
     * 内存够用的时候
     * -XX:+PrintGCDetails
     */
    public static void softRefMemoryEnough() {
        // 创建一个强应用
        Object o1 = new Object();
        // 创建一个软引用
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1);
        System.out.println(softReference.get());
        o1 = null;
        // 手动GC
        System.gc();
        System.out.println(o1);
        System.out.println(softReference.get());
    }
    /**
     * JVM配置，故意产生大对象并配置小的内存，让它的内存不够用了导致OOM，看软引用的回收情况
     * -Xms5m -Xmx5m -XX:+PrintGCDetails
     */
    public static void softRefMemoryNoEnough() {
        System.out.println("========================");
        // 创建一个强应用
        Object o1 = new Object();
        // 创建一个软引用
        SoftReference<Object> softReference = new SoftReference<>(o1);
        System.out.println(o1);
        System.out.println(softReference.get());
        o1 = null;
        // 模拟OOM自动GC
        try {
            // 创建30M的大对象
            byte[] bytes = new byte[30 * 1024 * 1024];
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(o1);
            System.out.println(softReference.get());
        }
    }
    
    public static void main(String[] args) {
        softRefMemoryEnough();
        //softRefMemoryNoEnough();
    }
}

内存充足输出结果在下面。我们会发现内存足够时首先输出的是o1和软引用的 softReference，我们都能够看到值。然后我们把 o1 设置为 null，执行手动 GC 后，我们发现 softReference 的值还存在，说明内存充足的时候，软引用的对象不会被回收

java.lang.Object@15db9742
java.lang.Object@15db9742
[GC (System.gc()) [PSYoungGen: 2621K->728K(76288K)] 2621K->736K(251392K), 0.0011732 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 728K->0K(76288K)] [ParOldGen: 8K->519K(175104K)] 736K->519K(251392K), [Metaspace: 2646K->2646K(1056768K)], 0.0048782 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
null
java.lang.Object@15db9742

内存不充足时输出结果在下面。我们发现o1和softReference都被回收了，因此说明，软引用关联的对象在内存不足的时候，会
自动回收。且回收后内存依然不足的话，还是会抛异常。

java.lang.Object@15db9742
java.lang.Object@15db9742
[GC (Allocation Failure) [PSYoungGen: ......
null
null
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at com.lun.jvm.SoftReferenceDemo.softRefMemoryNotEnough(SoftReferenceDemo.java:44)
	at com.lun.jvm.SoftReferenceDemo.main(SoftReferenceDemo.java:58)
Heap
 PSYoungGen......

软引用的使用场景

场景：假如有一个应用需要读取大量的本地图片

如果每次读取图片都从硬盘读取则会严重影响性能
如果一次性全部加载到内存中，又可能造成内存溢出。

此时使用软引用可以解决这个问题。

设计思路：使用HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占的空间，从而有效地避免了OOM的问题

Map<String, SoftReference<String>> imageCache = new HashMap<String, SoftReference<Bitmap>>();

弱引用WeakReference

弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短。对于只有弱引用的对象来说，只要垃圾回收机制一运行不管JVM的内存空间是否足够，都会回收该对象占用的内存。也就是说不管内存是否够，只要有 GC 操作就会进行对弱引用进行回收。

弱引用代码演示

这里我觉得老师的代码是有问题的，因为他在弱引用之前创建了一个强引用，所以只要强引用不为空，这里弱引用仍然可以取出对象。所以我把代码改为下面的代码了。

import java.lang.ref.WeakReference;

public class WeakReferenceDemo {
    public static void main(String[] args) {
        WeakReference<Object> weakReference = new WeakReference<>(new Object());
        System.out.println(weakReference.get());
        System.gc();
        System.out.println(weakReference.get());
    }
}

输出结果：

java.lang.Object@1b6d3586
null

弱引用的使用场景

**WeakHashMap：**WeakHashMap 和 HashMap 类似，只不过它的 Key 是使用了弱引用的，也就是说，当执行 GC 的时候，HashMap中的key会进行回收。比如一些常常和底层打交道的，如mybatis，底层就应用到了 WeakHashMap。

这里我阅读了下源码，我们都知道HashMap底层真正存储键值对的是Node类的实例，HashMap则把存储键值对的这一个个Node实例存储起来（Node数组的形式）。但是WeakHashMap底层存储键值对的却并不是Node对象。而是自定义了私有的静态内部类Entry，源码如下（只看底层数据结构，没有粘贴其方法）

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
    V value;
    final int hash;
    Entry<K,V> next;
}

其实它与HashMap的Node节点很像，因为Node类本身也实现了Map.Entry<K,V>这个接口，但是这个Entry关键的是又继承了WeakReference，这也是它起作用的最关键的一点。可以这么理解，WeakHashMap中存储的这一个个Entry就是一个个弱引用。这个Entry弱引用关联的就是我们向WeakHashMap中放的key。

这里因为篇幅受限我们不过多深入，我把下面第二个例子中使用WeakHashMap为什么能实现回收的原因说一下：

WeakHashMap中创建了一个Object常量，这个常量就是用来标识一个键值对的key是否为空的，如果为空就把这个常量赋给这个key，那么每当想要取值时都会进行一次判断如果等于这个常量就会返回null，那么自然而然这个对象就会被回收了。

下面我们使用例子来测试一下。我们使用了两个方法，第一个一个是普通的 HashMap 方法
我们输入一个 Key-Value 键值对，然后让它的 key 置空，然后再查看结果

private static void myHashMap() {
	Map<Integer, String> map = new HashMap<>();
	Integer key = new Integer(1);
	String value = "HashMap";
	map.put(key, value);
	System.out.println(map);
	key = null;
}

最后输出结果为：

{1=HashMap}
{1=HashMap}

第二个是使用了 WeakHashMap

private static void myWeakHashMap() {
        Map<Integer, String> map = new WeakHashMap<>();
        Integer key = new Integer(1);
        String value = "WeakHashMap";
        map.put(key, value);
        System.out.println(map);
        key = null;
        System.gc();
        System.out.println(map);
}

输出结果如下

{1=WeakHashMap}
{}

从这里我们看到，对于普通的 HashMap 来说，key 置空并不会影响HashMap的键值对，因为这个属于强引用，不会被垃圾回收。但是 WeakHashMap，在进行 GC 操作后，弱引用的就会被回收。

虚引用PhantomReference

概念

虚引用又称为幽灵引用，需要java.lang.ref.PhantomReference类来实现。虚引用顾名思义就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队列(ReferenceQueue)联合使用。虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被finalize以后，做某些事情的机制，这也是虚引用存在的意义。

PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。其意义在于说明一个对象已经进入finalization阶段，可以被gc回收，用来实现比fihalization机制更灵活的回收操作。换句话说，设置虚引用关联的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理。Java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动这相当于是一种通知机制。当关联的引用队列中有数据的时候，意味着引用指向的堆内存中的对象被回收。通过这种方式，JVW允许我们在对象被销毁后，做一些我们自己想做的事情。

虚引用代码演示

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceDemo {
	public static void main(String[] args) throws InterruptedException {
		Object o1 = new Object();
		ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
		PhantomReference<Object> phantomReference = new PhantomReference<>(o1, referenceQueue);
		System.out.println(o1);
		System.out.println(phantomReference.get());
		System.out.println(referenceQueue.poll());
		System.out.println("==================");
		o1 = null;
		System.gc();
		Thread.sleep(500) ;
		System.out.println(o1);
		System.out.println(phantomReference.get());
		System.out.println(referenceQueue.poll());
	}
}

输出结果：

java.lang.Object@15db9742
null
null
==================
null
null
java.lang.ref.PhantomReference@6d06d69c

ReferenceQueue引用队列

软引用，弱引用，虚引用在回收之前，可以在引用队列保存一下。只需要在初始化软引用，弱引用或者虚引用的时候，传入一个引用队列即可。这样就可以保证在进行 GC 回收之前被送至引用队列中。但ReferenceQueue是用来配合引用工作的，没有ReferenceQueue其他引用一样可以运行（包括虚引用，但虚引用如果不配合引用队列那么它就没任何价值了）。

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.concurrent.TimeUnit;

public class ReferenceQueueDemo {
    public static void main(String[] args) {
        Object o1 = new Object();
        // 创建引用队列
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        // 创建一个弱引用
        WeakReference<Object> weakReference = new WeakReference<>(o1, referenceQueue);
        System.out.println(o1);
        System.out.println(weakReference.get());
        // 取队列中的内容
        System.out.println(referenceQueue.poll());
        System.out.println("==================");
        o1 = null;
        System.gc();
        System.out.println("执行GC操作");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(o1);
        System.out.println(weakReference.get());
        // 取队列中的内容
        System.out.println(referenceQueue.poll());
    }
}

输出结果：

java.lang.Object@15db9742
java.lang.Object@15db9742
null
==================
执行GC操作
null
null
java.lang.ref.WeakReference@6d06d69c

GCRoots和四大引用小总结

红色部分在垃圾回收之外，也就是强引用的
蓝色部分：属于软引用，在内存不够的时候，才回收
虚引用和弱引用：每次垃圾回收的时候，都会被干掉，但是它在干掉之前可能还会存在引用队列中，然后我们可以通过引用队列进行一些通知机制。

感谢耐心看到这里的同学，觉得文章对您有帮助的话希望同学们不要吝啬您手中的赞，动动您智慧的小手，您的认可就是我创作的动力！
之后还会勤更自己的学习笔记，感兴趣的朋友点点关注哦。

天选的爪哇

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
2
评论
一文带你搞懂Java的四大引用：强引用，软引用，弱引用以及虚引用

红色部分在垃圾回收之外，也就是强引用的蓝色部分：属于软引用，在内存不够的时候，才回收虚引用和弱引用：每次垃圾回收的时候，都会被干掉，但是它在干掉之前可能还会存在引用队列中，然后我们可以通过引用队列进行一些通知机制。
复制链接

扫一扫