【Java基础】ThreadLocal

ThreadLocal是啥

ThreadLocal并不是新生事物，早在JDK 1.2的版本中就已经出现了。JDK 1.2发布于1998年12月，距今已经有22年的历史。JDK 1.2是Java发展史的一座里程碑，涌现了很多开创性的功能，例如本文要说的ThreadLocal。

ThreadLocal为解决多线程程序的并发问题提供了一种新的思路，使用这个工具类可以很简洁地编写出优美的多线程程序。但是，ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，所以有人觉得它命名为ThreadLocalVariable更容易让人理解一些。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。从线程的角度看，目标变量就像是线程的本地变量，这也是类名中“Local”所要表达的意思。

ThreadLocal应用场景

ThreadLocal 主要是用在多线程的场景中

• 保存线程上下文信息，在任意需要的地方可以获取
• 线程安全，避免某些情况需要考虑线程安全必须同步带来的性能损失

ThreadLocal原理

ThreadLocal类代码不长，JDK1.8只有722行（算上注释），有几个关键的成员：内部静态类ThreadLocalMap，是一个简化的HashMap， Entry类型的table数组保存元素，元素为Entry类型，Entry是ThreadLocalMap的静态内部类，其继承了WeakReference<ThreadLocal<?>>，Entry是一个key-value格式，key是ThreadLocal对象，value就是需要保存的本地对象，值得注意是这里key值ThreadLocal对象是一个弱引用，为什么采用弱引用后面解释。

static class ThreadLocalMap {

    /**
     * The entries in this hash map extend WeakReference, using
     * its main ref field as the key (which is always a
     * ThreadLocal object).  Note that null keys (i.e. entry.get()
     * == null) mean that the key is no longer referenced, so the
     * entry can be expunged from table.  Such entries are referred to
     * as "stale entries" in the code that follows.
     */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

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

    /**
     * The table, resized as necessary.
     * table.length MUST always be a power of two.
     */
    private Entry[] table;

    /**
     * Construct a new map initially containing (firstKey, firstValue).
     * ThreadLocalMaps are constructed lazily, so we only create
     * one when we have at least one entry to put in it.
     */
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        table = new Entry[INITIAL_CAPACITY];
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
    }

    /**
     * Get the entry associated with key.  This method
     * itself handles only the fast path: a direct hit of existing
     * key. It otherwise relays to getEntryAfterMiss.  This is
     * designed to maximize performance for direct hits, in part
     * by making this method readily inlinable.
     *
     * @param  key the thread local object
     * @return the entry associated with key, or null if no such
     */
    private Entry getEntry(ThreadLocal<?> key) {
        int i = key.threadLocalHashCode & (table.length - 1);
        Entry e = table[i];
        if (e != null && e.get() == key)
            return e;
        else
            return getEntryAfterMiss(key, i, e);
    }

    /**
     * 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();
    }
}

ThreadLocalMap的key（ThreadLocal对象）为什么用弱引用

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，Entry的构造方法调用了父类WeakReference的构造方法，把k（ThreadLocal对象）传给了WeakReference的构造方法，WeakReference又调用了七父类Reference的构造方法，将k赋给了成员变量referent，也就是WeakReference关联了这个ThreadLocal对象，这里被关联的ThreadLocal对象就作为弱引用，这也就是弱引用对象的用法。那为什么要把k作为弱引用呢？

这个k是在Entry被引用的，Entry又是ThreadLocalMap的成员变量，也就是k被ThreadLocalMap引用（强引用），ThreadLocalMap是ThreadLocal的静态内部类，Thread类持有ThreadLocalMap类型的成员变量threadLocals（强引用），所以Thread对象不释放的情况下，即使我们不再使用 ThreadLocal对象了（就是k），将 k 置为 null，但k在线程的ThreadLocalMap里还有引用，导致其无法被GC回收（当然，可以等到线程运行结束后，整个Map都会被回收，但很多线程要运行很久（比如线程池的场景下，线程可能不会被释放，二是被放回池内供其他任务使用），如果等到线程结束，便会一直占着内存空间）。

public class Thread implements Runnable { 
   ...
   ThreadLocal.ThreadLocalMap threadLocals = null;
   ...
}

这里借用网上的图来说明一下ThreadLocal存在内存泄漏风险问题，从上图中可以看出，ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal不存在外部强引用时，Key(ThreadLocal)势必会被GC回收，这样就会导致ThreadLocalMap中key为null， 而value还存在着强引用（因为thread在），只有thead线程退出以后，value的强引用链条才会断掉。但如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：

Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value

永远无法回收，造成内存泄漏。

这里的弱引用可以首先由 gc 来判断 ThreadLocal 实例（userInfoLocal）是否真的可以回收，由 gc 回收的结果，间接告诉我们，key 为 null 了，这时候 value 也可以被清理了，所以，我们在使用完 ThreadLocal 变量时，尽量用threadLocal.remove()来清除，避免 threadLocal=null 的操作。 remove方法会调用Reference的clear方法将referent设置为null，然后调用expungeStaleEntry方法清除掉线程 threadLocalMap 里的 entry，算是彻底清除。

ThreadLocal最佳实践

内存泄漏应该只会存在于线程池数量较大且存储在ThreadLocal中的数据量较大时，但是手动调用 remove() 可以加快内存的释放，所以还是推荐手动调用的。