撸完腾讯 T4 大佬整理的 ThreadLocal 笔记，解决内存泄漏只是小儿科

上一篇是分享的是《pring Boot 中 AOP 与 SpEL》，这篇分享的是《ThreadLocal 使用与原理》。

ThreadLocal 使用与原理

在处理多线程并发安全的方法中，最常用的方法，就是使用锁，通过锁来控制多个不同线程对临界区的访问。

但是，无论是什么样的锁，乐观锁或者悲观锁，都会在并发冲突的时候对性能产生一定的影响。

那有没有一种方法，可以彻底避免竞争呢？

答案是肯定的，这就是 ThreadLocal。

从字面意思上看，ThreadLocal 可以解释成线程的局部变量，也就是说一个 ThreadLocal 的变量只有当前自身线程可以访问，别的线程都访问不了，那么自然就避免了线程竞争。

因此，ThreadLocal 提供了一种与众不同的线程安全方式，它不是在发生线程冲突时想办法解决冲突，而是彻底的避免了冲突的发生。

ThreadLocal 的基本使用

创建一个 ThreadLocal 对象：

private ThreadLocal<Integer> localInt = new ThreadLocal<>();

上述代码创建一个 localInt 变量，由于 ThreadLocal 是一个泛型类，这里指定了 localInt 的类型为整数。

下面展示了如果设置和获取这个变量的值：

public int setAndGet(){ localInt.set(8); return localInt.get(); }

上述代码设置变量的值为 8，接着取得这个值。

由于 ThreadLocal 里设置的值，只有当前线程自己看得见，这意味着你不可能通过其他线程为它初始化值。为了弥补这一点，ThreadLocal 提供了一个 withInitial()方法统一初始化所有线程的 ThreadLocal 的值：

private ThreadLocal<Integer> localInt = ThreadLocal.withInitial(() -> 6);

上述代码将 ThreadLocal 的初始值设置为 6，这对全体线程都是可见的。

ThreadLocal 的实现原理

ThreadLocal 变量只在单个线程内可见，那它是如何做到的呢？我们先从最基本的 get()方法说起：

