ThreadLocal 存储的线程变量不能在父子线程中传递解决方案

Bertha 。 2022-10-21 11:50 196阅读 0赞

# 一，问题描述：ThreadLocal 存储的线程变量不能在父子线程中传递 #

项目中，我们经常会用ThreadLocal来存储线程变量，方便后续业务操作的获取。但是如果后续业务中又重新新开线程去处理业务的时候，ThreadLocal不能正常获取到存储的线程变量。也就是线程变量不能在父子线程中传递。

## 1，JDK提供的解决方案InheritableThreadLocal： ##

InheritableThreadLocal是jdk自带的提供父子线程传递的实现类。

InheritableThreadLocal实现的原理是:只有在创建线程Thread时才会去赋值父线程的InheritableThreadLocal中的值。来达到父子线程变量传递的目的。

## 2，线程池好处和直接去new Thread危害解释： ##

线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。

说明：使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

所以业务中我们都是用线程池去处理异步业务。但是由于线程池的线程是池化复用，InheritableThreadLocal只有在创建线程Thread时才会去赋值父线程的InheritableThreadLocal中的值，所以当我们用线程池执行异步业务任务的时候，父子线程变量的传递就会失效。因此InheritableThreadLocal并不能满足我们的业务使用。

## 3，alibaba提供的解决方案： ##

笔者看了下InheritableThreadLocal和ThreadLocal的源码，并收集了一些资料，发现这个问题在alibaba开源项目已经提供了解决方案。脑子里浮现了一句：“想做第一个吃螃蟹的人好难”

这里我们介绍alibaba开源的解决方案：

Github地址：[https://github.com/alibaba/transmittable-thread-local][https_github.com_alibaba_transmittable-thread-local]

感兴趣的小伙伴可以下载看下组件的实现原理。

# 二，开源组件简单介绍： #

JDK的InheritableThreadLocal类可以完成父线程到子线程的值传递。但对于使用线程池等会池化复用线程的执行组件的情况，线程由线程池创建好，并且线程是池化起来反复使用的；这时父子线程关系的ThreadLocal值传递已经没有意义，应用需要的实际上是把 任务提交给线程池时的ThreadLocal值传递到 任务执行时。由alibaba提供的TransmittableThreadLocal类继承并加强InheritableThreadLocal类，解决上述的问题。

## 1，使用TransmittableThreadLocal的三种方式 ##

1.  使用TtlRunnable和TtlCallable来修饰传入线程池的Runnable和Callable。
2.  修饰线程池，通过工具类com.alibaba.ttl.threadpool.TtlExecutors完成
3.  使用Java Agent来修饰JDK线程池实现类。这种方式，实现线程池的传递是透明的，业务代码中没有修饰Runnable或是线程池的代码。即可以做到应用代码 无侵入。

## 2，源码剖析 ##

以使用TtlRunnable和TtlCallable来修饰传入线程池的Runnable和Callable方式来讲解

## **3，TtlRunnable传递原理** ##

每次执行runnable之前，都必须先获取一个包装过的TtlRunnable，此过程会给TransmittableThreadLocal赋值。并通过Snapshot类的两个字段属性来实现父子变量的值复制和传递。

获取TtlRunnable对象

private TtlRunnable(@NonNull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
      this.capturedRef = new AtomicReference<Object>(capture());
      this.runnable = runnable;
      this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
    }

封装capturedRef对象

@NonNull
    public static Object capture() {
        return new Snapshot(captureTtlValues(), captureThreadLocalValues());
    }

captureTtlValues方法里面对TransmittableThreadLocal复制赋值

private static HashMap<TransmittableThreadLocal<Object>, Object> captureTtlValues() {
        HashMap<TransmittableThreadLocal<Object>, Object> ttl2Value = new HashMap<TransmittableThreadLocal<Object>, Object>();
        for (TransmittableThreadLocal<Object> threadLocal : holder.get().keySet()) {
            ttl2Value.put(threadLocal, threadLocal.copyValue());
        }
        return ttl2Value;
    }

最后返回组装好的Snapshot对象，实现传递变量的目的

privatestatic class Snapshot {
      final HashMap<TransmittableThreadLocal<Object>, Object> ttl2Value;
      final HashMap<ThreadLocal<Object>, Object> threadLocal2Value;
      private Snapshot(HashMap<TransmittableThreadLocal<Object>, Object> ttl2Value, HashMap<ThreadLocal<Object>, Object> threadLocal2Value) {
          this.ttl2Value = ttl2Value;
          this.threadLocal2Value = threadLocal2Value;
      }
    }

# 三，使用演示： #

这里我们采用TtlRunnable和TtlCallable来修饰传入线程池的Runnable和Callable的方式来解决我们的业务问题。

## 第一步：编写TransmittableThreadLocal上下文 ##

public class AppIdTtlContext {
        private static TransmittableThreadLocal<String> appIdLocal = new TransmittableThreadLocal<>();
    
        public static void addAppId(String appId) {
            appIdLocal.set(appId);
        }
    
        public static String getAppId() {
            return appIdLocal.get();
        }
    
        public static void removeAppId() {
            appIdLocal.remove();
        }
    
    }

## 第二步：编写线程池 ##

线程池的核心线程数和最大线程数我们设置为1，方便看实验结果，并使用TtlRunnable和TtlCallable来修饰传入线程池的Runnable和Callable

public class TtLThreadPoolUtil {
    
        private static ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    
        static{
            taskExecutor.setCorePoolSize(1);
            taskExecutor.setMaxPoolSize(1);
            //任务队列最大长度
            taskExecutor.setQueueCapacity(200);
            taskExecutor.setAllowCoreThreadTimeOut(true);
            taskExecutor.setKeepAliveSeconds(2000);
            taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
            taskExecutor.initialize();
        }
    
        private TtLThreadPoolUtil(){
        }
    
        public static void addTask(Runnable task) {
            //利用淘宝的TtlRunnable包装一下
            TtlRunnable ttlRunnable = TtlRunnable.get(task);
            taskExecutor.execute(ttlRunnable);
        }
    
        //Callable任务
        public static Future addReturnedTask(Callable task){
            //利用淘宝的TtlCallable包装一下
            Callable ttlCallable = TtlCallable.get(task);
            return taskExecutor.submit(ttlCallable);
        }
    
        public static void shutdown() {
            try{
                taskExecutor.shutdown();
            }catch(Exception ex) {
            }
        }
    
    }

## 第三步：编写拦截器 ##

编写拦截器实现线程变量的赋值，这里我们赋值的是header头的一个appid

public class OrderInterceptor  implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
            String appid = request.getHeader("appid");
            AppIdTtlContext.addAppId(appid);
    
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
            AppIdTtlContext.removeAppId();
        }
    }

