使用 ThreadLocal 时一定会出现内存泄露吗？什么情况在会出现？如何防止？

为什么会写这篇文章呢？也许大家在网上都看到很多关于ThreadLocal内存泄露的文章，很多写的都是错误的，说什么因为弱引用的原因导致无法回收，我一开始也是被这个误导的。所以今天通过源码来分析下ThreadLocal什么情况下出现内存泄露？如何防止内存泄露?

为了说明上面的问题，首先我们从一段代码来分析是否会出现内存泄露，然后跟着源码进去分析为何可能出现内存泄露，最终根据源码说明如何防止内存泄露

内存泄露案例

public class ThreadLocalDemo {
    private static final ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 5, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>());
    
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 100; ++i) {
            poolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    ThreadLocal threadLocal = new ThreadLocal<>();
                    // BigObject对象只是临时变量，该线程执行结束后就不需要了
                    threadLocal.set(new BigObject());
                    // 其他业务代码，这里不会进行手动的 threadLocal.remove()
                }
            });
            Thread.sleep(1000);
        }
    }
    static class BigObject {
        // 100M
        private byte[] bytes = new byte[100 * 1024 * 1024];
    }
}

代码分析：

• 创建一个核心线程数和最大线程数都为10的线程池，保证线程池里一直会有10个线程在运行。

• 使用for循环向线程池中提交了100个任务。

• 定义了一个ThreadLocal类型的变量，value类型是大对象。

• 每个任务会向threadLocal变量里塞一个大对象，然后执行其他业务逻辑。

• 由于没有调用线程池进行回收，线程池里的线程还是会存活着。

源码分析

ThreadLocal.set方法

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


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

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


/**
         * 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> {
            /** The value associated with this ThreadLocal. */
            Object value;

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

源码分析：

• 对于 set 方法，内部逻辑会先获取当前执行的线程（Thread t = Thread.currentThread();）

• 从当前线程获取 ThreadLocalMap 对象。（getMap(t);）进入 Thread 类，会发现原来 Thread 里面引用到了 ThreadLocalMap，也就是说其实 ThreadLocalMap 对象是存储在 Thread 对象内的。

• 判断ThreadLocalMap对象实例是否存在

• ThreadLocalMap对象实例存在则将 value 放入 ThreadLocalMap对象实例

• ThreadLocalMap对象实例存在则先创建 ThreadLocalMap对象 然后将 value 放入 ThreadLocalMap对象实例。

• 在进行存储时会将 ThreadLocal作为 key 存入 ThreadLocalMap 中，并且 key 是一个弱引用（因为Entry extends WeakReference>）。ThreadLocalMap的Entry类是继承自WeakReference

以上是大致的源码，通过以上的源码大致可以得出 ThreadLocalMap、ThreadLocal、ThreadLocal之间的关系。

所以如果出现内存不足时会对 key 进行回收（弱引用的对象，在出现 GC 时会被回收），但是 value 并不会被回收，所以就出现了内存泄露。

什么情况会出现内存泄露

从上面的分析可以知道，在 ThreadLocalMap 被强引用时，并且存储了的临时对象很多导致 gc 时由于存储的对象无法被回收就会出现内存泄露。

如何防止

要打破上面的条件可以通过以下措施：

1、让 ThreadLocalMap 不被引用，也就是案例中线程池使用完后进行回收。

2、ThreadLocalMap中的 value 也使用弱引用，这样 gc 时就能把它们进行回收

3、value 不需要时及时使用 remove 进行手动回收(最好的方式)

总结

使用 ThreadLocal 时出现内存泄露，归根还是因为 ThreadLocalMap 存储的临时数据不需要时没被手动回收，并且 ThreadLocalMap 一直被强引用。