InheritableThreadLocal跨线程传递变量

ThreadLocal 是 Java 实现线程私有存储的一种方式，通过 ThreadLocal 可以在当前线程下线程安全的读取、修改全局的变量。
线程私有虽然保障了线程安全，但是却在某些场景下带来了麻烦，常见的在 Web 应用中利用 ThreadLocal 作为用户上下文的实现，在应用中全局传递用户的信息，如果在业务流程中存在异步执行的情况，那么在异步执行的过程中，将无法通过上下文拿不到用户信息。
想要解决上面提到的问题，就需要实现 ThreadLocal 的跨线程传递。

InheritableThreadLocal

通过 InheritableThreadLocal 可以在父子线程之间传递 ThreadLocal ，父线程为当前线程，而子线程即为在当前线程中声明的线程。如果 ThreadLocal 为 InheritableThreadLocal ，子线程就可以拿到父线程在 ThreadLocal 中设置的值。

// 在父线程中设置
InheritableThreadLocal parent = new InheritableThreadLocal();
parent.set("value-set-in-parent");
 
// =====================================================
 
// 在子线程中可以读取，值是"value-set-in-parent"
String value = parent.get();

ThreadLocal 的实现原理是在每个 Thread 实例中，都维护了一个 ThreadLocalMap 对象，而 ThreadLocal 为 key 在线程中存储值。而每个 Thread 中，其实都存储有两个 ThreadLocalMap 。

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

而 InheritableThreadLocal 只是简单的重写了几个方法：

public class InheritableThreadLocal extends ThreadLocal {
 
    protected T childValue(T parentValue) {
        return parentValue;
    }
 
    /**
     * 获取的是线程的 inheritableThreadLocals ，以 inheritableThreadLocals 作为线程私有存储的存储结构
     *
     * @param t 当前线程
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
 
    /**
     * 创建 ThreadLocalMap 并赋值到线程的 inheritableThreadLocals ，以 inheritableThreadLocals 作为线程私有存储的存储结构
     *
     * @param t 当前线程
     * @param firstValue 第一个加入到 ThreadLocalMap 的值
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

而在 Thread 的 init 方法中将会传递 InheritableThreadLocal 中的数据。

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();
    // 省略代码
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    // 省略代码
}

在使用线程池的情况下传递 ThreadLocal

虽然 InheritableThreadLocal 可以做到 ThreadLocal 的传递，但是仅限于父子线程，而大多的业务场景都是使用线程池的，InheritableThreadLocal 将难以起到作用。
在这种情况下为了传递 ThreadLocal 中的值，可能需要作出一些妥协，例如将 ThreadLocal 中需要的值取出，显式传递到任务中，显然这样是不优雅的，会让方法增加了一些与原本业务无关的参数。

而对于上述提到的情况，可以尝试使用阿里的 Transmittable ThreadLocal(TTL) 。TTL 的很简单，文档已有详细的描述，这里不过多叙述。这里简单的分析一下 TTL 的实现，以此作为 ThreadLocal 在线程池场景下传递实现的参考。

根据文档 TTL 在使用时使用类 TransmittableThreadLocal 替代 ThreadLocal ，且需要将相关的 Runnable 或是 Callable 等类进行包装。

TransmittableThreadLocal 继承了 InheritableThreadLocal ，内部维护了一个静态的 InheritableThreadLocal ，存储的是而 TransmittableThreadLocal 作为 key 的 WeakHashMap 。

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

holder 会将应用中用到的 TransmittableThreadLocal 作为 key 存储起来。调用 TransmittableThreadLocal 的 get/set 方法都会调用一个 addValue 方法，而就是在这个 addValue 方法中完成存储的过程。

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

之后想要线程私有存储实现跨线程传递，需要将 Runnable 或 Callable 包装成 TtlRunnable 、TtlCallable 。这里以 TtlRunnable 为例，在包装时，将会调用 TtlRunnable 的构造方法。

private TtlRunnable(@Nonnull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
    this.capturedRef = new AtomicReference