在JDK 1.2版本之后，Java对引用的概念进行了扩充，将引用分为强引用（Strong Reference）、软引用（Soft Refaerence）、弱引用（Weak Reference）、和虚引用（Phantom Reference）4种，这4种引用强度依次逐渐减弱。

除前引用外，其他3种引用均可在java.lang.ref包种找到

文章内案例所使用的JVM参数：

-Xms10m -Xmx10m -XX:+PrintGCDetails

强引用（Strong Reference）

在Java程序中，最常见的引用类型是强引用（普通系统99%以上都是强引用） ，也就是我们最常见的普通对象引用，也是默认的引用类型。

当在Java语言中使用new操作符创建一个新的对象，并将其赋值给一个变量的时候，这个变量就成为指向该对象的一个强引用。

强引用的对象是可触及的，垃圾收集器就永远不会回收掉被引用的对象。

对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为nul1，就是可以当做垃圾被收集了，当然具体回收时机还是要看垃圾收集策略。

相对的， 软引用、弱引用和虚引用的对象是软可触及、弱可触及和虚可触及的，在一定条件下，都是可以被回收的。所以，强引用是造成Java内存泄漏的主要原因之一。

强引用的案例：

public class StrongReferenceTest {
    public static void main(String[] args) {
        //创建引用对象
        StringBuilder stringBuilder = new StringBuilder("StrongReferenceTest");
        //打印GC前对象状态
        System.out.println("Before GC : " + stringBuilder);
        //进行GC操作，暂停程序，以确保GC正常执行
        System.gc();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打印GC后对象状态
        System.out.println("After GC : " + stringBuilder);
        //进行内存填充，出现OOM错误
        try {
            //进行内存填充
            byte[] bytes = new byte[1024 * 1024 * 7];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            //打印OOM后对象状态
            System.out.println("After OOM : " + stringBuilder);
        }
    }
}	

运行结果

在上面案例中可以看到，无论是GC执行还是OOM时，强引用所引用的实例都没有被回收

强引用的特点：

• 强引用可以直接访问目标对象
• 强引用所引用的对象在任何时候都不会被系统回收
• 强引用可能导致内存泄漏

软引用（Soft Reference）

软引用是用来描述一些还有用，但非必需的对象。只被软引用关联着的对象，

在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。

软引用通常用来实现内存敏感的缓存。比如：高速缓存就有用到软引用。如果还有空闲内存，就可以暂时保留缓存，当内存不足时清理掉，这样就保证了使用缓存的同时，不会耗尽内存。

垃圾回收器在某个时刻决定回收软可达的对象的时候，会清理软引用，并可选地把引用存放到一个引用队列（Reference Queue）。

类似弱引用，只不过Java虚拟机会尽量让软引用的存活时间长一些，迫不得已才清理。

软引用的案例：

public class SoftReferenceTest {
    public static void main(String[] args) {
        //创建引用对象
        SoftReference<StringBuilder> softReference = new SoftReference<StringBuilder>(new StringBuilder("SoftReferenceTest"));
        //打印GC前对象状态
        System.out.println("Before GC : " + softReference.get());
        //进行GC操作，暂停程序，以确保GC正常执行
        System.gc();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打印GC后对象状态
        System.out.println("After GC : " + softReference.get());
        //进行内存填充，出现OOM错误
        try {
            //进行内存填充
            byte[] bytes = new byte[1024 * 1024 * 7];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            //打印OOM后对象状态
            System.out.println("After OOM : " + softReference.get());
        }
    }
}

运行结果

在上面案例中可以看到，当第一次GC执行后，因为内存充足，所以软引用所引用的对象实例并未被回收，而第二次由于内存不足GC后，软引用所引用的对象实例已经被回收

弱引用（Weak Reference）

弱引用也是用来描述那些非必需对象，只被弱引用关联的对象只能生存到下一
次垃圾收集发生为止。在系统GC时，只要发现弱引用，不管系统堆空间使用是否充足，都会回收掉只被弱引用关联的对象。

