InheritableThreadlocal使用问题排查
背景
在做一个微服务系统的时候，我们的参数一般都是接在通过方法定义来进行传递的，类似这样
public void xxx(Param p, ...){
// do something
}
然后这时有个模块，因为之前的设计原因，没有预留传递参数的形式，在本着尽可能不修改原来代码的情况下，决定通过InhertableThreadLocal来进行参数传递
InhertableThreadLocal
对于InhertableThreadLocal我们不陌生，其实它的思想是以空间来换取线性安全，对每个线程保留一份线程内私有的变量。
这个类一般是用于存在父子线程的情况下，那么在父子线程中，是怎么工作的？结合源码来简单认识下
下面这段代码是从jdk的Thread中摘取的，我们可以看到，每个被创建出来的线程，都有2个threadlocal，分别对应同名的类
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
* InheritableThreadLocal values pertaining to this thread. This map is
* maintained by the InheritableThreadLocal class.
*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
一开始的时候inheritableThreadLocals是null的，需要在InhertableThreadLocal调用createMap的时候来初始化。
createMap在setInitialValue()当中会被调用，而setInitialValue被get调用
// ThreadLocal.java
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
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();
}
// InheritableThreadLocal.java
/**
* 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);
}
一般我们创建InheritableThreadLocal会重写初始化的方法，类似如下
ThreadLocal<Map<String,Integer>> context = new InheritableThreadLocal<Map<String,Integer>>(){
@Override
protected Map<String,Integer> initialValue() {
System.out.println(Thread.currentThread().getName() + " init value");
return new HashMap<>();
}
};
看到这里估计开始迷糊了，但是只要记住，父子线程的传递是通过ThreadLocal.ThreadLocalMap inheritableThreadLocals这个关键的成员变量来实现的。
上面讲的其实是父线程怎么创建这个成员变量，那么子线程怎么获取呢？
从线程池中创建线程，或者普通的创建线程，最终都会调用到这个方法
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
//前面省略
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
}
// 后面忽略
注意到这个变量了吗boolean inheritThreadLocals 这个就是决定是否是要继承父线程中的inheritableThreadLocals,前提自然是不能为null。
一般的线程new Thread()这个变量是true，也就是继承父线程中存放的变量。而线程池，默认使用DefaultThreadFactory的newThread(Runnable r)方法，也是如此
到这里就完成了传递，解释了为什么子线程可以得到父线程上set的变量了
回到问题开始
在简单的介绍完了如何实现变量的传递后，我们来看看一开始的问题，测试的代码如下
@Test
public void ParentChildThread(){
ThreadLocal<Map<String,Integer>> context = new InheritableThreadLocal<Map<String,Integer>>(){
@Override
protected Map<String,Integer> initialValue() {
System.out.println(Thread.currentThread().getName() + " init value");
return new HashMap<>();
}
};
final String TEST_KEY = "tt";
class ChildThread implements Runnable{
@Override
public void run() {
try{
System.out.println(Thread.currentThread().getName());
int a = context.get().get(TEST_KEY);;
System.out.println(a);
}
finally {
// 注意这里
context.remove();
}
}
}
ExecutorService executorService = Executors.newFixedThreadPool(1);
String tname = Thread.currentThread().getName();
int c = 0;
try {
while(c++ < 2) {
System.out.printf("%s ======== %d ========\n", tname, c);
System.out.println(Thread.currentThread().getName() + " set");
// 第一次这里会触发createMap
// 这里这里存放的是c
context.get().put(TEST_KEY, c);
executorService.execute(new ChildThread());
System.out.println(Thread.currentThread().getName() + " remove");
TimeUnit.MILLISECONDS.sleep(5000L);
context.remove();
}
// 验证在线程池中remove会不会影响父线程的值，以此来判断是否需要在父线程中remove
} catch (InterruptedException e) {
e.printStackTrace();
}
}
main线程来模拟spring的线程池，因此需要放在一个循环中，重复的set和remove，子线程来模拟我在多线程环境下获取参数，因为在线程池中，所以需要记得remove，避免因为线程池复用的关系，而导致参数不对。
让我们来调试一下，输出的信息如下
Connected to the target VM, address: '127.0.0.1:46617', transport: 'socket'
main ======== 1 ========
main set
main init value
main remove
pool-1-thread-1
0
main ======== 2 ========
main set
main init value
main remove
pool-1-thread-1
pool-1-thread-1 init value
Exception in thread "pool-1-thread-1" java.lang.NullPointerException
at com.cnc.core.utils.CommonUtilTest$1ChildThread.run(CommonUtilTest.java:43)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)
从第一次的使用来看，ok，似乎没有问题，看第二次，怎么报错了，比较第一次和第二次，我们发现，因为在子线程中使用了remove，因此第二次需要重新进行初始化pool-1-thread-1 init value，毕竟我们已经remove了，所以肯定是需要重新初始化的，这个没有问题
注意到没这里线程池只有1个线程，这么做的原因是简化情景，因为实际的情况是32个线程，NPE的错误是在一定请求之后发生的
这个错误的发生，其实是在复用了之前的线程才出现的，也就是之前线程使用了remove后，就会出现这样的问题。why?
因为我们InheritableThreadLocal中存的是map，这个是父线程变量的拷贝
class ChildThread implements Runnable{
@Override
public void run() {
try{
System.out.println(Thread.currentThread().getName());
int a = context.get().get(TEST_KEY);;
System.out.println(a);
}
finally {
// 把这里注释掉
// context.remove();
}
}
}
注释上面是保证不再出现异常，我们看看控制台输出
main ======== 1 ========
main set
main init value
pool-1-thread-1
1
main remove
main ======== 2 ========
main set
main init value
pool-1-thread-1
1
main remove
发现了没有，输出的始终是1，我们注意看main线程也有在remove，这其实是切断了与子线程的联系
解决措施
根据上面的分析我们知道了，父子线程通过inheritableThreadLocals来进行变量的共享，根据我们设置的容器是map，其实不需要调用remove，而只要把map的内容清空即可，效果是一样的，因此，下面这个可以实现我们的需求
context.remove(); --> context.get().clear()
运行测试,，这里我多测试了几个
main ======== 1 ========
main set
main init value
pool-1-thread-1
1
main remove
main ======== 2 ========
main set
pool-1-thread-1
2
main remove
main ======== 3 ========
main set
pool-1-thread-1
3
main remove
main ======== 4 ========
main set
pool-1-thread-1
4
main remove
main ======== 5 ========
main set
pool-1-thread-1
5
main remove
main ======== 6 ========
main set
pool-1-thread-1
6
main remove
