鹅厂一面，有关 ThreadLocal 的一切

1. 底层结构

ThreadLocal 底层有一个默认容量为 16 的数组组成，k 是 ThreadLocal 对象的引用，v 是要放到 TheadLocal 的值

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

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}

数组类似为 HashMap，对哈希冲突的处理不是用链表/红黑树处理，而是使用链地址法，即尝试顺序放到哈希冲突下标的下一个下标位置。

该数组也可以进行扩容。

2. 工作原理

一个 ThreadLocal 对象维护一个 ThreadLocalMap 内部类对象，ThreadLocalMap 对象才是存储键值的地方。

更准确的说，是 ThreadLocalMap 的 Entry 内部类是存储键值的地方

见源码 set(),createMap() 可知。

因为一个 Thread 对象维护了一个 ThreadLocal.ThreadLocalMap 成员变量，且 ThreadLocal 设置值时，获取的 ThreadLocalMap 正是当前线程对象的 ThreadLocalMap。

// 获取 ThreadLocalMap 源码
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

所以每个线程对 ThreadLocal 的操作互不干扰，即 ThreadLocal 能实现线程隔离

3. 使用

ThreadLocal<String> threadLocal = new ThreadLocal<>();
threadLocal.set("七淅在学Java");
Integer i = threadLocal.get()
// i = 七淅在学Java

4. 为什么 ThreadLocal.ThreadLocalMap 底层是长度 16 的数组呢？

对 ThreadLocal 的操作见第 3 点，可以看到 ThreadLocal 每次 set 方法都是对同个 key（因为是同个 ThreadLocal 对象，所以 key 肯定都是一样的）进行操作。

如此操作，看似对 ThreadLocal 的操作永远只会存 1 个值，那用长度为 1 的数组它不香吗？为什么还要用 16 长度呢？

好了，其实这里有个需要注意的地方，ThreadLocal 是可以存多个值的

那怎么存多个值呢？看如下代码：

// 在主线程执行以下代码：
ThreadLocal<String> threadLocal = new ThreadLocal<>();
threadLocal.set("七淅在学Java");
ThreadLocal<String> threadLocal2 = new ThreadLocal<>();
threadLocal2.set("七淅在学Java2");

按代码执行后，看着是 new 了 2 个 ThreadLocal 对象，但实际上，数据的存储都是在同一个 ThreadLocal.ThreadLocalMap 上操作的

再次强调：ThreadLocal.ThreadLocalMap 才是数据存取的地方，ThreadLocal 只是 api 调用入口）。真相在 ThreadLocal 类源码的 getMap()

因此上述代码最终结果就是一个 ThreadLocalMap 存了 2 个不同 ThreadLocal 对象作为 key，对应 value 为 七淅在学Java、七淅在学Java2。

我们再看下 ThreadLocal 的 set 方法

