TransmittableThreadLocal剖析

最新推荐文章于 2024-10-12 00:35:48 发布
最新推荐文章于 2024-10-12 00:35:48 发布
阅读量1.8k 收藏 25
点赞数 12
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CTZL123456/article/details/142097870
版权

1. ThreadLocal系列介绍

1.1. 什么是TransmittableThreadLocal

TransmittableThreadLocal 是 Alibaba 开源的 Java 库 Transmittable Thread Local (TTL) 中的一个类。它扩展了 Java 标准库中的 java.lang.ThreadLocal 类，提供了跨线程传递本地变量（如跨线程池提交任务时）的能力。这在处理需要使用线程池的异步编程和并发场景下有大用处。

要关注的是，TransmittableThreadLocal 需要配合 TtlExecutors 装饰器使用，通过 TtlExecutors 装饰器包装的线程池可以确保在原始线程和执行任务的线程之间共享 TransmittableThreadLocal。

 

ini
 

代码解读
 

复制代码
 

// 创建一个ExecutorService线程池 ExecutorService pool = Executors.newFixedThreadPool(1); // 运用TtlExecutors装饰器来装饰线程池 ExecutorService ttlPool = TtlExecutors.getTtlExecutorService(pool); 
 

1.2. ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal区别
 

 

  1. ThreadLocal：父线程不会传递threadLocal副本到子线程中；
  2. InheritableThreadLocal：在子线程创建的时候，父线程会把threadLocal拷贝到子线程中，但是线程池的线程如果为核心线程不会每次都重新创建，所以这时核心线程还是拿到首次创建时拷贝的值；
  3. TransmittableThreadLocal：每次线程执行任务前都会将父线程在threadLocal中最新的值拷贝到子线程中，解决了InheritableThreadLocal线程池无法传递本地副本的问题。
 

2. 代码分析
 

2.1. ThreadLocal案例
 

 

ini
 

代码解读
 

复制代码
 