但是，由于垃圾回收器的线程通常优先级很低，因此，并不一定能很快地发现持有弱引用的对象。在这种情况下，弱引用对象可以存在较长的时间。

弱引用和软引用一样，在构造弱引用时，也可以指定一个引用队列，当弱引用对象被回收时，就会加入指定的引用队列，通过这个队列可以跟踪对象的回收情况。

软引用、弱引用都非常适合来保存那些可有可无的缓存数据。如果这么做，当系统内存不足时，这些缓存数据会被回收，不会导致内存溢出。而当内存资源充足时，这些缓存数据又可以存在相当长的时间，从而起到加速系统的作用。

弱引用的案例：

public class WeakReferenceTest {
    public static void main(String[] args) {
        //创建引用对象
        WeakReference<StringBuilder> weakReference = new WeakReference<StringBuilder>(new StringBuilder("WeakReferenceTest"));
        //打印GC前对象状态
        System.out.println("Before GC : " + weakReference.get());
        //进行GC操作，暂停程序，以确保GC正常执行
        System.gc();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打印GC后对象状态
        System.out.println("After GC : " + weakReference.get());
        //进行内存填充，出现OOM错误
        try {
            //进行内存填充
            byte[] bytes = new byte[1024 * 1024 * 7];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            //打印OOM后对象状态
            System.out.println("After OOM : " + weakReference.get());
        }
    }
}

运行结果：

在上面案例中可以看到，当第一次GC执行后，弱引用所引用的对象实例就已经被回收

虚引用

也称为“幽灵引用”或者“幻影引用”，是所有引用类型中最弱的一个。

一个对象是否有虚引用的存在，完全不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它和没有引用几乎是一样的，随时都可能被垃圾回收器回收。

它不能单独使用，也无法通过虚引用来获取被引用的对象。无法通过虚引用的get（）方法取得对象。

为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程。比如：能在这个对象被收集器回收时收到一个系统通知。

虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象后，将这个虚引用加入引用队列，以通知应用程序对象的回收情况。

由于虚引用可以跟踪对象的回收时间，因此，也可以将一些资源释放操作放置在虚引用中执行和记录。

虚引用的案例

public class PhantomReferenceTest {

    //创建引用对象
    static ReferenceQueue<StringBuilder> referenceQueue = null;
    static PhantomReference<StringBuilder> phantomReference = null;

    public static void main(String[] args) {
        //实例化引用对象
        referenceQueue = new ReferenceQueue<>();
        phantomReference = new PhantomReference<StringBuilder>(new StringBuilder("test"),referenceQueue);
        //创建一个守护线程，打印引用队列情况
        Thread thread = new Thread(() -> {
            while (true) {
                if (referenceQueue != null) {
                    PhantomReference<StringBuilder> reference = null;
                    try {
                        reference = (PhantomReference<StringBuilder>) referenceQueue.remove();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (reference != null) {
                        //打印回收信息
                        System.out.println("GC referenceQueue : " + (reference == phantomReference));
                    }
                }
            }
        });
        thread.setDaemon(true);
        thread.start();
        //打印GC前对象状态
        System.out.println("Before GC : " + phantomReference.get());
        //进行GC操作，暂停程序，以确保GC正常执行
        System.gc();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打印GC后对象状态
        System.out.println("After GC : " + phantomReference.get());
        //进行内存填充，出现OOM错误
        try {
            //进行内存填充
            byte[] bytes = new byte[1024 * 1024 * 7];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            //打印OOM后对象状态
            System.out.println("After OOM : " + phantomReference.get());
        }
    }
}

运行结果

在上面案例中可以看到，当我们试图通过get（）方法获取虚引用所引用的对象时，结果始终为null。通过引用队列我们可以看到，当第一次GC执行后，虚引用所引用的对象实例就已经被回收

总结

强引用（strongReference） ：最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“object obj=new object（）”这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。

软引用（SoftReference） ：在系统将要发生内存溢出之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常

弱引用（WeakReference） ：被弱引用关联的对象只能生存到下一次垃圾收集之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉被弱引用关联的对象。

虚引用（PhantomReference） ：一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获得一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。