ThreadLocal原理

参考：https://juejin.im/post/5a5efb1b518825732b19dca4
  ThreadLocal用于提供线程级的全局变量，所谓线程级的全局变量意思就是这个变量只在当前线程内部是任意位置都可以获取到的，所以有部分同学就会用它来进行一些线程内的传参。
  实际对于ThreadLocal而言，它的实现原理较为简单，就是每个线程在new Thread()创建的时候，内部都会自带有一个ThreadLocal.ThreadLocalMap对象，如下：

--> Thread.java
/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

  然后，我们在使用ThreadLocal的时候，语法为：

ThreadLocal<String> s = new ThreadLocal<>();
s.set("threadlocal");

  这里，我们看ThreadLocal的set方法实现如下：

--> ThreadLocal.java
public void set(T value) {
        Thread t = Thread.currentThread(); // 获取当前执行线程对象
        ThreadLocalMap map = getMap(t); // 获取当前线程对象的map容器
        if (map != null)
            map.set(this, value); // ThreadLocal变量自身作为key，设置的value值作为map中的value
        else
            createMap(t, value);
    }

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

  那么这里很显然，每个ThreadLocal对象其实只是一个个作为线程内部ThreadLocalMap对象的key，然后设置的值作为value存储到Map容器对象中，由于这个ThreadLocalMap对象是和线程绑定的，所以从而实现了所谓的线程全局变量。
  我们再来看看ThreadLocalMap的结构，如下：

--> ThreadLocal.ThreadLocalMap  内部类

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;
            }
        }
private static final int INITIAL_CAPACITY = 16;
private Entry[] table;

  这里很显然，这个实现和我们之前了解的各种HashMap是十分类似的，只不过这里需要注意一点的是，这个Map中存储的Entry结构是弱引用的，所以这里需要注意的就是我们在把ThreadLocal变量放进来的时候，这里的Entry和ThreadLocal变量之间是弱引用的关系，所以有可能出现ThreadLocal被GC回收的情况，这时候就会出现对应key为null的情况，我们来看看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); // 获取hash值

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

private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

  这其中注意到set的时候会遍历整个table数组，如果找到了ThreadLocal对应的数据，则进行更新；如果中间发现某个槽位的key==null，则调用replaceStaleEntry方法，这个方法的含义就是清理key为null的过期数据。
  我们在日常使用ThreadLocal变量的时候，需要注意的就是使用完毕之后，最好随手用try/finally在finally中调用remove清除ThreadLocal中数据，尤其是在线程池中如果用ThreadLocal变量，如果不清理数据，由于线程池中所有连接可能会一直存在，不清理就会导致map中的数据越来越多，最终结果就是出现内存泄漏。