1、问题
通常复杂的处理流程中，我们会使用一些异步处理的手段，那么这种场景下ThreadLocal即可能出现获取失败的问题。
public class ThreadLocalTest {
public static void main(String[] args) {
ThreadLocal<String> threadLocal = new ThreadLocal<>();
threadLocal.set("A");
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}).start();
}
}
2、InheritableThreadLocal
直接使用ThreadLocal，在跨线程时时无法获取到ThreadLocal的。
在lang包还有一个继承自ThreadLocal的类InheritableThreadLocal
public class InheritableThreadLocal<T> extends ThreadLocal<T> {
/**
* Computes the child's initial value for this inheritable thread-local
* variable as a function of the parent's value at the time the child
* thread is created. This method is called from within the parent
* thread before the child is started.
* <p>
* This method merely returns its input argument, and should be overridden
* if a different behavior is desired.
*
* @param parentValue the parent thread's value
* @return the child thread's initial value
*/
protected T childValue(T parentValue) {
return parentValue;
}
/**
* Get the map associated with a ThreadLocal.
*
* @param t the current thread
*/
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
/**
* Create the map associated with a ThreadLocal.
*
* @param t the current thread
* @param firstValue value for the initial entry of the table.
*/
void createMap(Thread t, T firstValue) {
t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}
}
重写了getMap和createMap方法，让每次get、set操作都是对inheritableThreadLocals进行操作。
在Thread的init方法中有个判断，若是父线程的inheritableThreadLocals不为空，则将其复制到子线程。
也就是说我们使用InheritableThreadLocal，只要新建线程就可以让ThreadLocal在子父线程之间传递。
public class ThreadLocalTest {
public static void main(String[] args) {
ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
threadLocal.set("A");
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}).start();
}).start();
}
}
3、线程池复用Thread导致的问题
并不代表InheritableThreadLocal就可以保证子父线程之间正确传递ThreadLocal对象。inheritableThreadLocals的复制操作只有在新创建Thread对象的时候才会触发。而我们通常不会在项目中new Thread，而是使用线程池，线程池的Thread对象是复用的。
将上面的例子改成使用线程池
使用固定大小的线程池，当固定大小为2时没问题，两次使用的不是同一个Thread，每次都成功复制了正确的ThreadLocal。
public class ThreadLocalTest1 {
public static void main(String[] args) throws InterruptedException {
Executor threadPool = Executors.newFixedThreadPool(2);
ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
threadLocal.set("A");
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}
});
threadLocal.set("B");
Thread.sleep(200);
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}
});
}
}
而将线程池固定大小设为1时会发现，使用同一个Thread对象，第二次并不会触发重新复制ThreadLocal对象，还是以前的A。
public class ThreadLocalTest1 {
public static void main(String[] args) throws InterruptedException {
Executor threadPool = Executors.newFixedThreadPool(1);
ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
threadLocal.set("A");
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}
});
threadLocal.set("B");
Thread.sleep(200);
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}
});
}
}
4、解决办法
阿里的TransmittableThreadLocal
引入transmittable-thread-local依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>transmittable-thread-local</artifactId>
<version>2.11.4</version>
</dependency>
使用TransmittableThreadLocal继续改造上面的例子
public class ThreadLocalTest2 {
public static void main(String[] args) throws InterruptedException {
Executor threadPool = TtlExecutors.getTtlExecutor(Executors.newFixedThreadPool(1));
ThreadLocal<String> threadLocal = new TransmittableThreadLocal<>();
threadLocal.set("A");
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}
});
threadLocal.set("B");
Thread.sleep(200);
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-getThreadLocal:"+threadLocal.get());
}
});
}
}
两个关键点：
（1）需要使用transmittable-thread-local包中的方法包装线程池，否则即使使用TransmittableThreadLocal也不会起作用
（2）使用TransmittableThreadLocal对象来保存线程变量。
简单分析一下这个东东：
TransmittableThreadLocal继承自InheritableThreadLocal
TransmittableThreadLocal中有个holder的静态对象，对ThreadLocal进行get、set、remove等操作时其实是在对这个holder进行操作。用到了WeakHashMap，这个其实和JDK1.8以前的老版hashmap很相似，不同的是Entry对象是使用WeakReference包装的，这应该个原生ThreadLocal中的ThreadLocalMap使用WeakReference是一样的道理。（ThreadLocal为什么使用WeakReference）
private static InheritableThreadLocal<WeakHashMap<TransmittableThreadLocal<Object>, ?>> holder = new InheritableThreadLocal<WeakHashMap<TransmittableThreadLocal<Object>, ?>>() {
protected WeakHashMap<TransmittableThreadLocal<Object>, ?> initialValue() {
return new WeakHashMap();
}
protected WeakHashMap<TransmittableThreadLocal<Object>, ?> childValue(WeakHashMap<TransmittableThreadLocal<Object>, ?> parentValue) {
return new WeakHashMap(parentValue);
}
};
然后看包装线程池是在干什么
@Nullable
public static Executor getTtlExecutor(@Nullable Executor executor) {
return (Executor)(!TtlAgent.isTtlAgentLoaded() && null != executor && !(executor instanceof TtlEnhanced)?new ExecutorTtlWrapper(executor):executor);
}
返回了一个ExecutorTtlWrapper对象，在调用execute时将Runnable对象换成了TtlRunnable。
class ExecutorTtlWrapper implements Executor, TtlWrapper<Executor>, TtlEnhanced {
private final Executor executor;
ExecutorTtlWrapper(@NonNull Executor executor) {
this.executor = executor;
}
public void execute(@NonNull Runnable command) {
this.executor.execute(TtlRunnable.get(command));
}
@NonNull
public Executor unwrap() {
return this.executor;
}
}
TtlRunnable中改造了原生Runnable的run方法
public final class TtlRunnable implements Runnable, TtlWrapper<Runnable>, TtlEnhanced, TtlAttachments {
private final AtomicReference<Object> capturedRef = new AtomicReference(Transmitter.capture());
private final Runnable runnable;
private final boolean releaseTtlValueReferenceAfterRun;
private final TtlAttachmentsDelegate ttlAttachment = new TtlAttachmentsDelegate();
private TtlRunnable(@NonNull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
this.runnable = runnable;
this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
}
public void run() {
Object captured = this.capturedRef.get();
if(captured != null && (!this.releaseTtlValueReferenceAfterRun || this.capturedRef.compareAndSet(captured, (Object)null))) {
Object backup = Transmitter.replay(captured);
try {
this.runnable.run();
} finally {
Transmitter.restore(backup);
}
} else {
throw new IllegalStateException("TTL value reference is released after run!");
}
}
......
}
Transmitter.capture()其实就是在获取TransmittableThreadLocal中holder的副本，对该副本使用AtomicReference进行包装，方便保证原子性。
调用run时，从capturedRef获取副本，使用cas将其更新为null，若cas失败则抛出异常IllegalStateException(“TTL value reference is released after run!”)，使用cas来保证每次取到的都是最新的副本。
因此包装线程池的作用就是将以前每次新建Thread对象才拷贝inheritableThreadLocals的机制变成了每次新建Runnable的时候拷贝副本，从而保证线程池中子父线程之间ThreadLocal对象的传递。
这种在子父线程之间传递上下文的操作其实在很多框架中都有，如sleuth：
以前一直很好奇，为什么异步调用时调用链路依然是完整的，很神奇。sleuth中使用一个叫ExecutorBeanPostProcessor的后置处理器包装了所有的线程池，例如将ThreadPoolTaskExecutor包装为LazyTraceThreadPoolTaskExecutor。LazyTraceThreadPoolTaskExecutor重写了线程池的execute、submit等方法，当我们传入参数Runnable或者Callable时会被包装为TraceRunnable或TraceCallable。
