细说Java中的各种引用以及GC策略

在介绍各种引用之前，先简单介绍下垃圾回收

什么是垃圾回收

• 垃圾回收（Garbage Collection，GC），顾名思义就是释放垃圾占用的空间，防止内存泄露。有效的使用可以使用的内存，对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收。
• Java 语言出来之前，大家都在拼命的写 C 或者 C++ 的程序，而此时存在一个很大的矛盾，C++ 等语言创建对象要不断的去开辟空间，不用的时候又需要不断的去释放控件，既要写构造函数，又要写析构函数，很多时候都在重复的 allocated，然后不停的析构。于是，有人就提出，能不能写一段程序实现这块功能，每次创建，释放控件的时候复用这段代码，而无需重复的书写呢？
• 1960年，基于 MIT 的 Lisp 首先提出了垃圾回收的概念，用于处理C语言等不停的析构操作，而这时 Java 还没有出世呢！所以实际上 GC 并不是Java的专利，GC 的历史远远大于 Java 的历史！

Java中的垃圾回收是根据可达性分析算法来判断对象是否存活的

可达性分析算法

在主流的商用程序语言（Java、C#，甚至包括前面提到的古老的Lisp）的主流实现中，都是称通过可达性分析（Reachability Analysis）来判定对象是否存活的。这个算法的基本思路就是通过一系列的称为"GC Roots"的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。如图3-1所示，对象object 5、object 6、object 7虽然互相有关联，但是它们到GC Roots是不可达的，所以它们将会被判定为是可回收的对象。

在Java语言中，可作为GC Roots的对象包括下面几种：

• 虚拟机栈（栈帧中的本地变量表）中引用的对象。
• 方法区中类静态属性引用的对象。
• 方法区中常量引用的对象。
• 本地方法栈中JNI（即一般说的Native方法）引用的对象。

各种引用

对象是否存活与“引用”有关。

在JDK 1.2以前，Java中的引用的定义很传统：如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就称这块内存代表着一个引用。这种定义很纯粹，但是太过狭隘，一个对象在这种定义下只有被引用或者没有被引用两种状态，对于如何描述一些“食之无味，弃之可惜”的对象就显得无能为力（这里说的就是强引用，最基本的引用方式）。

我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存之中；如果内存空间在进行垃圾收集后还是非常紧张，则可以抛弃这些对象。很多系统的缓存功能都符合这样的应用场景。

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

强引用

强引用就是最基本的引用方式， Object obj=new Object() ，引用的是另一块内存的起始地址。强引用的对象回收基于“可达性分析”算法，当对象不可达时才可能会被回收。

比如方法中new的对象，引用赋值给方法内的局部变量（局部变量存储在栈帧中的局部变量表），当方法结束之后，栈帧出栈，对象就自然不可达了，不可达就可能会被回收

软引用

软引用是用来描述一些还有用但并非必需的对象。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK

SoftReference<RefObj> ref = new SoftReference<RefObj>(refObj);

写个例子来测试下软引用的GC策略：

# JVM OPTIONS: -XX:+PrintGCDetails -Xmx5m
public class ReferenceTest {

    private List<RefObj> refObjs = new ArrayList<>();

    private SoftReference<RefObj> ref = new SoftReference<RefObj>(createRefObj(4096*256));//1m

    public void add(){
        refObjs.add(createRefObj(4096));
    }

    private RefObj createRefObj(int dataSize){
        RefObj refObj = new RefObj();
        byte[] data = new byte[dataSize];
        for (int i = 0; i < dataSize; i++) {
            data[i] = Byte.MAX_VALUE;
        }
        refObj.setData(data);
        return refObj;
    }
    public void validRef(){
        System.out.println(ref.get());
    }

    public static void main(String[] args) {
        ReferenceTest referenceTest = new ReferenceTest();
        for (int i = 0; i < 1200; i++) {
        //不停新增堆大小
            referenceTest.add();
        //新增后查看SoftReference中的对象是否被回收
            referenceTest.validRef();
        }

    }

    private class RefObj{
        private byte[] data;

        public byte[] getData() {
            return data;
        }

        public void setData(byte[] data) {
            this.data = data;
        }
    }
}

ReferenceTest中维护一个RefObjList和一个SoftReference，往RefObjList不断添加对象，增加堆大小，直至内存溢出。来观察下SoftReference中引用的对象是否还存在

测试结果：

