transmittable-thread-local源码分析

转载自：https://www.jianshu.com/p/82e737057221

 

前言

ThreadLocal解决了在多个线程针对一个变量维护不同值的功能，如果你想在同一个线程内传递一些值，那么就可以用到这个类，它的好处是无侵入性，这样我们就不需要再每个方法内透传这个参数，比如Dubbo的RpcContext。另外我们也可以利用这个类来解决在多线程情况下使用线程不安全的类的问题，比如SimpleDateFormat。ThreadLocal的子类InheritableThreadLocal在ThreadLocal的基础上，解决了和线程相关的副本从父线程向子线程传递的问题。如果不使用InheritableThreadLocal，这个变量在父线程和子线程是两个副本。
但是还有另外一种特殊情况，就是我们比较常用的线程池，线程池中的线程会被复用，线程在创建的时候会把父线程当前的inheritableThreadLocals拷贝过去(如果存在，浅拷贝)，之后我们再在代码中设置了InternalThreadLocal后，在线程池中的线程就再也获取不到这个新的InheritableThreadLocal了。影响最大的问题就是，我们调用链跟踪系统的traceid等信息，会在线程池中的线程丢失，我们也会丢失一部分调用信息。阿里开源的transmittable-thread-local框架就正是解决这个问题。

我们先来看下InheritableThreadLocal是怎么实现让子线程能访问到父线程的InheritableThreadLocal变量，并且通过这部分源码，也能看出来为什么线程池中的线程一旦创建完成之后被复用时为什么会丢失InheritableThreadLocal。

首先我们在Thread类的构造函数能发现下面这段代码

 

if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

意思就是说父线程的inheritableThreadLocals存在时，子线程的inheritableThreadLocals会浅拷贝父线程的inheritableThreadLocals

然后我们看InheritableThreadLocal的重载方法

 

ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

getMap中的返回从threadLocals变为了inheritableThreadLocals。

因为线程的复用，所以这个inheritableThreadLocals只能维持在这个线程创建时候的状态。

下面是测试这个问题的测试用例

 

    @Data
    @AllArgsConstructor
    static class Pet {
        private String name;
    }

    @Test
    public void testThreadLocalInPool() throws InterruptedException {
        final ThreadLocal tl1 = new InheritableThreadLocal<>();
        final ThreadLocal tl2 = new InheritableThreadLocal<>();


        Pet pet = new Pet("xiaomao");
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        tl1.set(pet);
        for(int i =0 ;i<2;i++) {
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " " + tl1.get());
            });
        }

        Thread.sleep(2000L);

        //inheritableThreadLocal是浅拷贝
        pet.setName("xiaogou");
        for(int i =0 ;i<2;i++) {
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " " + tl1.get());
            });
        }


        //线程池中线程一旦创建完成，InheritableThreadLocal就再也传不进去
        pet.setName("xiaoji");
        tl2.set(pet);
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" "+tl2.get());
            }
        });
        
    }

原理

我们先贴一个不使用ttl框架应该怎么解决线程池传递threadlocal变量的解决方案。

 

       private static ThreadLocal> holder = new InheritableThreadLocal>(){
        @Override
        protected Map initialValue() {
            return new HashMap<>();
        }
    };


    @Data
    public static class WrapedRunnable implements Runnable{

        private Map attachment;

        private Runnable runnable;

        public WrapedRunnable(Runnable runnable) {
            this.runnable=runnable;
            this.attachment = new HashMap<>(holder.get());
        }

        @Override
        public void run() {
            holder.set(this.attachment);
            runnable.run();
        }
    }

    @Test
    public void testMandatoryTTL(){

        Executor executor = Executors.newFixedThreadPool(1);
        executor.execute(()->{
            System.out.println("init");
        });

        HashMap attachment = new HashMap<>();
        attachment.put("123","456");
        holder.set(attachment);

        //普通方式
        executor.execute(()->{
            System.out.println(holder.get().containsKey("123"));
        });

        //处理后的方式
        executor.execute(new WrapedRunnable(()->{
            System.out.println(holder.get().containsKey("123"));
        }));



    }

上面的这种方式和ttl的设计思想差不多，但是ttl肯定更加优雅，通用性更高。

