详解ThreadLocal跨线程数据共享的设计和实现

一、理解ThreadLocal

从字面含义上看，ThreadLocal即线程本地变量，可以依赖ThreadLocal保存线程私有的变量，主要实现思想是在每个线程中创建了⼀个副本，那么每个线程可以访问自己内部的副本变量。也就是说，同⼀个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。ThreadLocal主要包含以下特点：

A：每个线程都维护自己的实例副本，且该副本只能由当前线程访问；
B：每个线程有自己的实例副本，且其它线程不可访问，所以也就不存在多线程间共享的问题。

上图就是ThreadLocal的设计结构，从源码了解其设计实现原理。数据添加：

public void set(T value) {
    //1、获取当前线程
    Thread t = Thread.currentThread();
    //2、获取线程中的属性 threadLocalMap ,如果threadLocalMap 不为空，
    //则直接更新要保存的变量值，否则创建threadLocalMap，并赋值
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        // 初始化thradLocalMap 并赋值
        createMap(t, value);
}

从上⾯的代码可以看出，ThreadLocal调用set方法首先会获取当前线程和对应的ThreadLocalMap属性。如果对应的map属性不为空，则直接更新值，如果map为空，则实例化 threadLocalMap，并初始化值。

public 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;
        }
    }
}

查看ThreadLocalMap，可以发现内部通过定义继承于WeakReference的Entry来保存数据。数据获取：

public T get() {
    //1、获取当前线程
    Thread t = Thread.currentThread();
    //2、获取当前线程的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    //3、如果map数据不为空，
    if (map != null) {
        //3.1、获取threalLocalMap中存储的值
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //如果是数据为null，则初始化，初始化的结果，TheralLocalMap中存放key值为threadLocal，值为null
    return setInitialValue();
}
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

数据获取方法也很简单，通过获取当前线程，再依赖线程获取存储在ThreadLocalMap中的属性值。数据删除：

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

ThreadLocal提供remove方法用于每次用完数据后进行清除。直接将ThrealLocal 对应的值从当前线程的ThreadLocalMap中删除。如果不删除，会有内存泄漏的风险。ThreadLocal并不支持继承性，那么如何做到在父子线程之间传递呢?

二、lnheritableThreadLocal 类

先来看一段简单的代码：

public class TestThreadLocal {
    //(1)创建线程变量
    public static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) {
        //(2)赋值本地变量
        threadLocal.set("hello world");
        //(3)启动⼦线程
        new Thread(() -> {
            //(4)⼦线程输出线程变量的值
            System.out.println("⼦线程thread:" + threadLocal.get());
        }).start();
        //(5)主线程输出线程变量的值
        System.out.println("main线程:" + threadLocal.get());
    }
}

运行结果：

主线程：hello world
⼦线程: null

从运行结果可以发现，同⼀个 ThreadLocal 变量在父线程程中被设置值后，在子程中是获取不到的。主要原因是两者是不同的线程，没有上下文关系，故取不到对应的值。Jdk给我们提供了InheritableThreadLocal可实现父子线程的数据传递。

// 在⽗线程中设置
InheritableThreadLocal<String> parent = new InheritableThreadLocal<String>();
parent.set("value-set-in-parent");

// 在⼦线程中可以读取，值是"value-set-in-parent"
String value = parent.get();

要想实现跨线程数据传递，那么就需要维护线程的上下文状态。在线程中维护了两个ThreadLocalMap，分别是threadLocals和inheritableThreadLocals。

ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

InheritableThreadLocal继承了ThreadLocal，重写了其中的部分方法，查看源码发现并没有看到任何关于线程上下文信息的操作。

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    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);
    }
}

那么子线程是如何获取父线程中设置的本地变量呢？这其实是要回到线程创建本身，查看初始化线程的源码，最终调用的都是init方法。

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    this.name = name;
    // 获取当前线程
    Thread parent = currentThread();
    this.group = g;
    this.daemon = parent.isDaemon();
    this.priority = parent.getPriority();
    this.target = target;
    setPriority(priority);
    // 如果当前线程inheritableThreadLocals不为空，设置创建线程的属性
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;
    /* Set thread ID */
    tid = nextThreadID();
}

这里省略了一些参数classLoader上下文的设置。主要操作在于初始化Thread对象的时候，会获取当前线程，如果当前线程inheritableThreadLocals不为空，依赖当前线程的属性来设置新创建线程的inheritableThreadLocals，最终将父类中Entry的value赋值给到子线程。

总体上来说，InheritableThreadLocal实现跨线程数据同步主要分成三个操作：

1：继承ThreadLocal重写了Map的创建获取方法；
2：线程调用inheritableThreadLocal方法获取数据时，如果发现inheritableThreadLocal还没有初始化，那么会先执行初始化操作；
3：当线程创建新的线程时，线程初始化的时候会调用init方法将当前线程中的inheritableThreadLocal变量复制到新创建线程的inheritableThreadLocal中，从而实现跨线程数据共享。

三、TransmittableThreadLocal类

虽然inheritableThreadLocal可以做到跨线程数据共享，但是仅限于父子线程，而且是在线程初始化的时候完成复制。而在实际开发过程中，大多数的业务场景都是使用线程池来避免线程频繁创建销毁的开销，此时inheritableThreadLocal起不到作用。

阿里提供了TransmittableThreadLocal 可用于线程池之间跨线程的数据共享。TransmittableThreadLocal继承于inheritableThreadLocal，内部维护了holder用来持有线程本地变量的数据存储，主要代码如下：

private static InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>> holder = new InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>>() {
    @Override
    protected Map<TransmittableThreadLocal<?>, ?> initialValue() {
        return new WeakHashMap<>();
    }
    @Override
    protected Map<TransmittableThreadLocal<?>, ?> childValue(Map<Trans
                                                                     mittableThreadLocal<?>, ?> parentValue) {
        return new WeakHashMap<TransmittableThreadLocal<?>, Object>(pa
                rentValue);
    }
};

调用TransmittableThreadLocal的set方法的时候，最终会调用addValue方法完成对象存储，主要代码如下：

private void addValue() {
    if (!holder.get().containsKey(this)) {
        holder.get().put(this, null); // WeakHashMap supports null value.
    }
}

想要实现跨线程传递，同时还需要将线程包装成TtlRunnable（TtlCallable）。以 TtlRunnable 为例，创建线程时候会调用TtlRunnable的初始化方法，可以定义线程运行结束之后是否释放掉对应值的引用。

private TtlRunnable(@Nonnull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
    this.capturedRef = new AtomicReference<Object>(capture());
    this.runnable = runnable;
    this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
}

其中capture方法就是拷贝当前线程TransmittableThreadLocal存储的对象。而拷贝的对象属性在实际的Runnable运行之前前，会将对应的属性设置到当前线程中，从而在后续的执行过程中实现本地变量的跨线程数据同步。

public void run() {
    Object captured = capturedRef.get();
    if (captured == null || releaseTtlValueReferenceAfterRun && !capturedRef.compareAndSet(captured, null)) {
        throw new IllegalStateException("TTL value reference is released after run!");
    }
    Object backup = replay(captured);
    try {
        runnable.run();
    } finally {
        restore(backup);
    }
}

主要还是在inheritableThreadLocal的基础上，定义了holder用来维护本地变量的属性，以及封装了线程创建运行的方式，本质还是线程之间对象属性的拷贝。