吊打面试官，聊聊：强引用、软引用、弱引用、虚引用？重点是各自的使用场景？（史上最全）

不念不忘少年蓝@ 2024-03-31 17:02 133阅读 0赞

文章很长，而且持续更新，建议收藏起来，慢慢读！[**疯狂创客圈总目录 博客园版**][Link 1] 为您奉上珍贵的学习资源 ：

免费赠送 :[**《尼恩Java面试宝典》**][Java] 持续更新+ 史上最全 + 面试必备 2000页+ 面试必备 + 大厂必备 +涨薪必备  
免费赠送 经典图书:[**《Java高并发核心编程（卷1）加强版》**][Java_1] 面试必备 + 大厂必备 +涨薪必备 加尼恩免费领  
免费赠送 经典图书:[**《Java高并发核心编程（卷2）加强版》** ][Java_1] 面试必备 + 大厂必备 +涨薪必备 加尼恩免费领  
免费赠送 经典图书:[**《Java高并发核心编程（卷3）加强版》**][Java_1] 面试必备 + 大厂必备 +涨薪必备 加尼恩免费领  
免费赠送 经典图书:[《**尼恩Java面试宝典 最新版**》 ][Java] 面试必备 + 大厂必备 +涨薪必备 加尼恩免费领  
免费赠送 资源宝库： **Java 必备 百度网盘资源大合集 价值**>10000元 加尼恩领取

--------------------

**尼恩提示：**

四大引用 中的三大，大家平时用的比较少，更多在**中间件源码、JDK源码**当中使用。

所以，这道题，**考验的是大家对 中间件源码、JDK源码的掌握和熟悉程度**。

*  软引用 和 弱引用， 在当今最火缓存caffeine源码中使用了。
 *  弱引用， 在ThreadLocalMap源码中使用了。
 *  虚引用 ，在 JDK 的 堆外内存 源码当中，使用了。

**具体答案：**

Java4种引用的级别由高到低依次为：强引用 > 软引用 > 弱引用 > 虚引用

<table> 
 <thead> 
  <tr> 
   <th>引用类型</th> 
   <th>被垃圾回收时间</th> 
   <th>用途</th> 
   <th>生存时间</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>强引用</td> 
   <td>从来不会</td> 
   <td>对象的一般状态</td> 
   <td>JVM停止运行时终止</td> 
  </tr> 
  <tr> 
   <td>软引用</td> 
   <td>在内存不足时</td> 
   <td>对象缓存</td> 
   <td>内存不足时终止</td> 
  </tr> 
  <tr> 
   <td>弱引用</td> 
   <td>在垃圾回收时</td> 
   <td>对象缓存</td> 
   <td>gc运行后终止</td> 
  </tr> 
  <tr> 
   <td>虚引用</td> 
   <td>在垃圾回收时</td> 
   <td>堆外内存</td> 
   <td>利用虚引用的通知特性来管理的堆外内存</td> 
  </tr> 
 </tbody> 
</table>

### 1、强引用 ###

以前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。

当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使jvm进程异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。  
如：

String str = "abc";
     List<String> list = new Arraylist<String>();
     list.add(str)
      在list集合里的数据不会释放，即使内存不足也不会

> 在ArrayList类中定义了一个私有的变量elementData数组，在调用方法清空数组时可以看到为每个数组内容赋值为null。
> 
> 使用如clear()方法中释放内存的方法对数组中存放的引用类型特别适用，这样就可以及时释放内存。

### 2、软引用（SoftReference） ###

特色：

*  内存溢出之前进行回收，GC时内存不足时回收，如果内存足够就不回收
 *  使用场景：在内存足够的情况下进行缓存，提升速度，内存不足时JVM自动回收

如果一个对象只具有软引用，那就类似于可有可物的生活用品。

如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。

只要垃圾回收器没有回收它，该对象就可以被程序使用。

软引用可用来实现内存敏感的高速缓存。

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。

如：

public class Test {
          
    
        public static void main(String[] args){
          
            System.out.println("开始");            
            A a = new A();            
            SoftReference<A> sr = new SoftReference<A>(a);  
            a = null;  
            if(sr!=null){
          
                a = sr.get();  
            }  
            else{
          
                a = new A();  
                sr = new SoftReference<A>(a);  
            }            
            System.out.println("结束");     
        }       
    
    }  
    
    class A{
          
        int[] a ;  
        public A(){
          
            a = new int[100000000];  
        }  
    }

当内存足够大时，可以把数组存入软引用，取数据时就可从内存里取数据，提高运行效率

### 3．弱引用（WeakReference） ###

特色：

*  每次GC时回收，无论内存是否足够
 *  使用场景：a. ThreadLocalMap防止内存泄漏 b. 监控对象是否将要被回收

如果一个对象只具有弱引用，那就类似于可有可物的生活用品。

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。

在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。

弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。  
如：

Object c = new Car(); //只要c还指向car object, car object就不会被回收
    WeakReference<Car> weakCar = new WeakReference(Car);

当要获得weak reference引用的object时, 首先需要判断它是否已经被回收:

weakCar.get();

如果此方法为空, 那么说明weakCar指向的对象已经被回收了.

> 如果这个对象是偶尔的使用，并且希望在使用时随时就能获取到，但又不想影响此对象的垃圾收集，那么你应该用 Weak Reference 来记住此对象。

