ThreadLocal为什么会导致内存溢出

什么是ThreadLocal

/** This class provides thread-local variables. These variables differ from

• their normal counterparts in that each thread that accesses one (via its
• {@code get} or {@code set} method) has its own, independently initialized
• copy of the variable. {@code ThreadLocal} instances are typically private
• static fields in classes that wish to associate state with a thread (e.g.,
• a user ID or Transaction ID).
  */

官方解释是This class provides thread-local variables，为线程提供本地变量。

ThreadLocal的实现本地变量原理

ThreadLocal能够为线程保存一份本地数据是由于Thread持有了 ThreadLocal.ThreadLocalMap。下面是Thread.class中的定义

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

所以ThreadLocal的核心就是ThreadLocalMap，当然他也是可能导致内存溢出的元凶，接下来我们就详细介绍下ThreadLocalMap。

ThreadLocalMap的结构

ThreadLocalMap是ThreadLocal的一个静态内部类，Map内部使用Entry（这里画圈，重点，老师会考），
进行存储。

 static class ThreadLocalMap {
        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，详细WeakReference的讲解点连接看，在这就不详细描述了。

   //下面的逻辑就是ThreadLocal的set方法
   public void set(T value) {
         //获取当前执行线程
        Thread t = Thread.currentThread();
        //获取当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null)
            //如果map不为空则直接set数据
            //entry的key是当前的ThreadLocal对象
            //而不是当前的Thread，这点不要搞错了
            map.set(this, value);
        else
            //如果没有map则创建一个map
            createMap(t, value);
    }
    
     ThreadLocalMap getMap(Thread t) {
     //返回当前线程的threadLocalMap
        return t.threadLocals;
    }
     void createMap(Thread t, T firstValue) {
       //初始化线程中的ThreadLocalMap对象
       //个人觉得这个位置命名会产生一些歧义，字面上看起来像是ThreadLocal的集合，还不如直接叫做threadLocalMap呢
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

什么会导致内存溢出呢

其实这不是一个很难的问题，无非就是线程的threadLocals放入的entry没有被及时的remove掉，这是一个坏习惯，正常我们在set后需要及时的remove掉。

其实，为了防止内存溢出，ThreadLocal也做了很多处理。看完WeakReference后大家对弱引用就有一定的了解了。当一个对象没有强引用的时候，这里指的就是ThreadLocal对象如果没有强引用，entry就会出现值为null，value存在的情况。

在ThreadLocalMap中，get和set方法都会去帮我们去删除无用的entry，并且帮我们重新排序去避免hash冲突。get和set会调用以下方法。

//命名上我们就看出来是清除无用的entry
private int expungeStaleEntry(int staleSlot) {
            Entry[] tab = table;
            int len = tab.length;

            // expunge entry at staleSlot
            tab[staleSlot].value = null;
            tab[staleSlot] = null;
            size--;

            // Rehash until we encounter null
            Entry e;
            int i;
            //这里循环遍历从节点开始staleSlot一直到为null终止
            for (i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                
                ThreadLocal<?> k = e.get();
                if (k == null) {
                //这里的这种情况就是上面所说的，key为null，value不是null。
                //这样需要把value和entry对象都设置为null来通知gc回收
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    int h = k.threadLocalHashCode & (len - 1);
                    //h != i代表当前entry是通过开放寻址获取到的下标
                    //而不是直接hash计算出来的下标
                    //这就是开放寻址法，有兴趣可以详细查询下
                    //开放寻址法大概的流程就是计算出来你应该在3位置，但是3位置被占用了，就会从3顺序向下寻找一个不为null的位置占下
                    if (h != i) {
                    
                        tab[i] = null;

                        // Unlike Knuth 6.4 Algorithm R, we must scan until
                        // null because multiple entries could have been stale.
                        //下面的逻辑是通过hash值重新计算entry下标
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            return i;
        }

但是假如你的线程会持续很久，例如是线程池的核心线程，使用ThreadLocal之后没有remove掉，如果在这时你的threadlocal对象也一直存在的话，那么threadLocal的get和set帮我们做的优化——清除key为null的entry，就没用了，积累的对象越来越多无法被回收，就内存溢出了。
所以最重要的是我们使用完一定要及时的remove。