Java 多线程：InheritableThreadLocal 实现原理

前言

介绍 InheritableThreadLocal 之前，假设对 ThreadLocal 已经有了一定的理解，比如基本概念，原理。这里再复习下 ThreadLocal 的原理，因为会对 InheritableThreadLocal 的理解 有重大的帮助：

1. 每个线程都有一个 ThreadLocalMap 类型的 threadLocals 属性。
2. ThreadLocalMap 类相当于一个Map，key 是 ThreadLocal 本身，value 就是我们的值。
3. 当我们执行 threadLocal.set(new Integer(123)); ，我们就会在这个线程中的 threadLocals 属性中放入一个键值对，key是这个threadLocal.set(new Integer(123)); 的 threadlocal，value 就是值。
4. 当我们通过 threadlocal.get() 方法的时候，首先会根据这个线程得到这个线程的 threadLocals 属性，然后由于这个属性放的是键值对，我们就可以根据键 threadlocal 拿到值。 注意，这时候这个键 threadlocal 和 我们 set 方法的时候的那个键 threadlocal 是一样的，所以我们能够拿到相同的值。

InheritableThreadLocal 概念

从上面的介绍我们可以知道，我们其实是根据 Thread.currentThread()，拿到该线程的 threadlocals，从而进一步得到我们之前预先 set 好的值。那么如果我们新开一个线程，这个时候，由于 Thread.currentThread() 已经变了，从而导致获得的 threadlocals 不一样，我们之前并没有在这个新的线程的 threadlocals 中放入值，那么我就再通过 threadlocal.get()方法 是不可能拿到值的。例如如下代码：

public class Test {
 
    public static ThreadLocal threadLocal = new ThreadLocal();
 
    public static void main(String args[]){
        threadLocal.set(new Integer(123));
 
        Thread thread = new MyThread();
        thread.start();
 
        System.out.println("main = " + threadLocal.get());
    }
 
    static class MyThread extends Thread{
        @Override
        public void run(){
            System.out.println("MyThread = " + threadLocal.get());
        }
    }
}

输出是：

main = 123
MyThread = null

那么这个时候怎么解决？ InheritableThreadLocal 就可以解决这个问题。 先看一个官方对它的介绍：

* This class extends ThreadLocal to provide inheritance of values
 * from parent thread to child thread: when a child thread is created, the
 * child receives initial values for all inheritable thread-local variables
 * for which the parent has values.  Normally the child's values will be
 * identical to the parent's; however, the child's value can be made an
 * arbitrary function of the parent's by overriding the childValue
 * method in this class.

也就是说，我们把上面的
public static ThreadLocal threadLocal = new ThreadLocal();
改成
public static ThreadLocal threadLocal = new InheritableThreadLocal();
再运行，就会有结果：

main = 123
MyThread = 123

也就是子线程或者说新开的线程拿到了该值。那么，这个究竟是怎么实现的呢，key 都变了，为什么还可以拿到呢？

InheritableThreadLocal 原理

我们可以首先可以浏览下 InheritableThreadLocal 类中有什么东西：

public class InheritableThreadLocal extends ThreadLocal {
    protected T childValue(T parentValue) {
        return parentValue;
    }
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

其实就是重写了3个方法。
首先，当我们调用 get 方法的时候，由于子类没有重写，所以我们调用了父类的 get 方法：

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

这里会有一个Thread.currentThread() ， getMap(t) 方法，所以就会得到这个线程 threadlocals。 但是，由于子类 InheritableThreadLocal 重写了 getMap()方法，再看上述代码，我们可以看到：
其实不是得到 threadlocals，而是得到 inheritableThreadLocals。 inheritableThreadLocals 之前一直没提及过，其实它也是 Thread 类的一个 ThreadLocalMap 类型的 属性，如下 Thread 类的部分代码：

ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

那么，这里看 InheritableThreadLocal 重写的方法，感觉 inheritableThreadLocals 和 threadLocals 几乎是一模一样的作用，只是换了个名字而且，那么究竟 为什么在新的 线程中 通过 threadlocal.get() 方法还能得到值呢？

这时候要注意 childValue 方法，我们可以看下它的官方说明：

 * 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.

这个时候，你明白了，是不是在 创建线程的时候做了手脚，做了一些值的传递，或者这里利用上了 inheritableThreadLocals 之类的。

其实，是的：
关键在于 Thread thread = new MyThread(); 这不是一个简简单单的 new 操作。当我们 new 一个 线程的时候：

public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}

然后：

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

然后：

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
     ......
    if (parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;
    ......
}

这时候有一句 'ThreadLocal.createInheritedMap(parent.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];
 
    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal