理解Java四种引用类型——强软弱虚

Java中引用分为4种类型，按照引用强度递减分别是强引用、软引用、弱引用、虚引用。
这里引用强度指的是被gc回收的存活倾向。

• 强引用 只要存在、指向的对象就不会被gc回收。
• 软引用 发生gc时若内存不足，则会回收指向的对象。
• 弱引用 只要发生gc、所指向的对象就会被回收。
• 虚引用 所指向的对象获取不到、拿出来是null，因此也叫幽灵对象。只起个标识的作用。

先定义一个用来测试的对象：

public class SomeObject {
    
    @Override
    protected void finalize() throws Throwable{
        System.out.println("OneObject对象即将回收...");
    }
}

强引用

public class StrongReferenceTest {
    public static void main(String[] args) {
        SomeObject object = new SomeObject();
        System.out.println("SomeObject实例：" + object);
        System.gc(); //命令jvm尝试一次fgc
        System.out.println("SomeObject实例：" + object);
        object = null; //使得上面的SomeObject对象失去gc root引用
        System.gc();
    }
}

输出结果：

SomeObject实例：com.wangan.javaref.SomeObject@2a139a55
SomeObject实例：com.wangan.javaref.SomeObject@2a139a55
SomeObject即将被垃圾回收...

第一次手动fgc时，由于存在object = new SomeObject()这个强引用关系，所以SomeObject对象没有被回收，之后object=null相当于使得object引用指向了null，这样一来SomeObject对象就没有gc root引用了，所以第二次fgc它被回收了，被gc之前触发了finalize()方法。

软引用

/**
 * -Xms100m -Xmx100m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log
 * */
public class SoftReferenceTest {
    private static final int M = 1024*1024;
    public static void main(String[] args) {
        SoftReference<SomeObject> softRef = new SoftReference<>(new SomeObject());
        SoftReference<byte[]> byteArraySoftRef = new SoftReference<>(new byte[50*M]);
        System.out.println("SomeObject：" + softRef.get());
        System.out.println("byte[]：" + byteArraySoftRef.get());
        System.gc();//手工gc
        System.out.println("SomeObject：" + softRef.get());
        System.out.println("byte[]：" + byteArraySoftRef.get());
        byte[] anotherByteArray = new byte[50*M]; //再来5M的byte数组，堆内存空间不足，触发gc
        System.out.println("softRef：" + softRef);
        System.out.println("SomeObject：" + softRef.get());
        System.out.println("byteArraySoftRef：" + byteArraySoftRef);
        System.out.println("byte[]：" + byteArraySoftRef.get());
    }
}

输出

