Java中引用Reference

java中有四种引用：强引用、软引用、若引用、虚引用

1 强引用

强引用就是我们平时使用引用，给一个域赋值一个对象，那这个域就是这个对象的强引用。

public class UserTest{
    private static User userOne= new User();
    private User userTwo = new User();

    public static void main(String[] args){
        UserTest userTest = new UserTest();
    }
}

这里的userOne和userTwo都是强引用，UserTest类被加载就会创建第一个User对象，main方法中初始化一个UserTest对象会创建一个User对象，当userTest出作用域后，userTest就不可达，userTest中的userTwo也就不可达。UserTest类被卸载时userOne引用的对象才变的不可达（例子不好，因为main方法执行结束，jvm就停止了，那就没啥可达不可达了）。

2 Reference

References是其他三种引用的基类。主要域属性有

private T referent;         /* Treated specially by GC */
volatile ReferenceQueue<? super T> queue;
@SuppressWarnings("rawtypes")
volatile Reference next;  
transient private Reference<T> discovered;  /* used by VM */
private static Reference<Object> pending = null;

Reference中有两个队列，pending和discovered维护一个队列：pending相当于head，discovered相当于next；queue和next维护一个队列。垃圾回收器发现引用指向的对象没有强引用的话就会将该引用加入pending队列中，Reference中会启动一个Reference-handler线程，将pending队列中的Reference对象加入到queue中，以便我们使用。下面再翻译一下Reference对象的状态。

1. Active：由垃圾回收器进行特殊处理。当垃圾回收器检测到其引用对象可达性发行变化时（没有强引用），会将引用的状态变成Pending或者Inactive，如果引用构造时有注册队列那么引用的状态会变成Pending否则会变成Inactive。
2. Pending：引用在Pending队列中，等待Reference-handler线程将其入队queue中。
3. Enqueued：引用在queue中。没有注册队列的引用不会有Pending和Enqueued状态
4. Inactive：从queue中poll或者remove后或者Active直接转换，Inactive表示已经没有其余工作需要做了，Inactive状态不会再超其他状态转变。

3 软引用SoftReference

垃圾回收器根据内存需求对软引用进行回收，多用于内存敏感的缓存。假定垃圾回收器在某个时间点决定一个对象是软引用可达的（对象没有强引用），那么垃圾回收器会自动选择回收该对象及仅通过该对象可达的对象。虚拟机会在抛出OutOfMemoryError之前回收软引用指向的对象。除此之外对软引用回收的时间及其回收的顺序没有限制，然后虚拟机偏向新创建的及最近使用的软引用（翻译注释的，不清楚发在发生正常垃圾回收后发现空间不够回收软引用的时候，是把全部软引用都回收还是只是回收到足够的空间即可）。

4 弱引用WeakReference

软引用不会影响其引用对象的回收，当垃圾回收器在某一时刻决定一个对象是弱可达的，那么垃圾回收器会在先清除弱引用引用的对象，然后回收其指向的对象，同一时间或稍后会将这些弱引用加入队列（如果引用初始化时有注册队列）。

 

public class DemoMain {
    
    public static void main(String[] args) {
        ReferenceQueue<User> referenceQueue = new ReferenceQueue<>();
        new Thread(() -> {
            Object o;
            while ((o = referenceQueue.poll()) == null) {
            }
            System.out.println(o); // o是一个Object对象java.lang.ref.WeakReference@d5bf752
            System.out.println(((Reference) o).get()); // ((Reference) o).get() = null
        }).start();
        WeakReference<User> weakReferenceUser = new WeakReference<>(new User("小明"), referenceQueue);
        System.out.println(JSON.toJSONString(referenceQueue.poll()));  // referenceQueue.poll() = null
        // weakReferenceUser.get() 是User对象， weakReferenceUser.get().getName() = "小明"
        System.out.println(weakReferenceUser.get() == null ? null : weakReferenceUser.get().getName());
        System.gc(); // 第一步
        // referenceQueue.poll() = null 垃圾回收器已经清理完队列了
        System.out.println(JSON.toJSONString(referenceQueue.poll()));    // 第二步 weakReferenceUser.get() == null 或者 weakReferenceUser.get() == java.lang.ref.WeakReference@d5bf752

        System.out.println(weakReferenceUser.get() == null ? null : weakReferenceUser.get().getName());
    }
    
    @Getter
    public static class User {
        private String name;
        public User(String name) {
            this.name = name;
        }
    }
}

就是说在第一步调用后，垃圾回收器会把weakReferenceUser中的referent置空，然后将User对象标记为已终结，最后将weakReferenceUser加到referenceQueue中。如果删除一直轮询referenceQueue的线程，在第二步的位置是poll可能会打印null或者weakReferenceUser对象的toString()返回值，这应该和线程执行顺序有关，也是单独的一个线程将回收的弱引用入队referenceQueue的。

弱引用主要也是用于缓存，例如WeakHashMap，ThreadLocal中的ThreadLocalMap（ThreadLocalMap感觉有点问题，可能也是造成内存泄漏的一个原因）。那我们来说说WeakHashMap， 先看下WeakHashMap的定义和其构造函数。

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V>

Entry(Object key, V value,
	ReferenceQueue<Object> queue,
	int hash, Entry<K,V> next) {
	super(key, queue);
	this.value = value;
	this.hash  = hash;
	this.next  = next;
}

WeakHashMap中的Entry实现了WeakReference，key是弱引用指向的对象。看下面例子

public class DemoMain2 {
    static WeakHashMap<String, DemoMain.User> weakHashMap = new WeakHashMap<>();
    public static void main(String[] args) {
        test();
        System.gc();  // 第一步
        String name1 = new String("小明");
        weakHashMap.put(name1, new DemoMain.User("小明"));
    }
    public static void test(){
        String name1 = new String("阿花");
        weakHashMap.put(name1, new DemoMain.User("阿花"));
    }
    @Getter
    public static class User {
        private String name;
        public User(String name) {
            this.name = name;
        }
    }
}

在第一步的位置，阿花对应的那个字符串因为没有强引用的存在，会被回收，但是这个阿花对应的Entry对象（也是一个弱引用对象）不会被回收，其实还是占着内存位置，但是WeakHashMap根据ThreadLocalMap不同的是，它利用弱引用的注册队列，在某些操作的情况下会触发清除无用Entry的情况。WeakHashMap#expungeStaleEntries方法会将queue中的entry对象取出清除，有下面三个方法直接调用。

WeakHashMap中的put等其他方法会间接调用。这种弱引用缓存的好处就是程序中key已经不可达了（就像上面程序执行gc的第一步，name1已经不可达）不需要手动删除缓存信息，由WeakHashMap利用弱缓存借用垃圾回收器帮我们清除缓存。ThreadLocalMap因为没有收集无用Entry的操作，所以弱缓存应该没有什么作用（感觉哈）。

5 影子引用PhantomReference

垃圾回收器在没有其引用指向这个对象，会将这个影子引用入队，影子引用多用于替换java中的finalization机制，影子引用更灵活。不像软引用和弱引用，影子引用入队时其指向的对象不会被自动清除，也就是说其指向的对象不会被回收，除非这个对象变得完全不可达（翻译的注释）。但是无法通过影子引用PhantomReference#get方法获取其指向的对象，所以使用时如果没有注册队列，那么影子引用完全没有作用。但是影子引用的子类Cleaner是被Reference特殊对待的类，它用于堆外内存的回收。见https://juejin.im/post/5be538fff265da611b57da10#comment