下面这张图是ttl核心设计逻辑的时序图。我分析过源码后，大家就能很容易看懂它的设计思想了。

 

源码讲解

后面出现的 tl=ThreadLocal itl=InheritableThreadLocal ttl=TransmittableThreadLocal

就如上面我自己写的那个传递方式一样，ttl也会把需要传递的threadlocal缓存起来，然后在包装类的run方法内重放，设置到子线程。这个缓存的逻辑封装在TransmittableThreadLocal类中。

TransmittableThreadLocal

TransmittableThreadLocal继承了InheritableThreadLocal，重载了get和set方法

 

@Override
    public final T get() {
        T value = super.get();
        if (null != value) addValue();
        return value;
    }

    @Override
    public final void set(T value) {
        super.set(value);
        // may set null to remove value
        if (null == value) removeValue();
        else addValue();
    }

可以看到在调用父类的逻辑上，新增了addValue和removeValue的逻辑，这个就是缓存的逻辑

 

private void addValue() {
        if (!holder.get().containsKey(this)) {
            holder.get().put(this, null); // WeakHashMap supports null value.
        }
    }

    private void removeValue() {
        holder.get().remove(this);
    }

会把当前这个threadlocal缓存到holder上面。

下面介绍下这个很关键的holder

holder

 

private static InheritableThreadLocal, ?>> holder =
            new InheritableThreadLocal, ?>>() {
                @Override
                protected Map, ?> initialValue() {
                    return new WeakHashMap, Object>();
                }

                @Override
                protected Map, ?> childValue(Map, ?> parentValue) {
                    return new WeakHashMap, Object>(parentValue);
                }
            };

首先这个holder本身是InheritableThreadLocal类型的，所以它也是和线程相关联的。可以在父子线程间传递，但是对于线程池内已经创建的线程肯定是传递不进去的。所以在初始化wrapper类的时候，那个时候还是父线程，在wrapper类构造的时候，要把这些threadlocal捕获出来，这个捕获相关逻辑见下一个Transmitter的分析。其次这个holder内保存的是一个WeakHashMap, Object>，所以这个WeakHashMap的key是在没被强引用的情况下可以被回收的。另外需要注意的是，这个WeakHashMap设计者是为了利用到它的key可以被回收的特性，就是当做set在使用。

Transmitter

Transmitter内有3个核心方法

方法	作用
capture	捕获父线程的ttl
replay	重放父线程ttl
restore	恢复之前子线程的ttl

capture用于捕获父线程的ttl，捕获操作要在父线程执行

 

public static Object capture() {
            Map, Object> captured = new HashMap, Object>();
            for (TransmittableThreadLocal threadLocal : holder.get().keySet()) {
                captured.put(threadLocal, threadLocal.copyValue());
            }
            return captured;
        }

replay传入capture方法捕获的ttl，然后在子线程重放，也就是调用ttl的set方法，会设置到当前的线程中去，最后会把子线程之前存在的ttl返回

 

public static Object replay(@Nonnull Object captured) {
            @SuppressWarnings("unchecked")
            Map, Object> capturedMap = (Map, Object>) captured;
            Map, Object> backup = new HashMap, Object>();

            for (Iterator, ?>> iterator = holder.get().entrySet().iterator();
                 iterator.hasNext(); ) {
                Map.Entry, ?> next = iterator.next();
                TransmittableThreadLocal threadLocal = next.getKey();

                // backup
                backup.put(threadLocal, threadLocal.get());

                // clear the TTL values that is not in captured
                // avoid the extra TTL values after replay when run task
                //清除之前上下文，不在capturedMap中，都清除
                if (!capturedMap.containsKey(threadLocal)) {
                    iterator.remove();
                    threadLocal.superRemove();
                }
            }

            // set values to captured TTL
            //这边是在子线程设置ttl的逻辑
            setTtlValuesTo(capturedMap);

            // call beforeExecute callback
            doExecuteCallback(true);

            return backup;
        }

setTtlValuesTo用于在子线程设置ttl，逻辑如下

 

private static void setTtlValuesTo(@Nonnull Map, Object> ttlValues) {
            for (Map.Entry, Object> entry : ttlValues.entrySet()) {
                @SuppressWarnings("unchecked")
                TransmittableThreadLocal