【JUC进阶】14. TransmittableThreadLocal

目录

1、前言

2、TransmittableThreadLocal

2.1、使用场景

2.2、基本使用

3、实现原理

4、小结

---

1、前言

书接上回《【JUC进阶】13. InheritableThreadLocal》，提到了InheritableThreadLocal虽然能进行父子线程的值传递，但是如果在线程池中，就无法达到预期的效果了。为了更好的解决该问题，TransmittableThreadLocal诞生了。

2、TransmittableThreadLocal

TransmittableThreadLocal 是Alibaba开源的、用于解决 “在使用线程池等会缓存线程的组件情况下传递ThreadLocal” 问题的 InheritableThreadLocal 扩展。既然是扩展，那么自然具备InheritableThreadLocal不同线程间值传递的能力。但是他也是专门为了解决InheritableThreadLocal在线程池中出现的问题的。

官网地址：https://github.com/alibaba/transmittable-thread-local

2.1、使用场景

1. 分布式跟踪系统 或 全链路压测（即链路打标）
2. 日志收集记录系统上下文
3. Session级Cache
4. 应用容器或上层框架跨应用代码给下层SDK传递信息

2.2、基本使用

我们拿《【JUC进阶】13. InheritableThreadLocal》文中最后的demo进行改造。这里需要配合TtlExecutors一起使用。这里先讲述使用方法，具体为什么下面细说。

首先，我们需要添加依赖：

    com.alibaba
    transmittable-thread-local
    2.14.2

其次，ThreadLocal的实现改为TransmittableThreadLocal。

static ThreadLocal threadLocal = new TransmittableThreadLocal<>();

最后创建线程池的时候，使用TTL装饰器：

static ExecutorService executorService = TtlExecutors.getTtlExecutorService(Executors.newSingleThreadExecutor());

完整代码如下：

// threadlocal改为TransmittableThreadLocal
static ThreadLocal threadLocal = new TransmittableThreadLocal<>();

// 线程池添加TtlExecutors
static ExecutorService executorService = TtlExecutors.getTtlExecutorService(Executors.newSingleThreadExecutor());

public static void main(String[] args) throws InterruptedException {

    //threadLocal.set("我是主线程的threadlocal变量，变量值为：000000");
    
    // 线程池执行子线程
    executorService.submit(() -> {
        System.out.println("-----> 子线程" + Thread.currentThread() + " <----- 获取threadlocal变量：" + threadLocal.get());
    });

    // 主线程睡眠3s，模拟运行
    Thread.sleep(3000);
    // 将变量修改为11111，在InheritableThreadLocal中修改是无效的
    threadLocal.set("我是主线程的threadlocal变量，变量值为：11111");

    // 这里线程池重新执行线程任务
    executorService.submit(() -> {
        System.out.println("-----> 子线程" + Thread.currentThread() + " <----- 获取threadlocal变量：" + threadLocal.get());
    });

    // 线程池关闭
    executorService.shutdown();
}

执行看下效果：

已经成功获取到threadlocal变量。

该方式也解决了因为线程被重复利用，而threadlocal重新赋值失效的问题。

3、实现原理

首先可以看到TransmittableThreadLocal继承InheritableThreadLocal，同时实现了TtlCopier接口。TtlCopier接口只提供了一个方法copy()。看到这里，可能有人大概猜出来他的实现原理了，既然实现了copy()方法，那么大概率是将父线程的变量复制一份存起来，接着找个地方存起来，然后找个适当的时机再还回去。没错，其实就是这样。

public class TransmittableThreadLocal extends InheritableThreadLocal implements TtlCopier {
}

知道了TransmittableThreadLocal类的定义之后，我们再来看一个重要的属性holder：

// Note about the holder:
// 1. holder self is a InheritableThreadLocal(a *ThreadLocal*).
// 2. The type of value in the holder is WeakHashMap, ?>.
//    2.1 but the WeakHashMap is used as a *Set*:
//        the value of WeakHashMap is *always* null, and never used.
//    2.2 WeakHashMap support *null* value.
private static final InheritableThreadLocal, ?>> holder =
        new InheritableThreadLocal, ?>>() {
            @Override
            protected WeakHashMap, ?> initialValue() {
                return new WeakHashMap<>();
            }

            @Override
            protected WeakHashMap, ?> childValue(WeakHashMap, ?> parentValue) {
                return new WeakHashMap<>(parentValue);
            }
        };

