Java中的类型引用

强软弱虚

强引用

栈内存指向了堆内存

public class MGCTest {
    public static void main(String[] args) {
        M m = new M();
        m = null;
        System.gc();
    }
}
复制代码

当栈内存的m指向堆内存的new M()，当m=null是gc触发就会把new M()回收。

软引用

先示例

/**
 * create by yanghongxing on 2020/5/19 11:48 下午
 */
public class SoftReferenceM {
    public static void main(String[] args) throws InterruptedException {
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024 * 10]);
        System.out.println(m.get());
        System.gc();
        System.out.println(m.get());
        SoftReference<byte[]> n = new SoftReference<>(new byte[1024 * 1024 * 11]);
        System.out.println(m.get());
      
      	ThreadLocal<M> mThreadLocal = new ThreadLocal<>();
        mThreadLocal.set(new M());
        mThreadLocal.get();
    }
}
复制代码

我先创建了一个弱引用，这里的引用关系时第一步创建了一个SoftReference对象，第二步创建了一个byte对象，第三 步将将SoftReference通过弱引用指向byte对象，最后将m通过强引用指向SoftReference对象。我们设置一个jvm参数-Xmx20m，将堆内存设置最大值为20m。输出结果为：

[B@372f7a8d
[B@372f7a8d
null
复制代码

因为我们把堆内存设置成最大值20m，第一次创建了一个10m的byte数组，第二次创建了一个11m的byte数组，第二次创建的时候堆内存不够用，就回收了之前10m的数组。

弱引用

public class WeakReferenceM {
    public static void main(String[] args) {
        WeakReference<M> m = new WeakReference<>(new M());
        System.out.println(m.get());
        System.gc();
        System.out.println(m.get());
    }
}
复制代码

输出结果：

com.example.demo.quote.M@372f7a8d
null
finalize
复制代码

弱引用垃圾回收器看到就会被回收。弄清楚弱引用先了解一下什么是ThreadLocal，是个本地线程对象，线程存在这个对象就存在，比如在spring的Transactional注解，在为了保证事务不同的方法中获取的必须是同一个连接对象，这个连接对象就被保存咋ThreadLocal中。我们看看ThreadLocal的源码。

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
复制代码

首先拿到当前线程对象，然后获取了个map，然后往这个map中放了当前对象，这个this就是ThreadLocal对象

 /**
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
复制代码

t.threadLocals，t是Thread对象，Thread对象的一个成员变量。我们再看看set方法的源码

/**
         * Set the value associated with key.
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
复制代码

这个构造了个Entry对象，这个Entry可以看成是map的一行数据，一个key-value对。再看看Entry的源码。

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
复制代码

这个Entry对象竟然是继承了WeakReference对象。所以弱引用的典型应用就是ThreadLocal中。

上面的用图画出来就是这个样子，Thread对象中存了一个强引用指向ThreadLocal就是ThreadLocal mThreadLocal = new ThreadLocal<>()句代码，同时Thread中还有个ThreadLocalMap，这个map的key就是指向ThreadLocal对象，这个对象使用的是弱引用，使用弱引用的原因是防止内存泄漏。既然这里使用的是弱引用为啥ThreadLocal还那么容易产生内存泄漏呢？我们看key是弱引用，但是value不是，所以这个记录还是在map中，所以容易产生内存泄漏，为了防止内存泄漏，我们就在ThreadLocal使用完就remove掉。

虚引用

public class PhontamReferenceM {
    private static ReferenceQueue<M> QUEUE = new ReferenceQueue<>();
    private static List<byte[]> LIST = new ArrayList();


    public static void main(String[] args) {
        PhantomReference<M> m = new PhantomReference<>(new M(), QUEUE);
        new Thread(() -> {
            while (true) {
                LIST.add(new byte[1024 * 1024]);
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("0" + m.get());
            }
        }).start();
        new Thread(() -> {
            while (true) {
                Reference<? extends M> poll = QUEUE.poll();
                if (Objects.nonNull(poll)) {
                    System.out.println("1" + poll);
                }
            }
        }).start();
    }
}
复制代码

输出为：

0null
1java.lang.ref.PhantomReference@b148489
0null
0null
0null
0null
复制代码

虚引用的主要作用是管理堆外内存， 比如nio操作为了提高效率就可能有部分内存放在堆外，堆外内存不能直接被GC回收，可能当对象被回收时，通过Queue可以检测到，然后清理堆外内存。