public void set(T value) {
    Thread t = Thread.currentThread();
    // 这里每次 set 之前，都会调用 getMap(t) 方法，t 是当前调用 set 方法的线程
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

// 重点：返回调用 set 方法的线程（例子是主线程）的 ThreadLocal 对象。  
// 所以不管 api 调用方 new 多少个 ThreadLocal 对象，它永远都是返回调用线程（例子是主线程）的 ThreadLocal.ThreadLocalMap 对象供调用线程去存取数据。
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

// t.threadLocals 的声明如下
ThreadLocal.ThreadLocalMap threadLocals = null;

// 仅有一个构造方法
public ThreadLocal() {
}

5. 数据存放在数组中，那如何解决 hash 冲突问题

使用链地址法解决。

具体怎么解决呢？看看执行 get、set 方法的时候：

• set：
• 且数组的 key 等于该 ThreadLocal，则覆盖该位置元素
• 否则就找下一个空位置，直到找到空或者 key 相等为止。
• 根据 ThreadLocal 对象的 hash 值，定位到 ThreadLocalMap 数组中的位置。
• 如果位置无元素则直接放到该位置
• 如果有元素
• get：
• 根据 ThreadLocal 对象的 hash 值，定位到 ThreadLocalMap 数组中的位置。
• 如果不一致，就判断下一个位置
• 否则则直接取出

// 数组元素结构
Entry(ThreadLocal<?> k, Object v) {
    super(k);
    value = v;
}

6. ThreadLocal 的内存泄露隐患

三个前置知识：

• ThreadLocal 对象维护一个 ThreadLocalMap 内部类
• ThreadLocalMap 对象又维护一个 Entry 内部类，并且该类继承弱引用 WeakReference<ThreadLocal<?>>，用来存放作为 key 的 ThreadLocal 对象（可见最下方的 Entry 构造方法源码），可见最后的源码部分。
• 不管当前内存空间足够与否，GC 时 JVM 会回收弱引用的内存

因为 ThreadLocal 作为弱引用被 Entry 中的 Key 变量引用，所以如果 ThreadLocal 没有外部强引用来引用它，那么 ThreadLocal 会在下次 JVM 垃圾收集时被回收。

这个时候 Entry 中的 key 已经被回收，但 value 因为是强引用，所以不会被垃圾收集器回收。这样 ThreadLocal 的线程如果一直持续运行，value 就一直得不到回收，导致发生内存泄露。

如果想要避免内存泄漏，可以使用 ThreadLocal 对象的 remove() 方法

7. 为什么 ThreadLocalMap 的 key 是弱引用

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

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

为什么要这样设计，这样分为两种情况来讨论：

• key 使用强引用：只有创建 ThreadLocal 的线程还在运行，那么 ThreadLocalMap 的键值就都会内存泄漏，因为 ThreadLocalMap 的生命周期同创建它的 Thread 对象。
• key 使用弱引用：是一种挽救措施，起码弱引用的值可以被及时 GC，减轻内存泄漏。另外，即使没有手动删除，作为键的 ThreadLocal 也会被回收。因为 ThreadLocalMap 调用 set、get、remove 时，都会先判断之前该 value 对应的 key 是否和当前调用的 key 相等。如果不相等，说明之前的 key 已经被回收了，此时 value 也会被回收。因此 key 使用弱引用是最优的解决方案。

8. 父子线程如何共享 ThreadLocal 数据

1. 主线程创建 InheritableThreadLocal 对象时，会为 t.inheritableThreadLocals 变量创建 ThreadLocalMap，使其初始化。其中 t 是当前线程，即主线程
2. 创建子线程时，在 Thread 的构造方法，会检查其父线程的 inheritableThreadLocals 是否为 null。从第 1 步可知不为 null，接着 将父线程的 inheritableThreadLocals 变量值复制给这个子线程。
3. InheritableThreadLocal 重写了 getMap, createMap, 使用的都是 Thread.inheritableThreadLocals 变量

如下：

public class InheritableThreadLocal<T> extends ThreadLocal<T> 

第 1 步：对 InheritableThreadLocal 初始化
public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

第 2 步：创建子线程时，判断父线程的 inheritableThreadLocals 是否为空。非空进行复制
// Thread 构造方法中，一定会执行下面逻辑
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
    this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

第 3 步：使用对象为第 1 步创建的 inheritableThreadLocals 对象
public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
}

// 示例：
// 结果：能够输出「父线程-七淅在学Java」
ThreadLocal threadLocal = new InheritableThreadLocal();
threadLocal.set("父线程-七淅在学Java");
Thread t = new Thread(() -> System.out.println(threadLocal.get()));
t.start();

// 结果：null，不能够输出「子线程-七淅在学Java」
ThreadLocal threadLocal2 = new InheritableThreadLocal();
Thread t2 = new Thread(() -> {
    threadLocal2.set("子线程-七淅在学Java");
});
t2.start();
System.out.println(threadLocal2.get());