# 截取一段关键部分
[Full GC (Ergonomics) [PSYoungGen: 1023K->1021K(1536K)] [ParOldGen: 4073K->4073K(4096K)] 5097K->5094K(5632K), [Metaspace: 3534K->3534K(1056768K)], 0.0017581 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
reference.ReferenceTest$RefObj@58372a00
reference.ReferenceTest$RefObj@58372a00
reference.ReferenceTest$RefObj@58372a00
reference.ReferenceTest$RefObj@58372a00
reference.ReferenceTest$RefObj@58372a00
[Full GC (Ergonomics) [PSYoungGen: 1024K->1021K(1536K)] [ParOldGen: 4093K->4093K(4096K)] 5117K->5114K(5632K), [Metaspace: 3534K->3534K(1056768K)], 0.0014771 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 1021K->0K(1536K)] [ParOldGen: 4093K->4072K(4096K)] 5114K->4072K(5632K), [Metaspace: 3534K->3534K(1056768K)], 0.0060554 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
null
.....省略
[Full GC (Allocation Failure) [PSYoungGen: 1022K->1022K(1536K)] [ParOldGen: 4093K->4093K(4096K)] 5116K->5116K(5632K), [Metaspace: 3534K->3534K(1056768K)], 0.0014051 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
Exception in thread "main" [Full GC (Ergonomics) [PSYoungGen: 1024K->0K(1536K)] [ParOldGen: 4094K->981K(4096K)] 5118K->981K(5632K), [Metaspace: 3538K->3538K(1056768K)], 0.0037282 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
java.lang.OutOfMemoryError: Java heap space
    at reference.ReferenceTest.createRefObj(ReferenceTest.java:21)
    at reference.ReferenceTest.add(ReferenceTest.java:16)
    at reference.ReferenceTest.main(ReferenceTest.java:35)
Heap
 PSYoungGen      total 1536K, used 39K [0x00000000ffe00000, 0x0000000100000000, 0x0000000100000000)
  eden space 1024K, 3% used [0x00000000ffe00000,0x00000000ffe09e10,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 4096K, used 981K [0x00000000ffa00000, 0x00000000ffe00000, 0x00000000ffe00000)
  object space 4096K, 23% used [0x00000000ffa00000,0x00000000ffaf55f0,0x00000000ffe00000)
 Metaspace       used 3565K, capacity 4564K, committed 4864K, reserved 1056768K
  class space    used 384K, capacity 388K, committed 512K, reserved 1048576K

从程序+GC日志中可以看出，在某次GC后（OOM前的GC），SoftReference中引用的对象获取不到了，已经被GC回收。

弱引用

弱引用也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK

弱引用和软引用使用方式一致，只是对应的类不同，和GC策略不同而已。

WeakReference<RefObj> ref = new WeakReference<RefObj>(refObj);

基于上面软引用的测试代码稍作修改，来测试下弱引用的GC策略：

public class ReferenceTest {

    private List<RefObj> refObjs = new ArrayList<>();

    private WeakReference<RefObj> ref = new WeakReference<RefObj>(createRefObj(4096*256));//1m

    public void add(){
        refObjs.add(createRefObj(4096));
    }

    private RefObj createRefObj(int dataSize){
        RefObj refObj = new RefObj();
        byte[] data = new byte[dataSize];
        for (int i = 0; i < dataSize; i++) {
            data[i] = Byte.MAX_VALUE;
        }
        refObj.setData(data);
        return refObj;
    }
    public void validRef(){
        System.out.println(ref.get());
    }

    public static void main(String[] args) {
        ReferenceTest referenceTest = new ReferenceTest();
        referenceTest.validRef();
        referenceTest.add();
        //手动GC后查看WeakReference中的对象是否还存在
        System.gc();
        referenceTest.validRef();
    }

    private class RefObj{
        private byte[] data;

        public byte[] getData() {
            return data;
        }

        public void setData(byte[] data) {
            this.data = data;
        }
    }
}

测试结果：

[GC (Allocation Failure) [PSYoungGen: 1526K->512K(1536K)] 1992K->1266K(5632K), 0.0005932 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
reference.ReferenceTest$RefObj@58372a00
[GC (System.gc()) [PSYoungGen: 706K->512K(1536K)] 2484K->2346K(5632K), 0.0005772 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 512K->0K(1536K)] [ParOldGen: 1834K->972K(4096K)] 2346K->972K(5632K), [Metaspace: 3493K->3493K(1056768K)], 0.0062458 secs] [Times: user=0.16 sys=0.00, real=0.01 secs] 
null
Heap
 PSYoungGen      total 1536K, used 31K [0x00000000ffe00000, 0x0000000100000000, 0x0000000100000000)
  eden space 1024K, 3% used [0x00000000ffe00000,0x00000000ffe07cc8,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
  to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
 ParOldGen       total 4096K, used 972K [0x00000000ffa00000, 0x00000000ffe00000, 0x00000000ffe00000)
  object space 4096K, 23% used [0x00000000ffa00000,0x00000000ffaf31d8,0x00000000ffe00000)
 Metaspace       used 3500K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 381K, capacity 388K, committed 512K, reserved 1048576K

从日志上看，在任何一次GC（包括手动GC）之后，GC会回收WeakReference中的对象，无论当前内存是否足够。

虚引用

虚引用也称为幽灵引用或者幻影引用，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。在JDK

也就是说，虚引用的对象，随时都有可能被回收

虚引用的用法和软引用/弱引用也很类似，只是在构造的时候，需要指定一个队列

//引用队列，当引用的对象被回收后，Reference对象本身会被添加到referenceQueue中，相当于得到了一个通知
//软引用/弱引用中都有此构造参数，只是在虚引用中此参数变成必传了而已
ReferenceQueue<RefObj> referenceQueue = new ReferenceQueue<>();

PhantomReference<RefObj> ref = new PhantomReference<RefObj>(refObj,referenceQueue);

SoftReference<RefObj> ref = new SoftReference<RefObj>(refObj,referenceQueue);

WeakReference<RefObj> ref = new WeakReference<RefObj>(refObj,referenceQueue);

还是基于上面的测试代码稍作修改，来测试一下虚引用以及回收队列

public class ReferenceTest {

    private List<RefObj> refObjs = new ArrayList<>();

    private ReferenceQueue<RefObj> referenceQueue = new ReferenceQueue<>();

    private PhantomReference<RefObj> ref = new PhantomReference<RefObj>(createRefObj(4096*256),referenceQueue);//1m

    public void add(){
        refObjs.add(createRefObj(4096));
    }

    /**
     * 启一个子线程，监控回收的引用队列
     */
    public void referenceQueueMonitor(){
        new Thread(()->{
            try{
                Reference<RefObj> weakReference;
                while ((weakReference = (Reference<RefObj>) referenceQueue.remove())!=null){
                    System.out.println("collect "+weakReference);
                }
            }catch (InterruptedException e){}
        }).start();
    }

    private RefObj createRefObj(int dataSize){
        RefObj refObj = new RefObj();
        byte[] data = new byte[dataSize];
        for (int i = 0; i < dataSize; i++) {
            data[i] = Byte.MAX_VALUE;
        }
        refObj.setData(data);
        return refObj;
    }
    public void validRef(){
        System.out.println(ref.get());
    }

    public static void main(String[] args) {
        ReferenceTest referenceTest = new ReferenceTest();
        referenceTest.referenceQueueMonitor();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        referenceTest.validRef();
        referenceTest.add();
        System.gc();
        referenceTest.validRef();
    }

    private class RefObj{
        private byte[] data;

        public byte[] getData() {
            return data;
        }

        public void setData(byte[] data) {
            this.data = data;
        }
    }
}

测试结果：

#第一次：
[GC (Allocation Failure) [PSYoungGen: 1525K->512K(1536K)] 3466K->2661K(5632K), 0.0005258 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
null
[GC (System.gc()) [PSYoungGen: 567K->512K(1536K)] 2717K->2717K(5632K), 0.0005225 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 512K->0K(1536K)] [ParOldGen: 2205K->2213K(4096K)] 2717K->2213K(5632K), [Metaspace: 4379K->4379K(1056768K)], 0.0078481 secs] [Times: user=0.13 sys=0.00, real=0.01 secs] 
null
#最后打印了回收日志
collect java.lang.ref.PhantomReference@7be2d776

#第N次：
[GC (Allocation Failure) [PSYoungGen: 1536K->512K(1536K)] 3440K->2536K(5632K), 0.0005524 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
#先打印了回收日志
collect java.lang.ref.PhantomReference@30a3ced6
null
[GC (System.gc()) [PSYoungGen: 573K->512K(1536K)] 2597K->2580K(5632K), 0.0005956 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 512K->0K(1536K)] [ParOldGen: 2068K->2252K(4096K)] 2580K->2252K(5632K), [Metaspace: 4387K->4387K(1056768K)], 0.0082860 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
null

从日志上，多次结果并不一致。由于程序启动时会发生GC，中途又手动触发了GC。结合虚引用的特点来看，虚引用的的对象存活周期并不能确定，对象可能在任何时候被回收。

各种引用的引用场景

我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存之中；如果内存空间在进行垃圾收集后还是非常紧张，则可以抛弃这些对象。很多系统的缓存功能都符合这样的应用场景。

最容易想到的就是缓存了，内存不足时释放部分数据，类似Redis/Ehcache之类的淘汰策略。

下面列出一下JDK/框架中的应用场景：

java.util.WeakHashMap
java.util.concurrent.ArrayBlockingQueue
org.springframework.util.ConcurrentReferenceHashMap

参考

• 《深入理解Java虚拟机：JVM高级特性与实战（第2版）》 - 周志明[著]
• 咱们从头到尾说一次 Java 垃圾回收