遇到线程池InheritableThreadLocal就废了，该怎么办？

王二北原创，转载请标明出处：来自王二北

一、从项目中遇到的问题说起：

最近项目有一个需求，如下图所示：
上游有A/B/C三个服务，通过Dubbo调用中间的Proxy服务，Proxy最终Dubbo Rpc调用不同的Target服务。
A/B/C三个服务中，共有N中业务场景，Target服务中共提供了50+业务接口，现在需要统计上游ABC中每种业务调用Target接口情况。

image

方案如下：

1、为了减少对接口的修改，上游A/B/C在调用Proxy服务时，通过Dubbo上下文传递业务字段buzSource，Proxy通过上下文获取buzSource内容。

2、然后在Proxy添加一个group=Consumer的DubboConsumerFilter，在这个DubboFilter中将buzSource和调用Target接口的对应关系收集起来，通过Mq发给收集系统。

3、我们都知道，Dubbo上下文其实就是将数据存放到一个ThreadLocal中，客户端掉用服务端时，就是将上下文数据存放到请求数据的头信息attachment，服务端接收到请求数据后，再将数据从请求头中取出，存放到当前的Dubbo RpcContext的上下文中。

在一次Dubbo调用结束后，其上下文信息就会被内置的ConsumerConextFilter清空(如下图所示)。

image

上游服务（A/B/C）的一次业务调用，对于Proxy服务来说，可能会涉及到调用下游Target的多个RPC接口。

因此buzSource字段传递到Target服务中后不能继续存放到dubbo上下文中，因为第一次rpc调用这个字段就被清了，后面的RPC调用就取不到了。
因此，这个buzSource字段，如果要在Proxy中的一个处理逻辑中一直存在，那自然就需要放在ThreadLocal中了。
在Proxy服务中添加了一个GROUP=Provider的DubboProviderFilter，用于请求到来后，将buzSource从RpcContext取出并放到一个新的ThreadLocal中，在请求处理完后，清理调用当前线程对应的buzSource信息。
整体结构图如下所示：

image

遇到的问题：

在Proxy中，有些业务是多线程并发调用的，也就说当上游服务A的请求到达Proxy后，请求后被拆分成多个子请求，放到线程池中去调用下游的Target服务。这个时候，线程池中的线程就无法获取业务主线程上下文中的buzSource了。

了解ThreadLocal的童鞋都知道，ThreadLocal的实现原理，就是因为Thread类中有一个ThreadLocalMap类型的属性threadLocals， key是ThreadLocal， value是你要存放的上下文的值。也就是说线程上下文是和线程一一绑定的，自然其他线程就无法获取了。

image

不想侵入业务代码，在每个业务调用的地方修改传入buzSource，那样太low了，怎么办，突然想到了InheritableThreadLocal，这个类是ThreadLocal的子类，作用是父线程存放到InheritableThreadLocal中的数据，子线程也可以拿到。简单做了个小例子：

private static final InheritableThreadLocal local = new InheritableThreadLocal();
public void test(){
    local.set("111111");
    new Thread(){
        public void run(){
            System.out.println(local.get());
        }
    }.start();
}
子线程输出结果为：111111

例子运行没有问题，于是兴冲冲的将原来存放buzSource的ThreadLocal改为了InheritableThreadLocal，然后在DubboConsumerFilter中取获取buzSource，然而，仍然获取不到！遇到线程池InheritableThreadLocal就废了，为什么？要弄明白原因，先来看看InheritableThreadLocal的实现原理.

二、InheritableThreadLocal实现原理

为什么线程池的线程无法获取业务线程存放到InheritableThreadLocal的数据？这就得从InheritableThreadLocal的原理说起了。

InheritableThreadLocal 继承自ThreadLocal，重写了其中crateMap方法和getMap方法。重写这两个方法的目的是使得所有线程通过InheritableThreadLocal设置的上下文信息，都保存在其对应的inheritableThreadLocals属性中。这一点和ThreadLocal不同，ThreadLocal是保存在Thread的threadLocals属性中。

下面是Thread类汇中threadLocals属性和inheritableThreadLocals两个属性,当调用ThreadLocal类型的上下文对象设置参数时，设置的就是其threadLocals属性对应的Map的kv值，当调用InheritableThreadLocal类型的上下文对象设置参数时，就是设置其inheritableThreadLocals属性的kv值：

 /* 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;

下面是InheritableThreadLocal重写的crateMap方法和getMap方法，正是通过这两个方法，改变了ThreadLocal中要设置和获取Thread中哪个属性的方法。

public class InheritableThreadLocal extends ThreadLocal {
    /**
     * 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.
     * 

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

那么子线程是如何能获取到父线程保存到InheritableThreadLocal类型上下文中数据的呢？
原来是在创建Thread对象时，会判断父线程中inheritableThreadLocals是否不为空，如果不为空，则会将父线程中inheritableThreadLocals中的数据复制到自己的inheritableThreadLocals中。这样就实现了父线程和子线程的上下文传递。

public Thread(ThreadGroup group, Runnable target, String name,
              long stackSize) {
    init(group, target, name, stackSize);
}

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals) {
    if (name == null) {
        throw new NullPointerException("name cannot be null");
    }

    this.name = name;
    ............
    ............
    // 此处会初始化Thread对应的inheritThreadLocals
    // 如果父线程的inheritThreadLocals不为空，则会复制父线程的inheritThreadLocals
    if (inheritThreadLocals && parent.inheritableThreadLocals != null)
        // 根据父线程的inheritableThreadLocals对应的parentMap创建子线程的inheritableThreadLocals
        this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    /* Stash the specified stack size in case the VM cares */
    this.stackSize = stackSize;

    /* Set thread ID */
    tid = nextThreadID();
}
// 根据父线程的inheritableThreadLocals对应的parentMap创建子线程的inheritableThreadLocals 
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
}


private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];
    // 将父Thread中的inheritThreadLocals（ThreadLocalMap）对应的的所有值都复制给子类的inheritThreadLocals
    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal