JDK源码：InheritableThreadLocal实现原理-CSDN博客

一.ThreadLocal

Thread中有一个ThreadLocalMap类型的属性，threadLocals：

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal的 set() 方法：拿到当前线程的 threadLocals，然后往其中塞值，key是ThreadLocal本身，value是塞入的值。

取出Map的时候，如果为空，则初始化Map。

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

ThreadLocal的 get() 方法：从线程中拿出threadLocals，如果不为空，从map中拿出键值对。如果Map为空或者没有拿到值，则直接返回null。

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);// getMap方法，被InheritableThreadLocal重写了
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();// map为空 or 没有取到值
    }
    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;
    }
    protected T initialValue() {
        return null;
    }

二.InheritableThreadLocal

首先看一个例子：

public class ThreadLocalParentSon {
       //public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
       public static ThreadLocal<Integer> threadLocal = new InheritableThreadLocal<Integer>();
       static class MyThread extends Thread{
            @Override
            public void run(){
                System.out.println("Son Thread = " + threadLocal.get());
            }
       }
       public static void main(String[] args) {
             threadLocal.set(new Integer(127));// 当前线程设置值
             Thread thread = new MyThread();
             thread.start();
             System.out.println("Main Tread = " + threadLocal.get());
       }
}

没有使用 InheritableThreadLocal 之前的输出结果：

Main Tread = 127
Son Thread = null

使用 InheritableThreadLocal 之后的输出结果：

Main Tread = 127
Son Thread = 127

透过现象看本质，分析子线程能够从父线程那里继承的值的原理：

看看 InheritableThreadLocal 的源码：重写了ThreadLocal的3个方法

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    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);
    }
}

在Thread中，还有另外一个类型为ThreadLocalMap类型的属性，inheritableThreadLocals。

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

重写的 getMap() 和 createMap() 方法，把之前对 threadLocals 的操作，换成了对 inheritableThreadLocals 。

get() 方法没有被重写，还是调用的ThreadLocal的get。在get()方法中：

ThreadLocalMap map = getMap(t);

实际调用获取到的是，InheritableThreadLocal重写后的inheritableThreadLocals。

那到底是在何时何地传递过来的呢？

InheritableThreadLocal的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.

大概意思是在子线程被创建的时候，做了从父线程传递值到子线程的操作。下面，看一下线程的创建过程：

    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, true);
    }
    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);
        ......
    }

跟着进去几层后，发现了使用到inheritableThreadLocals的地方，继续看 ThreadLocal.createInheritedMap：

    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

真相就快浮出水面了，继续看 ThreadLocalMap 的构造方法：

        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<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }