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

黑夜无路人

已于 2023-07-14 18:19:10 修改

阅读量304

点赞数

分类专栏： java基础文章标签： java ThreadLocal内存泄露

于 2023-07-14 17:42:27 首次发布

本文链接：https://blog.csdn.net/SO_zxn/article/details/131727363

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

文章目录

内存泄露案例
源码分析
- ThreadLocal.set方法
什么情况会出现内存泄露
如何防止
总结

为什么会写这篇文章呢？也许大家在网上都看到很多关于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<BigObject> 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<ThreadLocal<?>> {
            /** 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<ThreadLocal<?>>）。ThreadLocalMap的Entry类是继承自WeakReference

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

在这里插入图片描述