SomeObject：SomeObject@2a139a55
byte[]：[B@15db9742
SomeObject：SomeObject@2a139a55
byte[]：[B@15db9742
SomeObject即将被垃圾回收...
softRef：java.lang.ref.SoftReference@6d06d69c
SomeObject：null
byteArraySoftRef：java.lang.ref.SoftReference@7852e922
byte[]：null

我们首先固定住堆大小为100M，然后分配了一个对象和一个50M数组都是软引用，然后System.gc()手工触发gc，这时候由于堆内存还够用，软引用指向的对象没有被回收。之后我们再尝试分配50M的byte数组，大数组直接进入老年代、老年代不足触发gc，gc之后仍然堆内存不足，所以触发回收软引用对象。
值得一提的是，触发gc回收的是软引用指向的对象，也就是那个SomeObject和byte[]，而不是回收软引用SoftReference这个实例本身，SoftReference是在所在方法体执行完、对应的栈帧被弹出之后由于失去gc root被回收。
gc日志

Java HotSpot(TM) 64-Bit Server VM (25.60-b23) for windows-amd64 JRE (1.8.0_60-b27), built on Aug  4 2015 11:06:27 by "java_re" with MS VC++ 10.0 (VS2010)
Memory: 4k page, physical 8303348k(4172232k free), swap 14332660k(7197788k free)
CommandLine flags: -XX:InitialHeapSize=104857600 -XX:MaxHeapSize=104857600 -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC 
0.638: [GC (System.gc()) [PSYoungGen: 2064K->800K(29696K)] 53264K->52008K(98304K), 0.0039739 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.642: [Full GC (System.gc()) [PSYoungGen: 800K->0K(29696K)] [ParOldGen: 51208K->51734K(68608K)] 52008K->51734K(98304K), [Metaspace: 2642K->2642K(1056768K)], 0.0250932 secs] [Times: user=0.13 sys=0.02, real=0.03 secs] 
0.669: [GC (Allocation Failure) [PSYoungGen: 512K->0K(29696K)] 52246K->51734K(98304K), 0.0025944 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.672: [GC (Allocation Failure) [PSYoungGen: 0K->0K(29696K)] 51734K->51734K(98304K), 0.0028220 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.675: [Full GC (Allocation Failure) [PSYoungGen: 0K->0K(29696K)] [ParOldGen: 51734K->51734K(68608K)] 51734K->51734K(98304K), [Metaspace: 2642K->2642K(1056768K)], 0.0081899 secs] [Times: user=0.06 sys=0.02, real=0.01 secs] 
0.683: [GC (Allocation Failure) [PSYoungGen: 0K->0K(29696K)] 51734K->51734K(98304K), 0.0029494 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
0.686: [Full GC (Allocation Failure) [PSYoungGen: 0K->0K(29696K)] [ParOldGen: 51734K->523K(68608K)] 51734K->523K(98304K), [Metaspace: 2642K->2642K(1056768K)], 0.0212280 secs] [Times: user=0.09 sys=0.00, real=0.02 secs] 
Heap
 PSYoungGen      total 29696K, used 1280K [0x00000000fdf00000, 0x0000000100000000, 0x0000000100000000)
  eden space 25600K, 5% used [0x00000000fdf00000,0x00000000fe0401c0,0x00000000ff800000)
  from space 4096K, 0% used [0x00000000ffc00000,0x00000000ffc00000,0x0000000100000000)
  to   space 4096K, 0% used [0x00000000ff800000,0x00000000ff800000,0x00000000ffc00000)
 ParOldGen       total 68608K, used 51723K [0x00000000f9c00000, 0x00000000fdf00000, 0x00000000fdf00000)
  object space 68608K, 75% used [0x00000000f9c00000,0x00000000fce82cd8,0x00000000fdf00000)
 Metaspace       used 2649K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 286K, capacity 386K, committed 512K, reserved 1048576K

软引用的特性比较适合用于构建进程内缓存。

弱引用

public class WeakReferenceTest {
    public static void main(String[] args) {
        WeakReference<SomeObject> weakRef = new WeakReference<>(new SomeObject());
        System.out.println("weakRef: " + weakRef);
        System.out.println("SomeObject: " + weakRef.get());
        System.gc();
        System.out.println("weakRef: " + weakRef);
        System.out.println("SomeObject: " + weakRef.get());
    }
}

输出

weakRef: java.lang.ref.WeakReference@2a139a55
SomeObject: SomeObject@15db9742
weakRef: java.lang.ref.WeakReference@2a139a55
SomeObject: null
SomeObject即将被垃圾回收...

内存足够的情况下发生gc（这里我们是用手工System.gc，实际情况下更可能是年轻代分配对象空间不够触发的ygc），这时候弱引用指向的对象也会被回收。也就是弱引用不管内存是否足够都会在下一次gc中被回收。
ThreadLocal中有关于弱引用WeakReference的应用。

虚引用

我们无法获取虚引用所指向的对象，虚引用一般被用来释放堆外内存
因此它所指向的一般是堆外内存。
jvm无法直接管理和回收堆外内存，因此在gc的时候如果要顺带触发堆外内存的回收的话，必须找到个办法能知道这时候要回收哪块堆外内存。
比如某个方法内创建了一个虚引用临时变量，指向堆外内存，随着线程栈的弹出，理论上我们是要回收这个内存的，因为没有root引用了。
这时候就将这个虚引用放入创建它时候指定的那个引用队列，做个记录。之后再从引用队列里找到这个引用来释放相应的直接内存。

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;

/**
 * 我们无法获取虚引用所指向的对象，虚引用一般被用来释放堆外内存
 * 因此它所指向的一般是堆外内存。
 * jvm无法直接管理和回收堆外内存，因此在gc的时候如果要顺带触发堆外内存的回收的话，必须找到个办法能知道这时候要回收哪块堆外内存。
 * 比如某个方法内创建了一个虚引用临时变量，指向堆外内存，随着线程栈的弹出，理论上我们是要回收这个内存的，因为没有root引用了。
 * 这时候就将这个虚引用放入创建它时候指定的那个引用队列，做个记录。之后再从引用队列里找到这个引用来释放相应的直接内存。
 * */
public class PhantomReferenceTest {
    private static final ReferenceQueue<SomeObject> queue = new ReferenceQueue<>();
    
    public static void main(String[] args) {
        /**
         * SomeObject oneObject = new SomeObject();
         * PhantomReference<SomeObject> oneObjectRef = new PhantomReference<SomeObject>(oneObject, queue);
         * 这么搞的话底下System.gc()无法回收SomeObject对象，因为这里用oneObject指向了这个对象，
         * 且后者是个强引用，线程没执行完，栈帧没从线程栈里弹出来、线程栈也没销毁。
         * 所以不回收。
         * */
        //SomeObject oneObject = new SomeObject(); //创建一个SomeObject对象;
        PhantomReference<SomeObject> oneObjectRef = new PhantomReference<SomeObject>(new SomeObject(), queue);//创建这个对象的虚引用
        System.out.println("虚引用oneObjectRef的地址：" + oneObjectRef);
        System.out.println("虚引用oneObjectRef关联的SomeObject对象的地址：" + oneObjectRef.get());
        
        while(true) {
            System.gc(); //命令jvm尝试一次fgc，上边的new OneObject()没有强引用，要被回收了
            Reference<? extends SomeObject> ref = queue.poll();
            if(null!=ref) {
                System.out.println("gc过后，在引用队列中找到了虚引用，一般来说其所指向的是直接内存，无法gc，需要做特殊处理。" + ref);
                break;
            }
        }
    }
}

package com.wangan.direct;
import java.lang.reflect.Field;

import sun.misc.Unsafe;
public class UnsafeUtil {
    
    /**
     * 返回Unsafe实例
     * */
    public static Unsafe getUnsafeInstance() throws Exception{
        //return Unsafe.getUnsafe();
        Field unsafeInstance = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeInstance.setAccessible(true);
        return (Unsafe)unsafeInstance.get(Unsafe.class);
    }
}

参考文章：
https://blog.csdn.net/u011291072/article/details/106315905
https://blog.csdn.net/aitangyong/article/details/39455229