这里存放的是一个全局的WeakMap（同ThreadLocal一样，weakMap也是为了解决内存泄漏的问题），里面存放了TransmittableThreadLocal对象并且重写了initialValue和childValue方法，尤其是childValue，可以看到在即将异步时父线程的属性是直接作为初始化值赋值给子线程的本地变量对象。引入holder变量后，也就不必对外暴露Thread中的 inheritableThreadLocals，保持ThreadLocal.ThreadLocalMap的封装性。

而TransmittableThreadLocal中的get()和set()方法，都是从该holder中获取或添加该map。

重点来了，前面不是提到了需要借助于TtlExecutors.getTtlExecutorService()包装线程池才能达到效果吗？我们来看看这里做了什么事。

我们从TtlExecutors.getTtlExecutorService()方法跟进可以发现一个线程池的ttl包装类ExecutorServiceTtlWrapper。其中包含了我们执行线程的方法submit()和execute()。我们进入submit()方法：

@NonNull
@Override
public  Future submit(@NonNull Callable task) {
    return executorService.submit(TtlCallable.get(task, false, idempotent));
}

可以发现在线程池进行任务执行时，对我们提交的任务进行了一层预处理，TtlCallable.get()。TtlCallable也是Callable的装饰类，同样还有TtlRunnable，也是同样道理。我们跟进该方法偷瞄一眼：

@Nullable
@Contract(value = "null, _, _ -> null; !null, _, _ -> !null", pure = true)
public static  TtlCallable get(@Nullable Callable callable, boolean releaseTtlValueReferenceAfterCall, boolean idempotent) {
    if (callable == null) return null;

    if (callable instanceof TtlEnhanced) {
        // avoid redundant decoration, and ensure idempotency
        if (idempotent) return (TtlCallable) callable;
        else throw new IllegalStateException("Already TtlCallable!");
    }
    return new TtlCallable<>(callable, releaseTtlValueReferenceAfterCall);
}

上面判断下当前线程的类型是否已经是TtlEnhanced，如果是直接返回，否则创建一个TtlCallable。接着进入new TtlCallable()方法：

private TtlCallable(@NonNull Callable callable, boolean releaseTtlValueReferenceAfterCall) {
    this.capturedRef = new AtomicReference<>(capture());
    this.callable = callable;
    this.releaseTtlValueReferenceAfterCall = releaseTtlValueReferenceAfterCall;
}

可以看到在初始化线程的时候，调用了一个capture()方法，并将该方法得到的值存放在capturedRef中。没错，这里就是上面我们提到的将父线程的本地变量复制一份快照，存放起来。跟进capture()：

@NonNull
public static Object capture() {
    final HashMap, Object> transmittee2Value = newHashMap(transmitteeSet.size());
    for (Transmittee transmittee : transmitteeSet) {
        try {
            transmittee2Value.put(transmittee, transmittee.capture());
        } catch (Throwable t) {
            if (logger.isLoggable(Level.WARNING)) {
                logger.log(Level.WARNING, "exception when Transmitter.capture for transmittee " + transmittee +
                        "(class " + transmittee.getClass().getName() + "), just ignored; cause: " + t, t);
            }
        }
    }
    return new Snapshot(transmittee2Value);
}

这里的transmitteeSet是一个存放Transmitteedede 集合，在初始化中会将我们 前面提到的holder注册进去：

private static final Set> transmitteeSet = new CopyOnWriteArraySet<>();

static {
    registerTransmittee(ttlTransmittee);
    registerTransmittee(threadLocalTransmittee);
}

@SuppressWarnings("unchecked")
public static  boolean registerTransmittee(@NonNull Transmittee transmittee) {
    return transmitteeSet.add((Transmittee) transmittee);
}

跟进transmittee.capture()方法，该方法由静态内部类Transmitter实现并重写，com.alibaba.ttl.TransmittableThreadLocal.Transmitter.Transmittee#capture

private static final Transmittee, Object>, HashMap, Object>> ttlTransmittee =
        new Transmittee, Object>, HashMap, Object>>() {
            @NonNull
            @Override
            public HashMap, Object> capture() {
                final HashMap, Object> ttl2Value = newHashMap(holder.get().size());
                for (TransmittableThreadLocal