八、ThreadLocal - 《Java 并发编程教程》

1、类图结构
2、构造方法
3、属性
4、方法
5、InheritableThreadLocal
- 5.1、类图结构
- 5.2、源码
6、内存泄漏分析
7、总结

1、类图结构

只要线程处于活动状态并且可以访问 ThreadLocal 实例，每个线程都持有对其线程局部变量副本的隐式引用；线程终止后，它的所有线程本地实例副本都将会被垃圾回收（除非存在对这些副本的其他引用），类图如下。

Thread 类中有一个 threadLocals 和一个 inheritableThreadLocals，均是 ThreadLocal.ThreadLocalMap 类型的变量。ThreadLocalMap 有自己独立的实现，可以简单的将它的 key 是作为 ThreadLocal，value 为代码中放入的值。默认情况下，每个线程中的这两个变量都为 null，只有当前线程第一调用 ThreadLocalMap 的 set 或 get 方法时才会创建它们。其实每个线程的本地变量不是存放在 ThreadLocal 实例里面的，而是存放在调用线程的 threadLocals 变量里的面。也就是说，ThreadLocal 类型的本地变量存放在具体的线程内存中，从而实现了现成的隔离。

ThreadLocal 就是一个工具，它通过 set 方法把 value 值放入调用线程的 threadLocals 中存储起来。如果调用线程一直不终止，那么这个变量会一直存放在调用线程的 threadLocals 中，所以当不需要使用本地变量时，需要调用 ThreadLocal 的 remove 方法，从当前线程的 threadLocals 中删除该本地变量。

2、构造方法

ThreadLocal 只提供了一个无参构造，创建 ThreadLocal 变量。

public ThreadLocal() {
}

3、属性

其中 threadLocalHashCode 是 final 修饰的变量，在 ThreadLocal 被创建的时候就会调用 nextHashCode 方法初始化，每调用一次 threadLocalHashCode 就会增加 HASH_INCREMENT = 0x61c88647，0x61c88647 的十进制为 1640531527。

// 用于计算 ThreadLocalMap 的桶的 hash 值
private final int threadLocalHashCode = nextHashCode();
// 从 0 开始
private static AtomicInteger nextHashCode = new AtomicInteger();
// 0x61c88647 = 1640531527，近似等于 ~(2^32 * 0.618) + 0b1
// 每次当前线程的 nextHashCode 增加的魔法值
private static final int HASH_INCREMENT = 0x61c88647;

下面的代码过程演示了，0x61c88647 和斐波那契散的关系，当我们用 0x61c88647 作为魔数累加为每个 ThreadLocalMap 分配各自的 threadLocalHashCode，再与 2 的幂次方，得到的结果分布很均匀。ThreadLocalMap 使用的是线性探测法，均匀分布的好处在于很快就能探测到下一个临近的可用 slot，从而保证效率。这就是为什么 table 数组的长度必须是 2 的幂次方原因，为了优化探测效率。

// 黄金分割数* 2^32 = 0.618 * 2^32
long lg = (long) ((1L << 32) * ((Math.sqrt(5) - 1) / 2));
// 32位无符号整数
System.out.println("as 32 bit unsigned: " + lg);
int it = (int) lg;
// 32位有符号整数
System.out.println("as 32 bit signed:   " + it);
System.out.println("MAGIC = " + 0x61c88647);
=====================执行结果=====================
as 32 bit unsigned: 2654435769
as 32 bit signed:   -1640531527
MAGIC = 1640531527

4、方法

4.1、nextHashCode

该方法主要用于：当前线程的 nextHashCode 与魔法值 HASH_INCREMENT 相加。每调用一次该方法，当前线程的 nextHashCode 就会加一次 HASH_INCREMENT。

private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

4.2、initialValue

该方法为 ThreadLocal 要保存的数据类型指定一个初始值，在 ThreadLocal 中默认返回 null，我们可以通过重新该方法进行数据的初始化。该方法会在 get 和 set 方法调用。JDK8 提供的 Supplier 函数接口会更加简化。

