Java中的引用与ThreadLocal

Java中的引用–强软弱虚

强引用

Object object = new Object()，这个object就是一个强引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError异常，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

软引用(SoftReference)

如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

public class TestSoftReference {
    public static void main(String[] args) throws InterruptedException {
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        // m强引用指向softReference,softReference软指向byte[]
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024 * 10],queue);
        // 打印结果:[B@1e643faf
        System.out.println(m.get());
        System.gc();
        Thread.sleep(1000);
        // 打印结果:[B@1e643faf 表示没有被垃圾回收
        System.out.println(m.get());
        // 给出一个强引用
        byte[] bytes = new byte[1024 * 1024 * 15];
        // 不规定最大堆内存大小时，打印结果:[B@1e643faf
        // 指定最大堆内存-Xmx20M时，打印输出null
        System.out.println(m.get());
        //打印结果:java.lang.ref.SoftReference@6e8dacdf
        System.out.println(queue.poll());
    }
}

不指定参数，输出结果

[B@1e643faf
[B@1e643faf
[B@1e643faf
null

指定参数-Xmx20M，输出结果

[B@1e643faf
[B@1e643faf
null
java.lang.ref.SoftReference@6e8dacdf

弱引用(WeakReference)

如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

public class TestWeakReference {
    public static void main(String[] args) {
        WeakReference<byte[]> m = new WeakReference<>(new byte[1024*1024*10]);
        System.out.println(m.get());
        System.gc();
        System.out.println(m.get());
    }
}

有垃圾回收直接回收，打印结果：

[B@1e643faf
null

虚引用(PhantomReference)

顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 主要用在管理对外内存

ThreadLocal

ThreadLocal提供线程局部变量。这些变量与普通变量不同，因为每个线程都有其自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态变量，并将它与线程的状态绑定（例如，用户ID或事务ID）。

简单案例：

public class TestThreadLocal {
    private static final AtomicInteger nextId = new AtomicInteger(0);

    private static final ThreadLocal<Integer> threadId = ThreadLocal.withInitial(nextId::getAndIncrement);

    public static int get() {
        return threadId.get();
    }

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(TestThreadLocal.get());   // 0
            try {
                Thread.sleep(1000);
                System.out.println(TestThreadLocal.get());   // 0
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{System.out.println(TestThreadLocal.get());}).start();   // 1
    }
}

这里通过ThreadLocal对象threadId为每一个调用TestThreadLocal.get()方法的线程赋予一个线程Id，第4行通过ThreadLocal.withInitial(nextId::getAndIncrement)得到ThreadLocal的子类SuppliedThreadLocal对象，SuppliedThreadLocal对象复写了initialValue方法。

        @Override
        protected T initialValue() {
            return supplier.get();
        }

具体细节下面再谈。先看看main方法，其中启动了两个线程，可以看到每个线程通过调用TestThreadLocal.get()得到独有的Id。接下来分析ThreadLocal的主要方法。

set方法

源代码：

    public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 得到线程的threadLocals属性，是ThreadLocalMap对象,其中k为这个ThreadLocal对象，v为value
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }

从中可以看到ThreadLocalMap对象是实现功能的关键，整体思路和HashMap相似，具体代码就不细看了，有兴趣可以自己点进去看，接下来只讲述其中的关键点。ThreadLocalMap维护了一个Entry数组，对ThreadLocal对象的HashCode进行处理后作为index将Entry对象添加到数组中。接下来就是重中之重，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对象，并且拥有属性value。看下来可能有点晕了，给出一个图方便理解

可以理解为每一个Thread都有一个ThreadLocalMap属性，其中key为弱引用指向ThreadLocal,value为强引用指向传入的对象。

为什么要用弱引用作为key？

如果key为强引用,当我们现在将ThreadLocal的引用指向为null，但是每个线程中有自己独立ThreadLocalMap，还会一直持有该对象，所以ThreadLocal对象不会被回收，会发生内存泄漏问题。如果key为弱引用，当我们现在将ThreadLocal的引用指向为null时，线程中独立的ThreadLocalMap中的ThreadLocal对象会被回收。

还是有内存泄漏？

但是会发现就算是key被回收了，value也仍然被Entry中的value强引用指着不会被回收，依然会发生内存泄漏，所以在不用value的时候应该主动调用ThreadLocal对象的remove方法来移除。

remove方法

源代码：

        private void remove(ThreadLocal<?> key) {
            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)]) {
                if (e.get() == key) {
                    e.clear();   // 清理弱引用
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

expungeStaleEntry(i);将Entry数组的第i个entry对象的value置为null，然后将这个enrty对象置为null，最后进行rehash。

get方法

源代码：

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

在get方法中，通过getMap()获得当前Thread对象的threadLocals属性。在没有调用set方法之前，threadLocals属性为null，所以会调用setInitialValue()：

    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

可以看到，直接调用initialValue()方法得到value，然后设置并返回value，这就是前面为什么重写initialValue()方法。通过重写initialValue()方法，给顶一个初始值，这样在没有调用set方法之前调用get方法就会从initialValue()中得到一个初始值。