JVM中的四种引用（(强引用、软引用、弱引用、虚引用)）

前言

Java中的引用一共有四种，它们分别是强引用、软引用、弱引用和虚引用，下面我们来分别介绍。

一、强引用（默认支持模式）

强引用就是我们平常用的类似于“Object obj = new Object()”的引用，只要obj的生命周期没结束，或者没有显示地把obj指向为null，那么JVM永远不会回收的这种对象。

二、软引用

软引用，软引用在java内存充足的情况下，GC是不会回收的，而一旦内存非常高吃紧，面临要创建大量对象时，GC才会回收的一类引用。软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收！

java中通过SoftReference类来实现

 1 package com.dongguo.threadlocal;
 2 
 3 import java.lang.ref.SoftReference;
 4 import java.util.concurrent.TimeUnit;
 5 
 6 /**
 7  * @author Dongguo
 8  * @date 2021/9/8 0008-11:54
 9  * @description:
10  */
11 class MyObject {
12     //一般开发中不用调用这个方法
13     @Override
14     protected void finalize() throws Throwable {
15         System.out.println(Thread.currentThread().getName() + "\t" + "---finalize method invoked....");
16     }
17 }
18 
19 public class ReferenceDemo {
20     public static void main(String[] args) {
21 
22         SoftReference softReference = new SoftReference(new MyObject());
23 
24         System.out.println("-----gc before内存够用:: " + softReference.get());
25         
26         System.gc();//手动GC
27         try {
28             TimeUnit.SECONDS.sleep(1);
29         } catch (InterruptedException e) {
30             e.printStackTrace();
31         }
32         System.out.println("-----gc after内存够用:: " + softReference.get());
33     }
34 }
35 运行结果
36 -----gc before内存够用:: com.dongguo.threadlocal.MyObject@4b67cf4d
37 -----gc after内存够用:: com.dongguo.threadlocal.MyObject@4b67cf4d

模拟内存不够用的情况

 1 package com.dongguo.threadlocal;
 2 
 3 import java.lang.ref.SoftReference;
 4 import java.util.concurrent.TimeUnit;
 5 
 6 /**
 7  * @author Dongguo
 8  * @date 2021/9/8 0008-11:54
 9  * @description:
10  */
11 class MyObject {
12     //一般开发中不用调用这个方法
13     @Override
14     protected void finalize() throws Throwable {
15         System.out.println(Thread.currentThread().getName() + "\t" + "---finalize method invoked....");
16     }
17 }
18 
19 public class ReferenceDemo {
20     public static void main(String[] args) {
21         //当我们内存不够用的时候，soft会被回收的情况，设置我们的内存大小：-Xms10m -Xmx10m
22         SoftReference softReference = new SoftReference(new MyObject());
23 
24         System.out.println("-----gc before内存够用:: " + softReference.get());
25 
26 //        System.gc();//手动GC
27 //        try {
28 //            TimeUnit.SECONDS.sleep(1);
29 //        } catch (InterruptedException e) {
30 //            e.printStackTrace();
31 //        }
32 //        System.out.println("-----gc after内存够用:: " + softReference.get());
33         try
34         {
35             byte[] bytes = new byte[9 * 1024 * 1024];
36         }catch (Exception e){
37             e.printStackTrace();
38         }finally {
39             System.out.println("-----gc after内存不够: "+softReference.get());
40         }
41     }
42 }
43 运行结果
44 -----gc before内存够用:: com.dongguo.threadlocal.MyObject@4b67cf4d
45 -----gc after内存不够: null
46 Finalizer    ---finalize method invoked....
47 Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
48     at com.dongguo.threadlocal.ReferenceDemo.main(ReferenceDemo.java:35)

应用场景如下：

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

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

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

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

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

三、弱引用

弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短，