protected T initialValue() {
    return null;
}

4.3、withInitial

JDK8 中提供的 Supplier 函数接口的方法

public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
    return new SuppliedThreadLocal<>(supplier);
}

4.4、get

该方法用于返回当前线程在 ThreadLocal 中的数据备份，当前线程的数据都存放在一个成为 ThreadLocalMap 的数据结构中。

public T get() {
    Thread t = Thread.currentThread();
    // 从 ThreadLocal 中获取当前线程的 ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    // 从 map 中获取当前线程运行过程中的备份
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 判断 entry 是否无效
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            // 如果有效，则返回 e.value
            return result;
        }
    }
    // 返回之后，重新将 ThreadLocalMap 设置为 initValue 方法返回的值
    return setInitialValue();
}

4.5、setInitialValue

设置当前线程 ThreadLocal 的 ThreadLocalMap 的初始值，数据的初始值是 initialValue 方法返回的结果。

private T setInitialValue() {
    // 获取初始化值
    T value = initialValue();
    Thread t = Thread.currentThread();
    // 获取当前线程的 ThreadLocalMap
    // 如果是父线程则返回 Thread.threadLocals
    // 如果非父线程则返回 Thread.inheritableThreadLocals
    ThreadLocalMap map = getMap(t);
    // 如果不为空，直接设置初始值
    if (map != null)
        map.set(this, value);
    // map 为空，则创建一个新的 ThreadLocalMap
    else
        createMap(t, value);
    return value;
}

4.6、set

该方法主要是为了 ThreadLocal 指定将要被存储的数据，如果重写了 initialValue 方法，在未调用 set 方法的时候，数据的初始值是 initialValue 方法返回的结果。

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

4.7、remove

移除此线程 ThreadLocalMap 中当前线程的值

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

4.8、getMap

获取与 ThreadLocal 关联的映射，该方法在 InheritableThreadLocal 中重写。

ThreadLocalMap getMap(Thread t) {
    // 直接返回线程 t 的 threadLocals
    return t.threadLocals;
}

4.9、createMap

创建与 ThreadLocal 关联的映射，该方法在 InheritableThreadLocal 中重写。

void createMap(Thread t, T firstValue) {
    // 调用构造方法构建线程 t 的 ThreadLocalMap
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

4.10、createInheritedMap

该方法主要就是以父线程的 inheritableThreadLocals 为数据源，过滤出有效的 entry，初始化到自己的 threadLocals 中。其中 childValue 可以被重写。

需要注意的地方是 InheritableThreadLocal 只是在子线程创建的时候会去拷一份父线程的 inheritableThreadLocals。如果父线程是在子线程创建后再 set 某个 InheritableThreadLocal 对象的值，对子线程是不可见的。

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
}

4.11、childValue

该方法是在子类 InheritableThreadLocal 中实现的，但是在这里内部定义是为了提供给 createInheritedMap 工厂方法使用的。

T childValue(T parentValue) {
    throw new UnsupportedOperationException();
}

5、InheritableThreadLocal

同一个 ThreadLocal 变量在父线程 pT 中被设置值后，在子线程中是获取不到的。因为子线程 subT 里面调用 get 方法时，当前线程是 subT 线程；而父线程 pT 调用 set 方法设置线程变量的是 pT 线程，两者不是同一个线程。所以子线程无法获取到父线程的 threadLocals 中存放的本地变量。可以通过 InheritableThreadLocal 类来解决这个问题。

5.1、类图结构

InheritableThreadLocal 继承自 ThreadLocal，类图如下。其提供了一个特性，就是让子线程可以访问父线程中设置的本地变量。

5.2、源码

从下面的源码可以看出，InheritableThreadLocal 继承了 ThreadLocal，并重写了三个方法。这个三个方法实现了在 InheritableThreadLocal 中，线程的变量 inheritableThreadLocals 代替了 threadLocals。