public T get() {    //获得当前线程    Thread t = Thread.currentThread();    //每个线程 都有一个自己的ThreadLocalMap，    //ThreadLocalMap里就保存着所有的ThreadLocal变量    ThreadLocalMap map = getMap(t);    if (map != null) {        //ThreadLocalMap的key就是当前ThreadLocal对象实例，        //多个ThreadLocal变量都是放在这个map中的        ThreadLocalMap.Entry e = map.getEntry(this);        if (e != null) {            @SuppressWarnings("unchecked")            //从map里取出来的值就是我们需要的这个ThreadLocal变量            T result = (T)e.value;            return result;        }    }    // 如果map没有初始化，那么在这里初始化一下    return setInitialValue();}

可以看到，所谓的 ThreadLocal 变量就是保存在每个线程的 map 中的。这个 map 就是 Thread 对象中的 threadLocals 字段。如下：

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal.ThreadLocalMap 是一个比较特殊的 Map，它的每个 Entry 的 key 都是一个弱引用：

static class Entry extends WeakReference<ThreadLocal<?>> {    /** The value associated with this ThreadLocal. */    Object value;    //key就是一个弱引用    Entry(ThreadLocal<?> k, Object v) {        super(k);        value = v;    }}

这样设计的好处是，如果这个变量不再被其他对象使用时，可以自动回收这个 ThreadLocal 对象，避免可能的内存泄露（注意，Entry 中的 value，依然是强引用，如何回收，见下文分解）。

理解 ThreadLocal 中的内存泄漏问题

虽然 ThreadLocalMap 中的 key 是弱引用，当不存在外部强引用的时候，就会自动被回收，但是 Entry 中的 value 依然是强引用。这个 value 的引用链条如下：

可以看到，只有当 Thread 被回收时，这个 value 才有被回收的机会，否则，只要线程不退出，value 总是会存在一个强引用。但是，要求每个 Thread 都会退出，是一个极其苛刻的要求，对于线程池来说，大部分线程会一直存在在系统的整个生命周期内，那样的话，就会造成 value 对象出现泄漏的可能。处理的方法是，在 ThreadLocalMap 进行 set(),get(),remove()的时候，都会进行清理：

以 getEntry()为例：

private Entry getEntry(ThreadLocal<?> key) {    int i = key.threadLocalHashCode & (table.length - 1);    Entry e = table[i];    if (e != null && e.get() == key)        //如果找到key，直接返回        return e;    else        //如果找不到，就会尝试清理，如果你总是访问存在的key，那么这个清理永远不会进来        return getEntryAfterMiss(key, i, e);}

下面是 getEntryAfterMiss()的实现：

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {    Entry[] tab = table;    int len = tab.length;
    while (e != null) {        // 整个e是entry ，也就是一个弱引用        ThreadLocal<?> k = e.get();        //如果找到了，就返回        if (k == key)            return e;        if (k == null)            //如果key为null，说明弱引用已经被回收了            //那么就要在这里回收里面的value了            expungeStaleEntry(i);        else            //如果key不是要找的那个，那说明有hash冲突，这里是处理冲突，找下一个entry            i = nextIndex(i, len);        e = tab[i];    }    return null;}

真正用来回收 value 的是 expungeStaleEntry()方法，在 remove()和 set()方法中，都会直接或者间接调用到这个方法进行 value 的清理：

从这里可以看到，ThreadLocal 为了避免内存泄露，也算是花了一番大心思。不仅使用了弱引用维护 key，还会在每个操作上检查 key 是否被回收，进而再回收 value。

但是从中也可以看到，ThreadLocal 并不能 100%保证不发生内存泄漏。

比如，很不幸的，你的 get()方法总是访问固定几个一直存在的 ThreadLocal，那么清理动作就不会执行，如果你没有机会调用 set()和 remove()，那么这个内存泄漏依然会发生。

因此，一个良好的习惯依然是：当你不需要这个 ThreadLocal 变量时，主动调用 remove()，这样对整个系统是有好处的。

ThreadLocalMap 中的 Hash 冲突处理

ThreadLocalMap 作为一个 HashMap 和 java.util.HashMap 的实现是不同的。对于 java.util.HashMap 使用的是链表法来处理冲突：

但是，对于 ThreadLocalMap，它使用的是简单的线性探测法，如果发生了元素冲突，那么就使用下一个槽位存放：

具体来说，整个 set()的过程如下：

可以被继承的 ThreadLocal——InheritableThreadLocal

在实际开发过程中，我们可能会遇到这么一种场景。主线程开了一个子线程，但是我们希望在子线程中可以访问主线程中的 ThreadLocal 对象，也就是说有些数据需要进行父子线程间的传递。比如像这样：

public static void main(String[] args) {    ThreadLocal threadLocal = new ThreadLocal();    IntStream.range(0,10).forEach(i -> {        //每个线程的序列号，希望在子线程中能够拿到        threadLocal.set(i);        //这里来了一个子线程，我们希望可以访问上面的threadLocal        new Thread(() -> {            System.out.println(Thread.currentThread().getName() + ":" + threadLocal.get());        }).start();        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }    });}

执行上述代码，你会看到：

Thread-0:nullThread-1:nullThread-2:nullThread-3:null

因为在子线程中，是没有 threadLocal 的。如果我们希望子线可以看到父线程的 ThreadLocal，那么就可以使用 InheritableThreadLocal。顾名思义，这就是一个支持线程间父子继承的 ThreadLocal，将上述代码中的 threadLocal 使用 InheritableThreadLocal：

InheritableThreadLocal threadLocal = new InheritableThreadLocal();

再执行，就能看到：

Thread-0:0Thread-1:1Thread-2:2Thread-3:3Thread-4:4

可以看到，每个线程都可以访问到从父进程传递过来的一个数据。虽然 InheritableThreadLocal 看起来挺方便的，但是依然要注意以下几点：

1. 变量的传递是发生在线程创建的时候，如果不是新建线程，而是用了线程池里的线程，就不灵了

2. 变量的赋值就是从主线程的 map 复制到子线程，它们的 value 是同一个对象，如果这个对象本身不是线程安全的，那么就会有线程安全问题

写在最后的话

今天，我们介绍了 ThreadLocal，ThreadLocal 在 Java 的多线程开发中有着十分重要的作用。

在这里，我们介绍了 ThreadLocal 的基本使用和实现原理，尤其重点介绍了基于当前实现原理下可能存在的内存泄漏问题。

最后，还介绍了一个用于在父子线程间传递数据的特殊的 ThreadLocal 实现，希望对大家有所帮助。

• 以上就是《《ThreadLocal 使用与原理》的分享。

• 也欢迎大家交流探讨，该文章若有不正确的地方，希望大家多多包涵。

• 你们的支持就是我最大的动力，如果对大家有帮忙给个赞哦~~~