## 第四步：编写controller的方法，来验证效果 ##

@RequestMapping("/testTtlThread")
        @ResponseBody
        public void testTtlThread() {
            Long idParent = Thread.currentThread().getId();
            String nameParent = Thread.currentThread().getName();
            System.out.println( idParent+nameParent+"controller线程获取到的appid为="+ AppIdTtlContext.getAppId());
            TtLThreadPoolUtil.addTask(()->{
                Long id = Thread.currentThread().getId();
                String name = Thread.currentThread().getName();
                System.out.println( id+name+"异步线程获取到的appid为="+AppIdTtlContext.getAppId());
    
            });
        }

## 第五步：实验结果 ##

请求接口[http://127.0.0.1:8081/testTtlThread][http_127.0.0.1_8081_testTtlThread] 并且header头的appid值为1002，可以看到appid能被子线程正常获取

![20210504155059522.png][]

请求接口[http://127.0.0.1:8081/testTtlThread][http_127.0.0.1_8081_testTtlThread] 并且header头的appid值为1003，可以看到appid能被子线程正常获取，并且线程池用的是同一个线程，且不会受到第一次请求的干扰

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA3NzIyMzA_size_16_color_FFFFFF_t_70][]

# 四，小结： #

ThreadLocal 实现线程内部变量共享。

InheritableThreadLocal 实现了父线程与子线程的变量传递。InheritableThreadLocal 无法解决在使用线程池等会池化复用线程的执行组件情况下，异步执行执行任务，需要传递上下文的情况。

淘宝开源的TransmittableThreadLocal解决了使用线程池等会池化复用线程的执行组件情况下，异步执行执行任务，需要传递上下文的情况。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA3NzIyMzA_size_16_color_FFFFFF_t_70 1][]

[https_github.com_alibaba_transmittable-thread-local]: https://github.com/alibaba/transmittable-thread-local
[http_127.0.0.1_8081_testTtlThread]: http://127.0.0.1:8081/testTtlThread
[20210504155059522.png]: /images/20221021/e269b5a217554146b95c68d473c540c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA3NzIyMzA_size_16_color_FFFFFF_t_70]: /images/20221021/2ffc7b3de80b446b99e86b0f96577564.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA3NzIyMzA_size_16_color_FFFFFF_t_70 1]: /images/20221021/37eb5cd899cb42359e235036fa1492cf.png