第一篇：JVM引用四兄弟

一、前言

Java两种数据类型：8种值类型和3种引用类型（类、接口、数组），不管哪种引用类型，都要有相应的引用。

在Java中提供了四个级别的引用：强引用，软引用，弱引用和虚引用。在这四个引用类型中，只有强引用FinalReference类是包内可见，其他三种引用类型均为public，可以在应用程序中直接使用。引用类型的类结构如图所示。

金手指1：四种引用类型都是继承Reference抽象类，其中，只有强引用FinalReference类是包内可见，其他三种引用类型均为public。

二、强引用

Java中默认声明的就是强引用，例如以下代码，如果M对象被回收了，会打印finalize()方法中的内容：

public class Demo {
    public static void main(String[] args) throws IOException {
        M m = new M();  //只要m还指向M对象，M对象就不会被回收
        // m = null;   //手动置null
        System.gc();  // 进行垃圾回收

        System.in.read();
    }
}

class M {
    @Override
    protected void finalize() {
        System.out.println("对象被回收了...");
    }
}

运行结果：

只要强引用存在，垃圾收集器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了。例如上面的代码，将 m = null; 注释放开时，运行结果如下：

三、软引用

软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出OutOfMemoryError。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。

在 JDK1.2 之后，用 SoftReference 类来表示软引用。下面以一个例子来进一步说明强引用和软引用的区别。

在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx2M，将 JVM 的初始内存设为2M，最大可用内存为 2M。

首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常。

public class Demo {
    public static void main(String[] args) {
        // 当 new byte为 1M 时，程序运行正常
        byte[] buff1 = new byte[1024 * 1024 * 1];
        
        // byte[] buff2 = new byte[1024 * 1024 * 1];
    }
}

但是如果我们再创建一个1M大小的 byte数组时，则内存不够使用，程序直接报错。因为强引用不会被回收。

接着来看一下软引用会有什么不一样，在下面的示例中先创建一个大小为 1M 的软引用对象，打印m的地址，然后进行垃圾回收，休眠500ms后打印m的地址。最后又创建了一个1M的字节数组，打印m的地址。

public class Demo {
    public static void main(String[] args) {
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024]);

        System.out.println(m.get());
        System.gc();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(m.get());
        // 再分配一个数组，heap将装不下，
        // 这时系统会进行垃圾回收，如果内存不够，会把软引用干掉
        byte[] b = new byte[1024*1024*1];
        System.out.println(m.get());
    }
}

运行结果：

根据运行结果，我们可以看到，在内存不足的情况下，软引用才会被回收。

四、弱引用

弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 WeakReference 来表示弱引用。

我们以与软引用同样的方式来测试一下弱引用：

public class Demo {
    public static void main(String[] args) {
        WeakReference<byte[]> m = new WeakReference<>(new byte[1024 * 1024]);

        System.out.println(m.get());
        System.gc();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(m.get());
    }
}

运行结果：

根据运行结果，可以发现垃圾回收后被弱引用关联的对象被回收了。

在 Java 集合中有一种特殊的 Map 类型：WeakHashMap， 在这种 Map 中存放了键对象的弱引用，当一个键对象被垃圾回收，那么相应的值对象的引用会从 Map 中删除。WeakHashMap 能够节约存储空间，可用来缓存那些非必须存在的数据。

五、虚引用

虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收。在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象。虚引用必须要和 ReferenceQueue 引用队列一起使用。

public class PhantomReference<T> extends Reference<T> {
    public T get() {
        return null;
    }

    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}

public class Demo {

    private static final List<Object> LIST = new LinkedList<>();
    private static final ReferenceQueue QUEUE = new ReferenceQueue();

    public static void main(String[] args) {
        PhantomReference<M> m = new PhantomReference<>(new M(), QUEUE);

        new Thread(()->{
            while (true) {
                LIST.add(new byte[1024*1024]);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
                System.out.println(m.get());
            }
        }).start();

        new Thread(()->{
            while (true) {
                Reference poll = QUEUE.poll();
                if(poll != null) {
                    System.out.println("虚引用对象：" + poll + " 被jvm回收了");
                }
            }
        }).start();
    }
}

class M {
    @Override
    protected void finalize() {
        System.out.println("对象被回收了...");
    }
}

运行结果：

对象被回收了...
虚引用对象：java.lang.PhantomReference@4f7a3e51 被jvm回收了
null
Exception in thread "Thread-0" java.lang.OutOfMemoryError:Java heap space

当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。主要用于清理堆外内存。

六、面试金手指(Java四种引用类型)

6.1 类结构关系图和访问权限

类结构关系图：四种引用类型都是继承Reference抽象类；

访问权限：只有强引用FinalReference类是包内可见，其他三种引用类型均为public。

6.2 四种引用的使用对比

	强引用FinalReference	软引用SoftReference	弱引用WeakReferece	虚引用PhantomReference
什么时候释放	两个条件（System.gc()/自动内存回收+内存不够）同时满足也不释放，永远都不会释放，内存不够就OOM，不释放，除非将引用设置为null，System.gc()才释放	两个条件：System.gc()/自动内存回收+内存不够，同时满足，回收	一个条件： System.gc()/自动内存回收，回收	无条件：任意时候都可以回收
作用	程序员写代码都是使用强引用，引用只要不设置为null，System.gc()和自动垃圾都无法回收，保证程序绝对可靠运行，内存不够就OOM异常	作用：缓存技术，比如网页缓存，图片缓存，如果内存不够，就清空缓存保护内存（总不能因为缓存把程序OOM吧，程序OOM只有一个原因，那就是强引用，而强引用是程序员可以把握的，所有OOM是程序员可以处理的）	WeakHashMap 节约存储空间，作为缓存一些不重要的数据	一般无作用（记住一点，PhantomReference 源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，即虚引用必须要和 ReferenceQueue 引用队列一起使用）

优先级：强引用 > 内存不够OOM > 软引用 > 弱引用 >虚引用。

6.3 两个金手指

金手指1：强引用的优先级比OOM高

强引用作用：程序员写代码都是使用强引用，引用只要不设置为null，System.gc()和自动垃圾都无法回收，保证程序绝对可靠运行，内存不够就OOM异常。

金手指2：软引用的优先级比OOM低

软引用作用：缓存技术，比如网页缓存，图片缓存，如果内存不够，就清空缓存保护内存（总不能因为缓存把程序OOM吧，程序OOM只有一个原因，那就是强引用，而强引用是程序员可以把握的，所有OOM是程序员可以处理的）。

七、尾声

JVM引用四兄弟，完成了。

天天打码，天天进步！！！