如果不停的创建对象，总有一个时刻会占满内存空间，为了避免这种现象的发生，jvm会主动的将未使用的内存空间进行回收（GC）。java中基本数据类型分为两大类：1、基本数据类型；2、引用数据类型。JDK1.2中又将引用数据类型分为4类： 强引用、软引用、弱引用、虚引用，引入的目的是为了更好的管理内存空间。
](https://i-blog.csdnimg.cn/direct/e6ca1ab94e1c40d78f1e149e7af67313.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 MBSoftReference<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 MBSoftReference<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;}
//构造方法2public 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 MBSoftReference<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(); //强引用没有被取消 发生gcSystem.out.println(r1);System.out.println(weakReference.get());//-------------------------------------------------------------------r1 = null; //取消强引用 发生gcSystem.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