对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM的内存空间是否充足，都会回收该对象占用的内存。

 1 package com.dongguo.threadlocal;
 2 
 3 import java.lang.ref.SoftReference;
 4 import java.lang.ref.WeakReference;
 5 import java.util.concurrent.TimeUnit;
 6 
 7 /**
 8  * @author Dongguo
 9  * @date 2021/9/8 0008-11:54
10  * @description:
11  */
12 class MyObject {
13     //一般开发中不用调用这个方法
14     @Override
15     protected void finalize() throws Throwable {
16         System.out.println(Thread.currentThread().getName() + "\t" + "---finalize method invoked....");
17     }
18 }
19 
20 public class ReferenceDemo {
21     public static void main(String[] args) {
22 
23         WeakReference weakReference = new WeakReference(new MyObject());
24 
25         System.out.println("-----gc before内存够用:: " + weakReference.get());
26 
27         System.gc();//手动GC
28         try {
29             TimeUnit.SECONDS.sleep(1);
30         } catch (InterruptedException e) {
31             e.printStackTrace();
32         }
33         System.out.println("-----gc after内存够用:: " + weakReference.get());
34     }
35 }
36 运行结果
37 -----gc before内存够用:: com.dongguo.threadlocal.MyObject@4b67cf4d
38 Finalizer    ---finalize method invoked....
39 -----gc after内存够用:: null

四、虚引用

虚引用需要java.lang.ref.PhantomReference类来实现。

顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，
它不能单独使用也不能通过它访问对象，虚引用必须和引用队列 (ReferenceQueue)联合使用。

虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被 finalize以后，做某些事情的机制。 PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。

其意义在于：说明一个对象已经进入finalization阶段，可以被gc回收，用来实现比finalization机制更灵活的回收操作。

换句话说，设置虚引用关联的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理。

构造方法

引用队列

虚引用被回收前需要被引用队列保存下。

模拟触发GC前后虚引用的情况

 1 package com.dongguo.threadlocal;
 2 
 3 import java.lang.ref.*;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 import java.util.concurrent.TimeUnit;
 7 
 8 /**
 9  * @author Dongguo
10  * @date 2021/9/8 0008-11:54
11  * @description:
12  */
13 class MyObject {
14     //一般开发中不用调用这个方法
15     @Override
16     protected void finalize() throws Throwable {
17         System.out.println(Thread.currentThread().getName() + "\t" + "---finalize method invoked....");
18     }
19 }
20 
21 public class ReferenceDemo {
22     public static void main(String[] args) {
23         //当我们内存不够用的时候，soft会被回收的情况，设置我们的内存大小：-Xms10m -Xmx10m
24         ReferenceQueue referenceQueue =new ReferenceQueue();
25         PhantomReference<MyObject> phantomReference = new PhantomReference<>(new MyObject(),referenceQueue);
26 
27         //PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。
28         System.out.println("-----gc before内存够用:: " + phantomReference.get());
29 
30         List<byte[]> list = new ArrayList<>();
31 
32         new Thread(() -> {
33             while (true)
34             {
35                 //每过500毫秒创建一个1M的byte数组
36                 list.add(new byte[1 * 1024 * 1024]);
37                 try { TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
38                 System.out.println(phantomReference.get());
39             }
40         },"t1").start();
41 
42         new Thread(() -> {
43             while (true)
44             {
45                 //通过referenceQueue查看虚对象被回收的情况
46                 Reference<? extends MyObject> reference = referenceQueue.poll();
47                 //当内存不足前触发GC，phantomReference<MyObject>进入referenceQueue ，referenceQueue中有虚引用对象
48                 if (reference != null) {
49                     System.out.println("***********有虚对象加入队列了");
50                 }
51             }
52         },"t2").start();
53     }
54 }
55 运行结果
56 -----gc before内存够用:: null
57 Finalizer    ---finalize method invoked....
58 null
59 null
60 null
61 null
62 null
63 null
64 null
65 Exception in thread "t1" java.lang.OutOfMemoryError: Java heap space
66     at com.dongguo.threadlocal.ReferenceDemo.lambda$main$0(ReferenceDemo.java:36)
67     at com.dongguo.threadlocal.ReferenceDemo$$Lambda$1/1989780873.run(Unknown Source)
68     at java.lang.Thread.run(Thread.java:748)
69 ***********有虚对象加入队列了