Java面试之ThreadLocal及其内存泄露

什么是ThreadLocal

ThreadLocal提供了线程的局部变量，每个线程都可以通过set()和get()来对这个局部变量进行操作，但不会和其他线程的局部变量进行冲突，实现了线程的数据隔离

ThreadLocal的简单使用

package com.mxx;

import java.util.concurrent.TimeUnit;

public class ThreadLocalTest {

    public static void main(String[] args) {
        ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
        new ThreadLocal<Integer>();
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(()->{
                threadLocal.set(finalI);
                // 暂停一秒。保证local值全部set完
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("线程"+Thread.currentThread().getName()+"\tlocal值="+threadLocal.get());

            },"线程"+i).start();
        }
    }
}
/*
线程线程0	local值=0
线程线程2	local值=2
线程线程3	local值=3
线程线程1	local值=1
线程线程4	local值=4
*/

由此可见，ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的

ThreadLocal应用场景

1、管理Connection数据库连接池

​ 实现当前线程操作的都是同一个Connection对象，保证了事务

2、避免参数传递，在线程内部任何地方都可以使用，存取方便

ThreadLocal内部原理

ThreadLocal set()方法

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocal实际使用ThreadLocalMap来存储变量

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;
        }
    }
    // ...
    
    private void set(ThreadLocal<?> key, Object value) {
			// ...
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }
}

ThreadLocal 在set方法中使用getMap(t)获取ThreadLocalMap

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

ThreadLocalMap变量是Thread类维护的

ThreadLocal.ThreadLocalMap threadLocals = null;

1、set方法获取当前线程的ThreadLocalMap，将ThreadLocal对象本身作为key，要存的变量作为value存入map中

2、ThreadLocalMap是ThreadLocal的内部类，用Entry类来进行存储，但ThreadLocalMap对象的引用是在Thread中

3、总结：Thread为每个线程维护了ThreadLocalMap这么一个Map，而ThreadLocalMap的key是ThreadLocal对象本身，value则是要存储的对象

ThreadLocal get()，同理

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

ThreadLocal原理总结

1. 每个Thread维护着一个ThreadLocalMap的引用
2. ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储
3. 调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值是传递进来的对象
4. 调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象
5. ThreadLocal本身并不存储值，它只是作为一个key来让线程从ThreadLocalMap获取value。

正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响～

ThreadLocal之内存泄漏

简单区分：

• 内存溢出：OOM
• 内存泄露：无法GC

如何导致的？

ThreadLocal通过Entry保存变量，key为ThreadLocal的弱引用。

当ThreadLocal没有外部强引用时，此时系统GC就会导致ThreadLocal回收，因此Entry里key为null，无法访问value。

若当前线程不结束，value的强引用链就一直存在。Thread -> ThreadLocalMap -> Entry -> value，value无法回收，造成内存泄露。

因为ThreadLocalMap和Thead生命周期一样长，当前线程不结束，就不会回收。

static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;

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

为何使用弱引用？

1、假设ThreadLocal是强引用

此时若没有了外部引用，但ThreadLocal被ThreadLocalMap的Entry强引用，导致ThreadLocal无法被GC，存在以下强引用链：

Thread > ThreadLocalMap -> Entry -> TheadLocal

就算调用remove方法释放value，Entry 的key TheadLocal 也不会释放，因此导致Entry内存泄露

2、假设使用弱引用

ThreadLocal会被回收，value在调用remove时被回收。

如何避免？

1、用static修饰 ，static ThreadLocal，延长ThreadLocal生命周期，避免ThreadLocal强引用丢失而被回收

2、每次使用完ThreadLocal，都调用remove()方法，清除数据

参考：

https://juejin.im/post/5ac2eb52518825555e5e06ee

https://www.jianshu.com/p/1342a879f523