强、软、弱、虚四种类型引用剖析

首先，整体的UML架构图如下：

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

当内存不足时，JVM开始进行GC(垃圾回收)，对于强引用对象，就算是出现了OOM也不会对该对象进行回收，死都不会收。

强引用是我们最常见的普通对象引用，只要还要强引用指向一个对象，就表明这个对象还活着，垃圾收集器不会碰这种对象。在java中最常见的就是强引用，就是把一个对象赋值给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制给回收掉的，即使该对象以后永远都不会被用到也不会被JVM回收掉。因此，强引用是造成java内存泄漏的主要原因之一。

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

一个简单的小demo:

public class StrongReferenceDemo {
    public static void main(String[] args) {

        //定义一个强引用
        Object o1 = new Object();
        //o2引用赋值
        Object o2 = o1 ;
        o1 = null ;

        System.gc();

        System.out.println(o1);
        System.out.println(o2);

    }
}

//运行结果：
null
java.lang.Object@1b6d3586

2、软引用

软引用是一种相对强引用弱化了一些的引用，需要java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾手机。

对于软引用来说：

• 当系统内存充足的时候，不会被回收；
• 当系统内存不足时，它会被回收

软引用通常用在对内存敏感的 程序中，比如高速缓存就用到软引用。内存够用时就保留，不够时就回收。

内存够用的Demo：

    public static  void softRef_memory_enough(){

        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);

        System.out.println(o1);
        System.out.println(softReference.get());

        o1 = null;
        System.gc();

        System.out.println(o1);
        System.out.println(softReference.get());


    }
//运行结果：
java.lang.Object@1b6d3586
java.lang.Object@1b6d3586
null
java.lang.Object@1b6d3586

由此我们可以证明，内存够用的情况下软引用不会被回收。

那么接下来我们测试一下内存不够用的情况：

/**
     * 修改JVM配置参数，并且故意生产大对象，使得内存不够用引起OOM
     * 看软引用的回收情况
     * 配置参数:
     * -Xms5m -Xmx5m -XX:+PrintGCDetails
     */
    public static  void softRef_memory_not_enough(){

        Object o1 = new Object();
        SoftReference<Object> softReference = new SoftReference<>(o1);

        System.out.println(o1);
        System.out.println(softReference.get());

        o1 = null;

        try {

        byte[] bits = new byte[30*1024*1024];

        }catch (Throwable ex){

        }finally {

            System.out.println(o1);
            System.out.println(softReference.get());

        }

    }
//运行结果:
java.lang.Object@1b6d3586
java.lang.Object@1b6d3586
null
null

可以看到，内存不够用的时候，软引用对象也就被回收掉了。

3、弱引用

弱引用需要用到java.lang.ref.WeakReference类来实现，它比软引用的生存周期更短。对于只有弱引用的对象来说，只要有垃圾回收，不管JVM的内存空间够不够用，都会回收该对象占用的内存空间。

一个简单的小Demo:

public class WeakReferenceDemo {

    public static void main(String[] args) {

        Object o1 = new Object();
        WeakReference<Object> weakReference = new WeakReference<>(o1);

        System.out.println(o1);
        System.out.println(weakReference.get());

        o1 = null ;
        System.gc();

        System.out.println("===============");

        System.out.println(o1);
        System.out.println(weakReference.get());

    }

}
//运行结果：
java.lang.Object@1b6d3586
java.lang.Object@1b6d3586
===============
null
null

4、软引用和弱引用的使用场景

假如有一个应用需要读取大量的本地图片，如果每次都从硬盘读取则会严重影响性能；如果一次性全部加载到内存中又可能造成内存溢出。

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

再比如：MyBatis用到的缓存。。。。

补充一个WeakHashMap的Demo：

    public static void weakHashMapTest(){

        WeakHashMap<Integer,String> weakHashMap = new WeakHashMap<>();

        Integer key = new Integer(1);
        String value = "WeakHashMap";

        weakHashMap.put(key,value);
        System.out.println("weakHashMap"+weakHashMap);

        key = null ;
        System.out.println("weakHashMap"+weakHashMap);

        System.gc();
        System.out.println("weakHashMap"+weakHashMap+", weakHashMapSize = "+weakHashMap.size());

    }
//运行结果：
weakHashMap{1=WeakHashMap}
weakHashMap{1=WeakHashMap}
weakHashMap{}, weakHashMapSize = 0

5、虚引用

虚引用需要java.lang.ref.Phantomreference类来实现。顾名思义，虚引用就是形同虚设。与其它几种引用不同，虚引用并不会决定对象的声明周期。

如果一个对象仅仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收掉，他不能单独使用也不能通过它访问对象，虚引用必须和引用队列（ReferenceQueue）联合使用。

虚引用的作用主要是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被finalize以后，做某些事情的机制。PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。其意义在于说明一个对象已经进入了finalization阶段，可以被gc回收，用来实现比finalization机制更加灵活的回收操作。

换句话说，设置虚引用关联的唯一目的，就是在这个对象被回收的时候收到一个系统通知或者是后续添加进一步的操作处理。java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做一些必要的清理工作。

刚刚提到了引用队列，其作用就是一个对象在被回收之前，保存到这个队列中去。

虚引用结合引用队列使用的Demo：

public class ReferenceQueueDemo {

    public static void main(String[] args) throws InterruptedException {

        Object o1 = new Object();
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        PhantomReference<Object> phantomReference = new PhantomReference<>(o1,queue);

        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(queue.poll());

        System.out.println("=============");

        o1 = null ;
        System.gc();
        Thread.sleep(500);

        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(queue.poll());
    }

}
//运行结果:
java.lang.Object@1b6d3586
null
null
=============
null
null
java.lang.ref.PhantomReference@4554617c

ReferenceQueue是用来配合引用工作的，没有ReferenceQueue一样可以工作。

创建引用的时候可以指定关联的队列，当GC释放对象内存的时候，会将引用加入到引用队列中去。如果程序发现某个虚引用已经被加入到引用队列中，那么就可以在所引用的对象的内存被回收之前采取必要的行动，这相当于一种通知机制。

当关联的引用队列中有数据的时候，意味着引用指向堆内存中的对象被回收。通过这种方式，JVM允许我们在对象被销毁时，做一些后续处理。

暴力总结：

• 强引用：到死都不回收；
• 软引用：内存不够时才回收；
• 弱引用：只要有GC,就回收；
• 虚引用：形如虚设，垂死挣扎。