InheritableThreadLocal还存在的问题
2020-05-28 本文已影响0人
星空怎样
[toc]
问题场景
我们使用线程时候往往不会只是简单的new Thread对象，而是使用线程池，当然使用线程池的好处很多，那么线程池会给InheritableThreadLocal带来什么问题，我们列举一下线程池的特点：
- 为了减少创建线程的开销，线程池会缓存已经使用过的线程
- 生命周期统一管理，合理的分配系统资源(线程生命周期：新建状态、就绪状态、运行状态、阻塞状态、死亡状态)
对于第一点，如果子线程已经被使用过了，并且set了新的值到ThreadLocal中，那么第二个任务进来还能获得父线程的值吗？
final InheritableThreadLocal<Span> inheritableThreadLocal=new InheritableThreadLocal<>();
inheritableThreadLocal,set(new Span("xiexiexie"));
//输出xiexiexie
inheritableThreadLocal.get();
ExecutorService es=Executors.newFixedThreadPool(1);
es.execute(()->{
System.out.println("========");
//输出 xiexiexie
inheritableThreadLocal.get();
inheritableThreadLocal.set(new Span("qiqiqi");
//输出 qiqiqi
inheritableThreadLocal.get();
}});
TimeUnit.SECONDS.sleep(1);
es.execute(()->{
System.out.println("========");
//输出qiqiqi
inheritableThreadLocal.get();
inheritableThreadLocal.set(new Span("qiqiqi");
//输出qiqiqi
inheritableThreadLocal.get();
}});
TimeUnit.SECONDS.sleep(1);
System.out.prinln("========");
//输出xiexiexie
Span span = inheritableThreadLocal.get();
static class Span{
public String name;
public int age;
public Span(String name){
this.name=name;
}
}
输出结果是：
xiexiexie
========
xiexiexie
qiqiqi
========
qiqiqi
qiqiqi
========
xiexiexie
造成这个结果的原因：只有创建子线程的时候才会设置子线程的inheritableTreadLocals值，假如第一次提交的任务是A，第二次是B，B任务提交任务时使用的是A的任务的缓存线程，A任务执行时已经重新set了InheritableThreadLocals，值已经变为qiqiqi，B任务再次获取时候直接从t.inheritableThreadLocals中获取，所以获得的是A任务提交的值，而不是父线程的值(父线程值没有改变的原因是子线程set的值，只会set到子线程对应的t.inheritableThreadLocals中，不会影响父线程的inheritableThreadLocals)
解决思路
在submit新任务的时候在重新copy父线程的所有的Entry，然后重新给t.inheritableThreadLocals赋值，这样就解决线程池中每一个新的任务都能获得父线程中的ThreadLocal的值，而不受其他任务影响，因为在生命周期完成时候会自动clear所有数据。
解决方案
第三方库
Alibaba的一个库解决了这个问题，github:alibaba/transmittable-thread-local(详细见GitHub文档)
自定义RunTask类
自定一个RunTask类，使用反射加代理的方式来实现业务，主线程存在InheritableThreaadLocal中的值间接复制，详细如下：
- 定义一个InheritableTask抽象类，这个类实现了Runable接口，并定义一个runTask抽象方法，当开发者需要面对线程池，获取InheritableThreadLocal值的场景提交任务只需要集成InheritableTask类，实现runTask方法即可。
- 在创建任务时，也就是InheritableTask构造方法中，通过反射获取提交任务的业务线程的inheritableLocals属性，然后复制一份，暂存到当前的task的inheritableThreadLocalsObj属性找那个
- 线程池在执行该任务时，其实就是去掉用run()方法，在执行run方法时，先将inheritableThreadLocalsObj属性复制给当前执行任务的那个业务线程的inheritableThreadLocals属性值，然后再去执行runTask()方法，就是真正的业务逻辑，最后finally清理掉执行当前业务的线程的inheritableThreadLocals属性。
详细代码如下：
public abstract class InheritableTask implements Runnable {
private Object inheritableThreadLocalsObj;
public InheritableTask() {
try {
//获取当前业务线程
Thread currentThread = Thread.currentThread();
//获取inheritableThreadLocals属性值
Field inheritableThreadLocalsField = Thread.class.getDeclaredField("inheritableThreadLocals");
inheritableThreadLocalsField.setAccessible(true);
//得到当前线程inheritableThreadLocals的属性值
Object threadLocalMapObj = inheritableThreadLocalsField.get(currentThread);
if (null != threadLocalMapObj) {
//获取字段的类型
Class<?> threadLocalMapClazz = inheritableThreadLocalsField.getType();
//获取ThreadLocal中的createInheritedMap方法
Method method = ThreadLocal.class.getDeclaredMethod("createInheritedMap", threadLocalMapClazz);
method.setAccessible(true);
//调用createInheritedMap方法，重新创建一个新的inheritableThreadLocals，并且将这个值保存
this.inheritableThreadLocalsObj = method.invoke(ThreadLocal.class, threadLocalMapObj);
}
} catch (Exception e) {
throw new IllegalStateException(e);
}
}
@Override
public void run() {
//此处获取处理当前业务的线程，也就是线程池中的线程
Thread currentThread = Thread.currentThread();
Field field = null;
try {
//获取inheritableThreadLocals属性
field = Thread.class.getDeclaredField("inheritableThreadLocals");
//设置权限
field.setAccessible(true);
if (this.inheritableThreadLocalsObj != null) {
//将暂存值，赋值给currentThread
field.set(currentThread, this.inheritableThreadLocalsObj);
inheritableThreadLocalsObj = null;
}
//执行任务
runTask();
} catch (Exception e) {
throw new IllegalStateException(e);
} finally {
try {
//最后将线程的InheritableThreadLocals设置为null
if (field != null) {
field.set(currentThread, null);
}
} catch (IllegalAccessException e) {
throw new IllegalStateException(e);
}
}
}
/**
* 代理方法这个方法处理业务逻辑
*/
public abstract void runTask();
下面是测试用例：
public class ThreadLocalTest {
public static void main(String[] args) throws InterruptedException {
InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();
inheritableThreadLocal.set("qis");
System.out.println(inheritableThreadLocal.get());
ExecutorService executorService = Executors.newFixedThreadPool(1);
executorService.execute(() -> {
System.out.println(inheritableThreadLocal.get());
inheritableThreadLocal.set("qishuo");
System.out.println(inheritableThreadLocal.get());
});
Thread.sleep(1000);
System.out.println("----------------");
executorService.execute(() -> {
System.out.println(inheritableThreadLocal.get());
});
Thread.sleep(1000);
System.out.println("--------------分隔新以上是没有使用InheritableTask----------------");
executorService.submit(new InheritableTask() {
@Override
public void runTask() {
System.out.println(inheritableThreadLocal.get());
inheritableThreadLocal.set("qishuo");
System.out.println(inheritableThreadLocal.get());
}
});
Thread.sleep(1000);
System.out.println("----------------");
executorService.submit(new InheritableTask() {
@Override
public void runTask() {
System.out.println(inheritableThreadLocal.get());
}
});
}
}
输出结果：
qis
qis
qishuo
----------------
qishuo
--------------分隔新以上是没有使用InheritableTask----------------
qis
qishuo
----------------
qis
这样就解决了在线程池场景下的InheritableThreadLocal无效的问题，然而反射比较耗性能，一般优化反射的两种方式，一种使用缓存，一种使用性能较高的反射工具比如RefelectASM类。
下面展示使用缓存的实现：
public abstract class InheritableTaskWithCache implements Runnable {
private Object threadLocalsMapObj;
private static volatile Field inheritableThreadLocalsField;
private static volatile Class threadLocalMapClazz;
private static volatile Method createInheritedMapMethod;
private static final Object accessLock = new Object();
public InheritableTaskWithCache() {
try {
Thread currentThread = Thread.currentThread();
Field field = getInheritableThreadLocalsField();
//得到当前线程的inheritableThreadLocals的值ThreadLocalMap
Object threadLocalsMapObj = field.get(currentThread);
if (null != threadLocalsMapObj) {
Class threadLocalMapClazz = getThreadLocalMapClazz();
Method method = getCreateInheritedMapMethod(threadLocalMapClazz);
//创建一个新的ThreadLocalMap
this.threadLocalsMapObj = method.invoke(ThreadLocal.class, threadLocalsMapObj);
}
} catch (Exception e) {
throw new IllegalStateException(e);
}
}
private Field getInheritableThreadLocalsField() {
if (null == inheritableThreadLocalsField) {
synchronized (accessLock) {
if (null == inheritableThreadLocalsField) {
try {
Field field = Thread.class.getDeclaredField("inheritableThreadLocals");
field.setAccessible(true);
inheritableThreadLocalsField = field;
} catch (Exception e) {
throw new IllegalStateException(e);
}
}
}
}
return inheritableThreadLocalsField;
}
private Method getCreateInheritedMapMethod(Class threadLocalMapClazz) {
if (null != threadLocalMapClazz && null == createInheritedMapMethod) {
synchronized (accessLock) {
if (null == createInheritedMapMethod) {
try {
Method method = ThreadLocal.class.getDeclaredMethod("createInheritedMap", threadLocalMapClazz);
method.setAccessible(true);
createInheritedMapMethod = method;
} catch (Exception e) {
throw new IllegalStateException(e);
}
}
}
}
return createInheritedMapMethod;
}
private Class getThreadLocalMapClazz() {
if (null == inheritableThreadLocalsField) {
return null;
}
if (null == threadLocalMapClazz) {
synchronized (accessLock) {
if (null == threadLocalMapClazz) {
threadLocalMapClazz = inheritableThreadLocalsField.getType();
}
}
}
return threadLocalMapClazz;
}
/**
* 代理方法这个方法处理业务逻辑
*/
protected abstract void runTask();
@Override
public void run() {
Thread currentThread = Thread.currentThread();
Field field = getInheritableThreadLocalsField();
try {
if (null != threadLocalsMapObj && null != field) {
field.set(currentThread, threadLocalsMapObj);
threadLocalsMapObj = null;
}
runTask();
} catch (Exception e) {
throw new IllegalStateException(e);
} finally {
try {
if (field != null) {
field.set(currentThread, null);
}
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
}
综上，通过一个抽象的InheritableTask解决了线程池场景下InheritableThreadLocal失效问题。
总结
- InheritableThreadLocal在线程池中无效的原因是只有在创建线程Thread时才会去赋值父线程的InheritableThreadLocal中的值，而线程池场景下，主业务线程仅仅是提交任务的队列中的
- 如果要解决这个问题，可以自定义一个RunTask类，通过反射加代理的方式来实现业务主线程存在InheritableThreadLocal中值的间接复制，或者使用阿里开源的transmittable-thread-local。
