ThreadLocal

ThreadLocal 与 Thread 的关系

当我们通过 ThreadLocal 实例调用 set / get 时，会先调用 Thread.currentThread，获取当前线程，在获取线程上的 ThreadLocalMap。随后哈希取模定位哈希表上的 Entry 节点，找到 Key 为自身引用的 Entry 节点进行 set / get 操作。总的来说，可以理解为 ThreadLocal 是操作 ThreadLocalMap 的一个操作类。数据本身存储在 Thread 上。

内存泄露

原因：ThreadLocalMap的Entry结点继承的WeakReference

分析：
当通过 ThreadLocal 调用 set 方法时，会将自身包装为 java.lang.ThreadLocal.ThreadLocalMap.Entry 实例中的 Key，Value 为设置的值。每次GC会回收弱引用，即回收 ThreadLocalMap 上的 Entry 节点中的 Key，即回收 ThreadLocal 实例。因为只是 Key 上的 ThreadLocal 实例被回收，但是包装该 Key 的 Entry 仍存在，导致无法通过 Key 找到对应的 Entry 节点。又因 Entry 被 ThreadLocalMap 中的 HashTable 引用，故也无法被回收。当积攒到一定程度时，从内存泄漏发展为了内存溢出。

解决方法：

1. 设置为静态常量：static final，避免GC将ThreadLocal实例回收
2. 手动remove，这样做还有另一个好处：当线程能被重复利用时，保证不会获取到以往的数据

不过仔细思考一下，只有在核心线程上才会出现这种泄露问题。如果很多线程都是临时线程，那么线程执行完毕后，ThreadLocalMap 就会被销毁，无法访问到的 Entry 节点自然也就都释放了。而且，实际上 ThreadLocal 也会偷偷的帮我们处理无法访问到的节点，具体代码在：

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
    	// Here，该方法会判断 e.key() == null。如果为 null 则清除 value & entry 节点
        return getEntryAfterMiss(key, i, e);
}

父子线程间传递线程变量

public static void main(String[] args) {
    ThreadLocal<String> local = new InheritableThreadLocal<>();
    local.set("Main");
    new Thread(() -> {
        System.out.println("Child: " + local.get());
        local.set("Child");

        new Thread(() -> {
            System.out.println("Grandchild: " + local.get());
            local.set("Grandchild");
        }, "Grandchild").start();

    }, "Child").start();
    System.out.println("Main: " + local.get());
}

打印结果：
Main: Main
Child: Main
Grandchild: Child

如果是正常的ThreadLocal，各个线程之间的线程变量是无法共享的。最终的打印结果，只有Main线程能够获取到数据。InheritableThreadLocal 可以帮助解决父子线程间传递线程变量的需求。那么是如何实现的？

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

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

public class Thread implements Runnable {

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

（init方法的inheritThreadLocals参数，如果不指定，默认为true）
线程在初始化时，会判断父线程即当前创建子线程的线程的inheritableThreadLocals是否空。若父线程使用的InheritableThreadLocal则不为空。

因为父线程首次set时会调用被重写了的getMap返回了自身的inheritableThreadLocals作为容器。
故子线程可以获取到父线程的inheritableThreadLocals来初始化自己的inheritableThreadLocals，那么就实现了子线程能够读取到父线程变量的需求。

注意，不要通过InheritableThreadLocal.withInitial的形式创建InheritableThreadLocal，原因如下：

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

static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
    private final Supplier<? extends T> supplier;
    
    SuppliedThreadLocal(Supplier<? extends T> supplier) {
        this.supplier = Objects.requireNonNull(supplier);
    }
    
    @Override
    protected T initialValue() {
        return supplier.get();
    }
}

可见，最终返回的是SuppliedThreadLocal类，而其只是重写了initialValue方法而已。

非父子线程间传递线程变量

使用阿里开源的TransmittableThreadLocal

public static void main(String[] args) throws InterruptedException {
    ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 2, 60,
            TimeUnit.SECONDS, new ArrayBlockingQueue<>(10), new NamedThreadFactory());

    TransmittableThreadLocal<String> context = new TransmittableThreadLocal<>();
    context.set("value-set-in-parent");

    CountDownLatch countDownLatch = new CountDownLatch(5);
    for (int i = 1; i <= 5; i++) {
        Runnable ttlRunnable = TtlRunnable.get(() -> {
            System.out.println(Thread.currentThread().getName() + ": " + context.get());
            context.set("value-set-in-child");
            countDownLatch.countDown();
        });
        pool.execute(ttlRunnable);
    }
    
    countDownLatch.await();
    System.out.println("Main Thread: " + context.get());
}