@Test public void threadLocalTest() { ThreadLocal<String> local = new ThreadLocal<>(); try { local.set("我是主线程"); ExecutorService executorService = Executors.newFixedThreadPool(1); CountDownLatch c1 = new CountDownLatch(1); CountDownLatch c2 = new CountDownLatch(1); executorService.execute(() -> { System.out.println("线程1结果：" + local.get()); c1.countDown(); }); c1.await(); executorService.execute(() -> { System.out.println("线程2结果：" + local.get()); c2.countDown(); }); c2.await(); executorService.shutdownNow(); } catch (InterruptedException e) { e.printStackTrace(); } finally { //使用完毕，清除线程中ThreadLocalMap中的key。 local.remove(); } } 
 

运行结果：
 

 

通过结果我们可以看出，只使用ThreadLocal，线程池中的子线程是无法拿到主线程设置到ThreadLocal的值的。
 

2.2. InheritableThreadLocal案例
 

 

csharp
 

代码解读
 

复制代码
 

@Test public void inheritableThreadLocalTest() throws InterruptedException { ThreadLocal<String> local = new InheritableThreadLocal<>(); local.set("我是主线程"); new Thread(() -> { System.out.println("子线程1结果：" + local.get()); }).start(); } 
 

运行结果：
 

 

固定一个core线程的线程池再试：
 

 

csharp
 

代码解读
 

复制代码
 

@Test public void inheritableThreadLocalTest() throws InterruptedException { ThreadLocal<String> local = new InheritableThreadLocal<>(); try { local.set("我是主线程"); ExecutorService executorService = Executors.newFixedThreadPool(1); CountDownLatch c1 = new CountDownLatch(1); CountDownLatch c2 = new CountDownLatch(1); //初始化init的时候，赋予了父线程的ThreadLocal的值 executorService.execute(() -> { System.out.println("线程1结果：" + local.get()); c1.countDown(); }); c1.await(); //主线程修改值 local.set("修改主线程"); //再次调用，查看效果 executorService.execute(() -> { System.out.println("线程2结果：" + local.get()); c2.countDown(); }); c2.await(); executorService.shutdownNow(); } catch (InterruptedException e) { e.printStackTrace(); } finally { //使用完毕，清除线程中ThreadLocalMap中的key。 local.remove(); } } 
 

运行结果：
 

 

通过实验我们可以看出，当把核心线程数设置为1时，主线程中ThreadLocal值再更改，子线程获取到的仍然是首次赋值拿到的值，故其弊端是核心线程不会每次重建，所以值也就不会更新。
 

2.3. TransmittableThreadLocal案例
 

 

ini
 

代码解读
 

复制代码
 

@Test public void transmittableThreadLocalTest() throws InterruptedException { TransmittableThreadLocal<String> local = new TransmittableThreadLocal<>(); local.set("我是主线程"); //生成额外的代理 ExecutorService executorService = Executors.newFixedThreadPool(1); //核心装饰代码 executorService = TtlExecutors.getTtlExecutorService(executorService); CountDownLatch c1 = new CountDownLatch(1); CountDownLatch c2 = new CountDownLatch(1); executorService.execute(() -> { System.out.println("我是线程1结果：" + local.get()); c1.countDown(); }); c1.await(); local.set("修改主线程"); System.out.println("此时主线程值：" + local.get()); executorService.execute(() -> { System.out.println("我是线程2结果：" + local.get()); c2.countDown(); }); c2.await(); } 
 

运行结果：
 

 

通过上面的实验可知，使用TransmittableThreadLocal存储配合TtlExecutors，线程池中的子线程每次都能拿到主线程最近一次在TransmittableThreadLocal存的值。
 

3. 原理分析
 

3.1. InheritableThreadLocal
 

首先来看，为什么案例 2.2 中的InheritableThreadLocal只能拿到在创建线程前最近一次父线程设置的值呢？原因如下：
 

3.1.1. 父线程set
 

父线程往InheritableThreadLocal设置值时，在创建ThreadLocalMap时会最后赋值给InheritableThreadLocal的inheritableThreadLocals变量（也就是说父线程往InheritableThreadLocal设置的值都保存在inheritableThreadLocals变量）。
 

 

 

线程池当第一个任务进来时会去创建Worker，在Worker构造函数中会通过线程工厂创建线程。
 

 

 

 

 

这里的parent.inheritableThreadLocals就是父线程InheritableThreadLocal设置的值，可以看到在子线程创建时拷贝给了子线程的inheritableThreadLocals变量（也可以理解为这里子线程继承了父线程的inheritableThreadLocals变量，但是只有在创建子线程前会做）。
 

3.1.2. 子线程get
 

 

 

 

可以看到子线程get的时候获取值就是从inheritableThreadLocals中去取，拿到的也就是创建子线程前父线程拷贝过来的inheritableThreadLocals
 

 

在执行了local.set("修改主线程");后，确实修改了主线程的内容。
 

 

但到了子线程中，其值依然是之前的“我是主线程”，由于设定的线程池核心数为1，这个线程又处于空闲状态，所以线程池不会再次创建线程，而是复用已第一次创建的线程。可以看到拿到的inheritableThreadLocals还是创建线程时父线程拷贝过来的值。这就能解释2.2案例中返回的结果了。
 

3.2. TransmittableThreadLocal
 

3.2.1. holder
 

在TransmittableThreadLocal中会维护一个holder变量，该变量保存当前线程所有的TransmittableThreadLocal。
 

 

 

 

在执行set或get方法时，父线程会将存放在TransmittableThreadLocal的数据都放在holder变量中。
 

 

 

 

 

在交给TtlExecutors线程池执行任务前会创建TtlRunnable（excute() -> TtlRunnable -> capture() -> run() ->replay() ），TtlRunnable会在创建时初始化执行capture() 方法，可以看到 capture 的逻辑其实就是返回一个快照，而这个快照就是遍历 holder 获取所有存储在 holder 里面的 TTL ，返回一个新的 map。
 

3.2.2. replay
 

在具体执行任务时TtlRunnable执行的run方法主要分为四部：
 

  1. 拿到父类本地变量拷贝
  2. 赋值给当前线程（线程池内的某线程），并保存之前的本地变量
  3. 执行任务逻辑
  4. 复原当前线程之前的本地变量
 

 

再来看下replay，即如何将父类的本地变量赋值给当前线程的，主要逻辑就是先备份当前线程目前存储的值（以备后续恢复），然后拷贝父线程中的值进行覆盖，最后返回备份。
 

其中实现此逻辑的重点就在于captured和backup。captured 和 backup 都是 HashMap<TransmittableThreadLocal, Object> 对象，但它们在逻辑上扮演着不同的角色，具有不同的用途。
 

 

3.2.2.1. captured
 

captured 是传递给 replay 方法的参数。它包含的是从其他线程捕获的 TransmittableThreadLocal 的值。换句话说，captured 是线程本地变量（TTL）的快照，它保存的是在某个特定时间点，这些变量在其他线程中的状态。这些值将被“重播”到当前线程中。
 

3.2.2.2. backup
 

backup 是在 replay 方法中创建的一个新的 HashMap<TransmittableThreadLocal<Object>, Object> 对象。它的主要作用是备份当前线程中的 TransmittableThreadLocal 值。这是为了在重播 captured 的值之前，保存当前线程中的 TTL 值，以便能在需要时恢复这些值。
 

总结一下就是，
 

  • captured 保存的是从其他线程捕获的 TTL 值，准备重播到当前线程中。
  • backup 保存的是当前线程在重播前的 TTL 值，目的是为了在重播后能恢复这些值。
 

通过这样设计，可以确保重播在其他线程捕获的 TTL 值之前和之后，都能保证当前线程的已有状态不被永久改变。
 

 

 

可以看下父线程如何将本地变量拷贝到当前线程的，其实就是 for 循环进行 set ，从这里也可以得知为什么上面需要移除父线程没有的 TTL，因为这里只是进行了 set，如果不 remove 当前线程的本地变量，那就不是完全继承自父线程的本地变量了，可能掺杂着之前的本地变量，也就是不干净了，防止这种干扰。
 

 

最后恢复操作，主要是去除子线程里backup没有的TransmittableThreadLocal给移除，恢复上下文。
 

4. 内存泄漏
 

提到ThreadLocal，难免就会想到不正确使用带来内存泄漏问题，接下来让我们一起来分析下。
 

4.1. 案例一
 

4.1.1. 代码
 

 

dart
 

代码解读
 

复制代码
 

@Test public void leakMapTest() throws InterruptedException { TransmittableThreadLocal<Map<String, String>> t1 = new TransmittableThreadLocal<>(); ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 3000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(100)); try { HashMap<String, String> map = new HashMap<>(); map.put("key1", "value1"); t1.set(map); threadPoolExecutor.execute(() -> { System.out.println("t1: " + Thread.currentThread().getName() + ":" + t1.get()); Map<String, String> stringMap = t1.get(); stringMap.put("key2", "value2"); System.out.println("t1: " + Thread.currentThread().getName() + ":" + t1.get()); }); t1.remove(); } finally { Thread.sleep(2000); System.out.println("主线程试试 t1: " + Thread.currentThread().getName() + ":" + t1.get()); // 为什么这里能拿到值呢 threadPoolExecutor.execute(() -> { System.out.println("异步线程试试 t1: " + Thread.currentThread().getName() + ":" + t1.get()); }); } } 
 

运行结果：
 

 

如果TransmittableThreadLocal不配合TtlExecutors使用，而是使用普通线程池，只要线程池内的线程不被销毁，该线程就会一直持有TransmittableThreadLocal中设定的值，这部分内容就一直不会被GC。
 

4.1.2. 分析
 

为何会造成泄漏？我们需要在线程池创建线程的地方去看下
 

 

可以看到在创建线程时断点会走到ThreadLocal.createInheritedMap，断点走到这步的具体原因在于父线程中使用了TransmittableThreadLocal，而TransmittableThreadLocal继承了InheritableThreadLocal，而父线程往TransmittableThreadLocal设置value时会创建InheritableThreadLocal创建ThreadLocalMap并赋值给inheritableThreadLocals，所以可以看到parent.inheritableThreadLocals是有值的。
 

 

 

在ThreadLocalMap中会将父线程inheritableThreadLocals深拷贝一份，然后给子线程的inheritableThreadLocals
 

 

这样也就能理解了，外部父线程就算对TransmittableThreadLocal做了清理，清理的是父线程inheritableThreadLocals的值，子线程inheritableThreadLocals引用的值只要线程不会销毁就会一直持有，也不会被GC掉。
 

4.1.3. 结论
 

使用TransmittableThreadLocal需要线程池配合使用装饰器，即TtlExecutors，否则会有泄漏风险。
 

关于不修饰runnable使用TTL导致子线程泄露问题
 

4.2. 案例二
 

4.2.1. 代码
 

 

dart
 

代码解读
 

复制代码
 

@Test public void leakMapTest2() throws InterruptedException { TransmittableThreadLocal<Map<String, String>> t1 = new TransmittableThreadLocal<Map<String, String>>() { @Override protected Map<String, String> initialValue() { //线程池以及父子线程之间的值是浅拷贝即引用关系，所以使用线程安全的hashmap return new ConcurrentHashMap<>(8); } }; ExecutorService executorService = Executors.newFixedThreadPool(1); executorService = TtlExecutors.getTtlExecutorService(executorService); try { HashMap<String, String> map = new HashMap<>(); map.put("key1", "value1"); t1.set(map); executorService.execute(() -> { Map<String, String> stringMap = t1.get(); stringMap.put("key2", "value2"); t1.set(stringMap); System.out.println("t1: " + Thread.currentThread().getName() + ":" + t1.get()); }); t1.remove(); } finally { Thread.sleep(2000); System.out.println("主线程试试t1: " + Thread.currentThread().getName() + ":" + t1.get()); executorService.execute(() -> { System.out.println("异步线程试试t1: " + Thread.currentThread().getName() + ":" + t1.get()); }); } } 
 

运行结果：
 

 

4.2.2. 分析
 

 

从结果上看父线程对TransmittableThreadLocal进行remove后，子线程再次执行从TransmittableThreadLocal是获取不到值了，看起来value都被回收了。但是当我们对finally模块的子线程执行execute进行debug发现子线程还是引用到了Map，而这个Map里的值就是父线程回收前的值。
 

 

debug打进去发现子线程执行前会将父线程TransmittableThreadLocal值拷贝过来，这里captured没有值，是正常的。
 

 

意想不到的事情发生了，从上图可以看出holder中的TransmittableThreadLocal还是会间接对map持有引用，map中的值也是这个子线程创建的时候从当时的父线程拷贝过来的，也可理解为子线程的inheritableThreadLocals一直对该map持有引用。父线程中的TransmittableThreadLocal.remove其实只是让父线程移除了指向这个map的引用。也就是说子线程继承了主线程，想要把这部分value得以销毁，必须要把该线程也要销毁了。
 

这样带来的问题是如果每次用这个线程对这个map进行add，那就回越来越多，都得不到回收了。
 

结论2：要禁用继承本地线程，否则GC依赖于线程池的销毁。
 

4.3. 案例三（解决4.2中内存泄漏）
 

有两种方式可以解：
 

  • TtlExecutors.getDefaultDisableInheritableThreadFactory()业务操作前 清空线程池线程上下文；
  • 或者声明解决泄漏问题，父子线程继承的时候 子线程初始化为空值。如下代码：
 

 

typescript
 

代码解读
 

复制代码
 

TransmittableThreadLocal<String> t1 = new TransmittableThreadLocal<String>() { protected String childValue(String parentValue) { return initialValue(); } } 
 

例采用第二种方式：
 

 

typescript
 

代码解读
 

复制代码
 

@Test public void leakMapTest2() throws InterruptedException { TransmittableThreadLocal<Map<String, String>> t1 = new TransmittableThreadLocal<Map<String, String>>() { @Override protected Map<String, String> initialValue() { //线程池以及父子线程之间的值是浅拷贝即引用关系，所以使用线程安全的hashmap return new ConcurrentHashMap<>(8); } @Override protected Map<String, String> childValue(Map<String, String> parentValue) { return initialValue(); } }; ExecutorService executorService = Executors.newFixedThreadPool(1); executorService = TtlExecutors.getTtlExecutorService(executorService); try { HashMap<String, String> map = new HashMap<>(); map.put("key1", "value1"); t1.set(map); executorService.execute(() -> { Map<String, String> stringMap = t1.get(); stringMap.put("key2", "value2"); t1.set(stringMap); System.out.println("t1: " + Thread.currentThread().getName() + ":" + t1.get()); }); t1.remove(); } finally { Thread.sleep(2000); System.out.println("主线程试试t1: " + Thread.currentThread().getName() + ":" + t1.get()); executorService.execute(() -> { System.out.println("异步线程试试t1: " + Thread.currentThread().getName() + ":" + t1.get()); }); } } 
 

运行结果：
 

 

让TransmittableThreadLocal实现childValue，让子线程初始化时指向空集合，这样子线程holder指向的map永远都是空集合，完全依靠子线程执行任务前拷贝主线程的值，执行完再还原为空集合。
 


                

        

        

        

    

  


    

      

        

            

              
                
                  「已注销」
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
全链路追踪必备组件之 TransmittableThreadLocal 详解

				
			

			

				

					游戈程序员
				

				

					04-18
					
					1182
					
				

			

		

		

			
				
ThreadLocal 线程传递 & TransmittableThreadLocal 源码解析
文章目录ThreadLocal 线程传递 & TransmittableThreadLocal 源码解析InheritableThreadLocal缺点RunnableWrapper/ CallableWrapperDelegaingExecutorTransmittableThrea...

			
		

	



                

            
              



	

		

			

				
					
TransmittableThreadLocal 原理分析

				
			

			

				

					For-的博客
				

				

					07-18
					
					464
					
				

			

		

		

			
				
注：在看此篇文章前，你需要了解的原理。这里先总体的介绍（下文以ttl作为简称）的原理再去分析一些核心的源码，旨在先有个整体的认识，再去详细了解源码。由于是新建线程时复制父线程的本地变量到子线程，在线程池中由于线程只创建一次，因此无法复制新增的本地变量。ttl照着这个思路去找替代方案，在新建线程任务（Runnable）时将这些本地变量放到另一个类的属性字段中保存，这个类就是。下图的 holder 是一个，存的是当前线程的一个。

			
		

	



              


  
              

                


	

		

			

				
					
ThreadLocal，TransmittableThreadLocal

				
			

			

				

					weixin_42030357的博客
				

				

					12-23
					
					566
					
				

			

		

		

			
				
参考文献：
手撕面试题ThreadLocal！！！
ThreadLocal-面试必问深度解析
通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。如果想实现每一个线程都有自己的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子...

			
		

	





	

		

			

				
					
初识TransmittableThreadLocal

					
热门推荐

				
			

			

				

					大鸡腿的博客
				

				

					05-04
					
					3万+
					
				

			

		

		

			
				
文章目录前言TransmittableThreadLocalmavendemo参考博客
前言
TransmittableThreadLocal是阿里开源的一个类，主要目的是处理父子线程变量不能共用的情况。ThreadLocal是跟当前线程挂钩的，所以脱离当前线程它就起不了作用。
ThreadLocal
场景：它的应用就是比如当前用户特有的一些属性，不能跟其他线程，用户共用。
Transmittab......

			
		

	



		

			
		



	

		

			

				
					
【父子线程传值TransmittableThreadLocal使用踩坑-及相关知识拓展】

					
最新发布

				
			

			

				

					weixin_44585177的博客
				

				

					10-12
					
					1375
					
				

			

		

		

			
				
- TransmittableThreadLocal 是对 ThreadLocal 和 InheritableThreadLocal
   的增强，解决了线程池复用和父子线程上下文传递问题。它在异步编程和多线程环境中，尤其是线程池场景下，有很大的应用价值，适用于需要传递线程上下文信息的各种场景，如分布式追踪、会话管理、日志追踪等。
 - 使用异步编程的时候，我们肯定会接触到父子线程传值问题，如果不使用TransmittableThreadLocal就得自己手动设置到每个子线程里面去，很是麻烦

			
		

	





	

		

			

				
					
TransmittableThreadLocal

				
			

			

				

					hahahahaoooo的博客
				

				

					09-08
					
					2690
					
				

			

		

		

			
				
是一个线程本地变量的实现，它是在 Java 语言中使用的一个类。与普通的不同，允许在线程之间传递值。在多线程环境下，每个线程可以独立地访问自己的线程本地变量，而不会干扰其他线程的变量。变量的值只对所属线程可见。在此基础上提供了额外的功能。当线程在执行过程中切换到另一个线程时（例如，使用线程池），通过可以保留原始线程的变量值，并在切换后恢复这些值，使得新线程能够继续使用原始线程的变量。这种特性在一些应用场景中非常有用，特别是在线程池、异步任务等需要跨线程传递上下文或状态的情况下。

			
		

	





	

		

			

				
					
TransmittableThreadLocal详解

				
			

			

				

					唐芬奇的博客
				

				

					02-01
					
					1万+
					
				

			

		

		

			
				
是阿里开源的用于解决，在使用线程池等会池化复用线程的执行组件情况下，提供ThreadLocal值的传递功能，解决异步执行时上下文传递的问题。详细的内容可以查看。 TransmittableThreadLocal  ， ThreadLocal 线程池访问值为null，解决方案。跨线程访问上下文问题

			
		

	





	

		

			

				
					
TransmittableThreadLocal详解，源码分析，一文带你掌握核心逻辑

				
			

			

				

					weixin_42293662的博客
				

				

					01-05
					
					931
					
				

			

		

		

			
				
到这里分析就结束了整体我认为这个设计的还是很巧妙的，解决了InheritableThreadLocal在线程复用(线程池的情况无法使用的问题)首先使用了holder这样一个ThreadLocal，记录了每一个线程使用了哪些threadLocal，到时候可以直接将这个线程所有的thread以及value遍历出来只用TtlRunnable把Runnable包装了一层，在调用.get时就把父线程打了个快照把Runnable的run方法包装了一层，让线程开始执行之前。

			
		

	





	

		

			

				
					
ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal 使用以及区别

				
			

			

				

					昨日晨曦的博客
				

				

					02-18
					
					808
					
				

			

		

		

			
				
ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal 使用以及区别

			
		

	





	

		

			

				
					
ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal解析

				
			

			

				

					hosaos的博客
				

				

					10-24
					
					1781
					
				

			

		

		

			
				
文章目录使用场景ThreadLocalDemoThreadLocal存储结构关键APIset方法实现get方法实现缺点内存泄露父子线程传值问题InheritableThreadLocal线程上下文复制Demo缺点TransmittableThreadLocalDemo原理TransmittableThreadLocal#holderTransmittableThreadLocal#set捕获与重放...

			
		

	





	

		

			

				
					
TransmittableThreadLocal 使用详解、使用 TransmittableThreadLocal 解决在多线程环境下，线程切换时无法传递变量值的问题

				
			

			

				

					川子的博客
				

				

					08-23
					
					4463
					
				

			

		

		

			
				
TransmittableThreadLocal是什么，TransmittableThreadLocal 和 ThreadLocal 的区别，TransmittableThreadLocal依赖文件、TransmittableThreadLocal的使用，TransmittableThreadLocal使用注意的点、线程之间值传递有哪些方式、TransmittableThreadLocal实现原理

			
		

	





	

		

			

				
					
Java并发编程: TransmittableThreadLocal实现父子线程之间值传递

				
			

			

				

					玉汝于成
				

				

					04-04
					
					2105
					
				

			

		

		

			
				
TransmittableThreadLocal 是 Alibaba 开源框架 transmittable-thread-local 中的一个核心类，它扩展了 Java 的标准 ThreadLocal 类。与标准的 ThreadLocal 不同，TransmittableThreadLocal 的值可以在线程之间传递，尤其是在线程池中的线程复用场景下。

			
		

	





	

		

			

				
					
TransmittableThreadLocal简单理解及使用

				
			

			

				

					那仰望的人，心底的孤独和叹息
				

				

					04-05
					
					1622
					
				

			

		

		

			
				
TransmittableThreadLocal是对普通 ThreadLocal 的增强，它能够在多线程环境中安全地传递线程本地变量，并且能够在线程池中使用，但相应地可能会带来一定的性能开销。使ttl使用场景，简单理解，使用案例代码

			
		

	





	

		

			

				
					
TransmittableThreadLocal总结

				
			

			

				

					weixin_43489232的博客
				

				

					06-10
					
					2063
					
				

			

		

		

			
				
在使用线程池等会池化复用线程的执行组件情况下，提供ThreadLocal值的传递功能，解决异步执行时上下文传递的问题。ThreadLocal使用场景针对线程不安全的例如SimpleDateFormat使用时能够支持多线程状态下的安全使用。同时不需要实例化过多实例和使用锁。} };上下文调用中屏蔽过多的方法栈中的传参（例如用户信息，客户端信息等存入，那么当前线程在任何地方需要时，都可以使用）} /*** 此方法可以支持在当前线程内任意地方获取客户端信息。

			
		

	





	

		

			

				
					
何为TransmittableThreadLocal

				
			

			

				

					hellozhxy的博客
				

				

					07-13
					
					1161
					
				

			

		

		

			
				
一、示例 线程池内的线程并没有父子关系，所以不适合InheritableThreadLocal的使用场景public class ThreadPoolInheritableThreadLocalDemo {

//    static ThreadLocal&lt;String&gt; threadLocal = new InheritableThreadLocal&lt;&gt;();
//  ...

			
		

	





	

		

			

				
					
Java随笔3-TransmittableThreadLocal

				
			

			

				

					yeleits的博客
				

				

					07-11
					
					323
					
				

			

		

		

			
				
阅读本文前，需要了解

① ThreadLocal的特性，参考：Java随笔1-ThreadLocal

② InheritableThreadLocal的特性，参考：Java随笔2-InheritableThreadLocal

③ transmittable：adj.可传送的，可传播的

④ TransmittableThreadLocal 是Alibaba开源的，需配合TtlRunnable 和 TtlCallable 使用


<dependency>
    <groupId&.

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值