引用类型

在jdk 1.2之前，一个对象只有 "已被引用" 和 "未被引用"两种概念，在jdk1.8之后，引用类型分为4类：
强引用：Strong Reference
软引用：Soft Reference
弱引用：Weak Reference
虚引用：Phantom Reference
这4中引用的强度依次减弱

强引用

java中默认的引用类型，只要引用存在，永远不会回收，哪怕内存不足，系统会抛出OOM异常，也不会回收。

软引用

只有当内存不足时，才会回收，回收后如果还是内存不足才会抛出OOM

private static void testSoftReference() {
        for (int i = 0; i < 10; i++) {
            byte[] buff = new byte[1024 * 1024];
            SoftReference<byte[]> sr = new SoftReference<>(buff);
            list.add(sr);
        }
        
        System.gc(); //主动通知垃圾回收
        
        for(int i=0; i < list.size(); i++){
            Object obj = ((SoftReference) list.get(i)).get();
            System.out.println(obj);
        }
        
    }

弱引用

// 无论内存是否足够，只要JVN开始回收，弱引用都会被回收
很多文章都说，只要执行GC就会回收软引用，这种结论是错误的。

当一个对象只被弱引用实例引用（持有）时，这个对象就会被GC回收

• 被回收的对象弱引用实例引用的对象，而不是弱引用本身
• 如果显式地声明了一个变量E e，并使之指向一个对象：e = new E()，这时变量e就是对对象的一个强引用。如果变量e所引用的这个对象同时又被WeakReference的一个实例持有，则由于存在对对象的一个强引用e，对象并不符合上述回收规则，因此对象至少在变量e的作用域范围内都不会被回收。

class TestWeakReference {
    private static List<Object> list = new ArrayList<>();
    public static void main(String[] args) {
        testWeakReference();
    }
    private static void testWeakReference() {
        byte[]buff = new byte[1024 * 1024];
        for (int i = 0; i < 10; i++) {
            WeakReference<byte[]> weakReference = new WeakReference<>(buff);
            list.add(weakReference);
        }
        System.gc();

        for (int i =0; i < list.size(); i ++) {
            Object o = ((WeakReference)list.get(i)).get();
            System.out.println(o);
        }
    }
}

在上述情况下，buff是一个强引用类型，在它的作用域时是不可回收的，即使除了弱引用持有没有其他的引用。

将上述代码改一下，将buff与gc作用域修改

class TestSoftReference {
    private static List<Object> list = new ArrayList<>();
    private static List<Object> lists = new ArrayList<>();
    public static void main(String[] args) {

        testWeakReference();
        gc();
    }
    static WeakReference<byte[]> softReference;
    private static void testWeakReference() {
        byte[]buff = new byte[1024 * 1024];
        for (int i = 0; i < 10; i++) {
            softReference = new WeakReference<>(buff);
            list.add(softReference);
        }
    }
    public static void gc() {
        System.gc();

        for (int i =0; i < list.size(); i ++) {
            Object o = ((WeakReference)list.get(i)).get();
            System.out.println(o);
        }
    }
}

在上面这种情况下，gc执行的作用域与buff的作用域是同级的另一个作用域，且buff无其他引用，则可以回收

将上述代码再修改一下

class TestWeakReference {
    private static List<Object> list = new ArrayList<>();
    public static void main(String[] args) {
        testWeakReference();
    }
    private static void testWeakReference() {
        for (int i = 0; i < 10; i++) {
            byte[]buff = new byte[1024 * 1024];
            WeakReference<byte[]> weakReference = new WeakReference<>(buff);
            list.add(weakReference);
        }
        System.gc();

        for (int i =0; i < list.size(); i ++) {
            Object o = ((WeakReference)list.get(i)).get();
            System.out.println(o);
        }
    }
}

此时buff的作用域只在for循环内，此时是可以被回收的，因为输出的结果均为null

虚引用

虚引用是最弱的引用类型，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收。
永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。

引用队列（ReferenceQueue）

引用队列可以与软引用、弱引用以及虚引用一起配合使用，当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施。

与软引用、弱引用不同，虚引用必须和引用队列一起使用。