当你想引用一个对象，但是这个对象有自己的生命周期，你不想介入这个对象的生命周期，这时候你就是用弱引用。

> 这个引用不会在对象的垃圾回收判断中产生任何附加的影响。

### 4．虚引用（PhantomReference） ###

“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。

如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。

虚引用主要用来跟踪对象被垃圾回收的活动。

虚引用与软引用和弱引用的一个区别在于：**虚引用必须和引用队列（ReferenceQueue）联合使用**。

当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。

程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

特别注意，

在实际程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，

这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。

#### 虚引用（PhantomReference）的使用场景： ####

虚引用（PhantomReference）的使用场景，主要在 byteBuffer回收堆外内存（直接内存）的流程中。

两种使用堆外内存的方法：

*  一种是依靠unsafe对象
 *  另一种是NIO中的ByteBuffer，

直接使用unsafe对象来操作内存，对于一般开发者来说难度很大，并且如果内存管理不当，容易造成内存泄漏。所以不推荐。所以， 推荐使用的是ByteBuffer来操作堆外内存。

在上面的ByteBuffer如何 触发堆外内存的回收呢？是通过 虚引用的 关联线程是实现的。

*  当byteBuffer被回收后，在进行GC垃圾回收的时候，发现`虚引用对象Cleaner`是`PhantomReference`类型的对象，并且`被该对象引用的对象（ByteBuffer对象）`已经被回收了
 *  那么他就将将这个对象放入到（`ReferenceQueue`）队列中
 *  JVM中会有一个优先级很低的线程会去将该队列中的`虚引用对象`取出来，然后回调`clean（）`方法
 *  在`clean（）`方法里做的工作其实就是根据`内存地址`去释放这块内存（内部还是通过unsafe对象去释放的内存）。  
    ![7d71e2f4859240b9a5db772c0d6a0e82.png][]

可以看到被虚引用引用的对象其实就是这个byteBuffer对象。

所以说需要重点关注的是这个byteBuffer对象被回收了以后会触发什么操作。

![93a200bcd672434e9edc982a3a97b88a.png][]

### 推荐阅读： ###

*  《[尼恩Java面试宝典][Java 1]》
 *  《[Springcloud gateway 底层原理、核心实战 (史上最全)][Springcloud gateway _]》
 *  《[sentinel （史上最全）][sentinel]》
 *  《[分库分表 Sharding-JDBC 底层原理、核心实战（史上最全）][Sharding-JDBC]》
 *  《[分布式事务 （秒懂）][Link 2]》
 *  《[缓存之王：Caffeine 源码、架构、原理（史上最全，10W字 超级长文）][Caffeine _10W_]》
 *  《[缓存之王：Caffeine 的使用（史上最全）][Caffeine]》
 *  《[Java Agent 探针、字节码增强 ByteBuddy（史上最全）][Java Agent _ ByteBuddy]》
 *  《[Docker原理（图解+秒懂+史上最全）][Docker]》
 *  《[Redis分布式锁（图解 - 秒懂 - 史上最全）][Redis_ - _ -]》
 *  《[Zookeeper 分布式锁 - 图解 - 秒懂][Zookeeper _ - _ -]》
 *  《[Zookeeper Curator 事件监听 - 10分钟看懂][Zookeeper Curator _ - 10]》
 *  《[Netty 粘包 拆包 | 史上最全解读][Netty _ _ _]》
 *  《[Netty 100万级高并发服务器配置][Netty 100]》
 *  《[Springcloud 高并发 配置 （一文全懂）][Springcloud _ _]》

[Link 1]: https://www.cnblogs.com/crazymakercircle/p/9904544.html
[Java]: https://www.cnblogs.com/crazymakercircle/p/13917138.html
[Java_1]: https://www.cnblogs.com/crazymakercircle/p/14493539.html
[7d71e2f4859240b9a5db772c0d6a0e82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ab142b38800346afa8b0d9b64e34503f.png
[93a200bcd672434e9edc982a3a97b88a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f21eae1204454ee9a43ed6cb46f622ea.png
[Java 1]: https://blog.csdn.net/crazymakercircle/article/details/124790425
[Springcloud gateway _]: https://blog.csdn.net/crazymakercircle/article/details/125057567
[sentinel]: https://blog.csdn.net/crazymakercircle/article/details/125059491
[Sharding-JDBC]: https://blog.csdn.net/crazymakercircle/article/details/123420859
[Link 2]: https://blog.csdn.net/crazymakercircle/article/details/109459593
[Caffeine _10W_]: https://blog.csdn.net/crazymakercircle/article/details/128123114
[Caffeine]: https://blog.csdn.net/crazymakercircle/article/details/113751575
[Java Agent _ ByteBuddy]: https://blog.csdn.net/crazymakercircle/article/details/126579528
[Docker]: https://blog.csdn.net/crazymakercircle/article/details/120747767
[Redis_ - _ -]: https://blog.csdn.net/crazymakercircle/article/details/116425814
[Zookeeper _ - _ -]: https://blog.csdn.net/crazymakercircle/article/details/85956246
[Zookeeper Curator _ - 10]: https://blog.csdn.net/crazymakercircle/article/details/85922561
[Netty _ _ _]: https://blog.csdn.net/crazymakercircle/article/details/83957259
[Netty 100]: https://blog.csdn.net/crazymakercircle/article/details/83758107
[Springcloud _ _]: https://blog.csdn.net/crazymakercircle/article/details/102557988