createMap 方法，当第一调用 set 方法时，创建的是当前线程的 inheritableThreadLocals 变量的实例而不再是 threadLocals。getMap 方法，当调用 get 方法获取当前线程内部的 map 变量时，获取的是 inheritableThreadLocals 而不再是 threadLocals。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    // 计算此可继承线程局部变量的子级初始值，作为创建子线程时父级值的函数。 
    // 在启动子线程之前，从父线程内部调用此方法。
    // 此方法仅返回其输入参数，如果需要不同的行为，则应覆盖该方法。
    protected T childValue(T parentValue) {
        return parentValue;
    }
    // 获取与 ThreadLocal 关联的映射
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
    // 创建与 ThreadLocal 关联的映射
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

�childValue 方法何时执行，以及如何让子线程可以访问父线程的本地变量？这要从创建 Thread 开始看起，下面是创建 Thread 类的源码。

在创建线程时，构造函数会调用 init 方法，对线程进行初始化。代码 23 行会先判断父线程的 inheritableThreadLocals 是否为 null？如果不为 null 的话，这里会直接调用 ThreadLocal 的 createInheritedMap 方法创建一个新的 ThreadLocalMap 实例，然后赋值给子线程的 inheritableThreadLocals 属性。childValue 最终会在 ThreadLocalMap 的构造函数中被调用，在改构造函数中会把父线程的 inheritableThreadLocals 属性的值赋值到新的 ThreadLocalMap 实例中。

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}
private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}
private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }
    this.name = name;
    // 获取当前线程
    Thread parent = currentThread();
    ...
    // 如果是父线程的 inheritableThreadLocals 不为 null
    // 设置子线程的 inheritableThreadLocals
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
        ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    ...
}

6、内存泄漏分析

ThreadLocal 会引起内存泄漏原因是，如果一个线程的 ThreadLocal 对象被回收了，我们之前保存的 value 对于当前线程是可达的，如图所示，Current Thread Ref -> Thread -> ThreadLocalMap -> Entry.value 的一条强引用链时可达的，因此 value 不会被回收。

内存泄漏和内存溢出是有区别的，内存泄漏是导致内存溢出的原因之一。但两者并不是完全等价的，内存泄漏更多的是程序不再持有某个对象的引用，但是该对象仍然无法别垃圾回收器回收。原因是该对象的引用根 root 的链路是可达的，比如 Current Thread Ref 到 Entry.value 的引用链路

认为 ThreadLocal 不会引起内存泄漏的原因是 Thread.ThreadLocalMap 源码实现中自带一套自我清理的机制。之所以有关于内存泄漏的讨论，是因为在有线程复用的场景中，一个线程的寿命很长，此时大对象长期不被回收可能会影响系统运行效率和安全，如线程池。如果线程不会复用，用完立即销毁了，不会有 ThreadLocal 引发内存泄漏的问题。

7、总结

ThreadLocal 不是用来解决线程安全问题的，多线程不同享，不存在竞争问题。目的是线程本地变量只能单个线程维护使用。在使用 ThreadLocal 的过程中，防止内存泄漏最好的方法就是结束时调用其 remove 清理 ThreadLocal 中的无效 Entry。比如：对于一个请求一个线程的 tomcat 中，在代码中对 web api 做一个切面，存放一些用户信息，在连接点方法结束后，再显式调用 remove 进行无效 Entry 清理。

InheritableThreadLocal 类通过重写 ThreadLocal 的 creatMap 和 getMap 方法，实现了让本地变量保存到具体线程的 inheritableThreadLocals 属性中。此时线程通过 InheritableThreadLocal 实例的 set 或 get 方法设置变量时，就会设置当前线程的 inheritableThreadLocals 属性。当父线程创建子线时，构造函数会把父线程中 inheritableThreadLocals 属性中的本地变量值复制一份保存到子线程的 inheritableThreadLocals 属性中。