InheritableThreadLocal父子线程变量共享实现原理

概述

  我们知道ThreadLocal 的设计初衷是为了解决多线程并发导致的线程安全问题，向每一个线程提供一个自己的变量副本，实现变量隔离。那如何在不同线程之间共享变量呢？InheritableThreadLocal为解决此问题而生，使用她可以实现父子线程访问ThreadLocal的值。

  实现变量传递的关键是在类Thread中定义的本地变量inheritableThreadLocals：

    /* 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可以实现父子线程间传递变量。

/**
 * 线程间共享变量
 *
 * @author Wiener
 * @date 2020/10/27
 */
public class ShareArgsProblem {
    private static void shareArgs() {
        //主线程中赋值
        ThreadLocal<String> threadLocal = new ThreadLocal<>();
        final ThreadLocal itl = new InheritableThreadLocal();
        itl.set("帅得一匹！");
        threadLocal.set("在 ThreadLocal 中存放了值");
        System.out.println(String.format("① 当前线程名称：%s", Thread.currentThread().getName()));
        Thread t = new Thread() {
            @Override
            public void run() {
                super.run();
                //子线程中读取
                System.out.println(String.format("楼兰的胡杨帅么？%s", itl.get()));
                System.out.println(String.format("拿不到ThreadLocal 存储的值：%s", threadLocal.get()));
                System.out.println(String.format("② 当前线程名称: %s", Thread.currentThread().getName()));
            }
        };
        t.start();
    }

    public static void main(String[] args) {
        shareArgs();
    }
}

  执行main函数，输出结果如下：

  在上面的测试用例中，开启两个线程——主线程和子线程t，主线程中创建了两个变量和一个新的线程t，并尝试在线程t中获取本地变量的值。从输出结果可以看得出来，我们拿不到ThreadLocal类型变量 threadLocal 的值，但是，能够准确拿到 InheritableThreadLocal 类型的变量 itl的值。下面分析为什么可以读取出来InheritableThreadLocal 类型的变量的值。

InheritableThreadLocal共享变量原理分析

  先让我们看看InheritableThreadLocal的寥寥数行源码：

/**
 * This class extends {@code 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 {@code childValue}
 * method in this class.
 *
 * <p>Inheritable thread-local variables are used in preference to
 * ordinary thread-local variables when the per-thread-attribute being
 * maintained in the variable (e.g., User ID, Transaction ID) must be
 * automatically transmitted to any child threads that are created.
 * @author  Josh Bloch and Doug Lea
 */

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

  类InheritableThreadLocal继承自 ThreadLocal，作为子类，它重写了如上所述的三个方法。从上述注释得知，父线程thread-local 变量会被传递至子线程中，下面看看如何传递的。

    public Thread() {//创建新线程时调用的构造方法
        this(null, null, "Thread-" + nextThreadNum(), 0);
    }
    public Thread(ThreadGroup group, Runnable target, String name,
                  long stackSize) {
        this(group, target, name, stackSize, null, true);
    }
    /**
     * Initializes a Thread.
     */
    private Thread(ThreadGroup g, Runnable target, String name,
                   long stackSize, AccessControlContext acc,
                   boolean inheritThreadLocals) {
		 ...
        Thread parent = currentThread();
		 ...
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);//①
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        this.tid = nextThreadID();
    }

  跟着进去几层后，发现在①处给inheritableThreadLocals赋值，继续看 ThreadLocal.createInheritedMap的返回值是什么：

    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }
    /**
     * Construct a new map including all Inheritable ThreadLocals
     * from given parent map. Called only by createInheritedMap.
     *
     * @param parentMap the map associated with parent thread.
     */
    private ThreadLocalMap(ThreadLocalMap parentMap) {
        Entry[] parentTable = parentMap.table; //父线程的table
        int len = parentTable.length;
        setThreshold(len);
        table = new Entry[len];//当前线程的table
        //循环取父线程的值到当前线程
        for (Entry e : parentTable) {
            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++;
                }
            }
        }
    }

  从构造方法ThreadLocalMap可以得知，首先拿到父线程中的键值对表table，然后循环遍历parentTable，把父线程中的这些值通过值传递复制到子线程的ThreadLocalMap对象中，此时子线程的成员变量 inheritableThreadLocals中就有了值。其实，ThreadLocalMap的注释已经明确告诉我们，这里将把父线程的可遗传本地变量（Inheritable ThreadLocals）复制到当前线程中。这种模式，有点类似于ClassLoader的 loadClass() 的机制。

  通过查看Object value = key.childValue(e.value)的实现方式，我们知道这里是值传递。

小结

  Thread对象通过成员变量ThreadLocal.ThreadLocalMap inheritableThreadLocals维护从父线程（创建该线程的线程）继承而来的数据。原理就是在父线程创建子线程时，如果父线程的inheritableThreadLocals不是null，则ThreadLocalMap中的构造函数会复制一份保存到子线程的inheritableThreadLocals变量中。

  由于本地变量在父子传递过程中通过值传递，所以即使父线程的本地变量发生了改变，子线程的本地变量依旧是创建线程时初始化的值。在实际的应用场景里，基本都是使用线程池来进行多线程编程，因线程池复用线程，而非每次创建新的线程，所以如果更新父线程InheritableThreadLocal 的值，被复用的子线程中的InheritableThreadLocal变量值不会被更新，从而导致数据异常。阿里开源的TransmittableThreadLocal 可以解决此问题，感兴趣的老铁们可以去了解一下。

  以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多点赞支持。

Reference

• https://www.cnblogs.com/noteless/p/10448283.html
• https://blog.csdn.net/weixin_34221775/article/details/89657201
• https://it007.blog.csdn.net/article/details/107049975