背景

在做一个微服务系统的时候，我们的参数一般都是接在通过方法定义来进行传递的，类似这样

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

巴特西

InheritableThreadlocal使用问题排查

背景

InhertableThreadLocal

回到问题开始

解决措施

最新文章

热门文章