从 TL、ITL 到 TTL | 京东云技术团队

1、概述

ThreadLocal（TL）是Java中一种线程局部变量实现机制，他为每个线程提供一个单独的变量副本，保证多线程场景下，变量的线程安全。经常用于代替参数的显式传递。

InheritableThreadLocal（ITL）是JDK提供的TL增强版，而TransmittableThreadLocal（TTL）是阿里开源的ITL增强版

这些ThreadLocal在不同场景下有不同用途，我们来分析一下：

2、ThreadLocal

ThreadLocal主要的方法有四个：initialValue、set、get、remove

2.1、初始化——initialValule

当线程首次访问该ThreadLocal时（ThreadLocal.get()），会进行初始化赋值。我们常用两种方法初始化ThreadLocal

2.1.1、重写initialValue

ThreadLocal threadLocal = new ThreadLocal() {
    @Override
    protected String initialValue() {
        return "";
    }
};

2.1.2、调用ThreadLocal.withInitial

ThreadLocal threadLocal = ThreadLocal.withInitial(() -> "");

他会创建一个SuppliedThreadLocal内部类

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

该类重写了initialValue方法

static final class SuppliedThreadLocal extends ThreadLocal {

    private final Supplier supplier;

    SuppliedThreadLocal(Supplier supplier) {
        this.supplier = Objects.requireNonNull(supplier);
    }

    @Override
    protected T initialValue() {
        //当该线程首次访问ThreadLocal时，会间接调用lambda表达式初始化
        return supplier.get();
    }
}

⚠️ITL并没有重新实现withInitial，如果使用withInitial则会创建STL，失去自己增强的特性

2.2、赋值——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);
}

这里出现了一个关键属性ThreadLocalMap，类定义在ThreadLocal中，是Thread的成员变量

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

ThreadLocalMap内部还有一个内部类Entry，是存值的地方

static class ThreadLocalMap {
    static class Entry extends WeakReference> {
        Object value;
        Entry(ThreadLocal k, Object v) {
            //ThreadLocal的引用是“key”
            super(k);
            //线程局部变量是value
            value = v;
        }
    }
    //Entry数组
    //value具体放在哪个index下，是由ThreadLocal的hashCode算出来的
    private Entry[] table;
}

2.3、取值——get

public T get() {
    Thread t = Thread.currentThread();
    //1、获取线程的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //2、根据ThreadLocal的hashCode，获取对应Entry下的value
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //3、如果没有赋过值，则初始化
    return setInitialValue();
}

2.4、清空——remove

 public void remove() {
     ThreadLocalMap m = getMap(Thread.currentThread());
     if (m != null)
         //会将对应Entry、包括他的key、value手动置null
         m.remove(this);
 }

3、InheritableThreadLocal

3.1、TL在父子线程场景下存在的问题

我们先来看一个例子

public static void main(String[] args) throws InterruptedException {
    ThreadLocal threadLocal = ThreadLocal.withInitial(() -> "A");
    threadLocal.set("B");
    Thread thread = new Thread(() -> {
        System.out.println("子线程ThreadLocal：" + threadLocal.get());
    }, "子线程");
    thread.start();
    thread.join();
}

打印结果如下，可见子线程的ThreadLocal是初始值，并没有使用父线程修改后的值：

子线程ThreadLocal：A

线程的ThreadLocalMap是首次访问时创建的，所以子线程使用ThreadLocal的时候，会初始化一个新的ThreadLocal，线程局部变量为默认值

⚠️所以，TL不具有遗传性

3.2、ITL的解决方案

为了解决TL子线程遗传性的问题，JDK引入了ITL

他继承ThreadLocal，重写了childValue、getMap、createMap三个方法

public class InheritableThreadLocal extends ThreadLocal {

    protected T childValue(T parentValue) {
        return parentValue;
    }

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

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

这里出现了inheritableThreadLocals，他存储的就是从父线程拷贝过来的ThreadLocal，这个值是在父线程首次修改ThreadLocal的时候赋值的，然后在子线程创建时拷贝过来的

//父线程部分：
public void set(T value) {
    Thread t = Thread.currentThread();
    //该方法被ITL重写，访问inheritableThreadLocals为null
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
    //该方法同样被ITL重写，创建一个ThreadLocalMap赋值给inheritableThreadLocals
        createMap(t, value);
}

//子线程部分：
public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
    //省略一些代码...

    //获取当前线程（父线程、也就是创建子线程的线程）
    Thread parent = currentThread();
    //1、允许ThreadLocal遗传（这个默认为true）
    //2、inheritableThreadLocals不为空，因为父线程调用set了
    //父线程不调用set，那ThreadLocal就是初始值，那直接初始化就好了，也不用进该分支
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
}

//createInheritedMap使用该构造函数，根据父线程的inheritableThreadLocals进行深拷贝
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];
    //深拷贝父线程ThreadLocalMap
    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal