ThreadLocal线程池使用和TransmittableThreadLocal值传递

已于 2022-05-17 14:12:21 修改
阅读量2.6k 收藏 12
点赞数 2
分类专栏： 线程 文章标签： 多线程 thread java
于 2021-07-05 22:15:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jike11231/article/details/118486750
版权

一、ThreadLocal配合线程池

注意配合remove方法，线程池是对线程进行复用的，如果没有及时的清理，那么之前对该线程的使用，就会影响到后面的线程了，造成数据不准确。

package com.test.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadLocalAndPool {
	 
    private static ThreadLocal<Integer> variableLocal = ThreadLocal.withInitial(() -> 0);

    public static int get() {
        return variableLocal.get();
    }

    public static void remove() {
        variableLocal.remove();
    }

    public static void increment() {
        variableLocal.set(variableLocal.get() + 1);
    }

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(2,2,0, TimeUnit.SECONDS,new LinkedBlockingDeque<>(12));

        for(int i=0;i<5;i++){
            executorService.execute(()->{
                long threadId = Thread.currentThread().getId();
                String threadName =  Thread.currentThread().getName();
                int before = get();
                increment();
                int after = get();
                System.out.println("threadid:" + threadId +"  threadName:"+threadName +"  before:" + before + "  after:" + after);
                /* threadlocal与线程池使用的问题了，因为threadlocal维护是 Map<Thread,T>这个结构。
                 * 而线程池是对线程进行复用的，如果没有及时的清理，那么之前对该线程的使用，就会影响到后面的线程了，造成数据不准确。
                 * */
                remove();//增加remove,解决内存泄露    
            });
        }
        executorService.shutdown();
    }
}

注释remove()方法结果
在这里插入图片描述
未注释remove()方法结果
在这里插入图片描述

二、线程池如何传递ThreadLocal

如何解决线程池中的值传递功能？
多个线程之间竞争同一个变量，为了线程安全进行值隔离，可以使用ThreadLocal。

父子线程之间的值传递，可以使用InheritableThreadLocal类来实现。

在遇到线程池等会池化复用线程的执行组件情况下，上述两种方案都会失灵，就需要通过TransmittableThreadLocal类来实现。

采用InheritableThreadLocal实现。阿里开发出来的TransmittableThreadLocal来让线程池提交任务时进行ThreadLocal的值传递。

2.1 maven依赖

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>transmittable-thread-local</artifactId>
            <version>2.12.1</version>
</dependency>

2.2 JDK对跨线程传递ThreadLocal的支持

package com.test1;

public class TestThreadLocal {

	public static void main(String[] args) {
		/* 代码块1
		ThreadLocal<Object> threadLocal = new ThreadLocal<>();
		threadLocal.set("father");
		new Thread(() -> {
			System.out.println("subThread:" +threadLocal.get());
		}).start();
		*/
		
		//代码块2
        InheritableThreadLocal<String> itl = new InheritableThreadLocal<>();
        itl.set("father");
        new Thread(()->{
            System.out.println("subThread:" + itl.get());//子线程可以拿到父线程的变量
            itl.set("son");
            System.out.println(itl.get());//子线程修改
        }).start();

        try {
			Thread.sleep(3);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}//等待子线程执行完

        System.out.println("thread:" + itl.get()); //子线程修改不影响父线程的变量	
	}
}

执行代码块1，则获取结果为null。执行代码块2结果
在这里插入图片描述

2.3 InheritableThreadLocal的实现原理

InheritableThreadLocal的实现原理，其实特别简单。就是Thread类里面分开记录了ThreadLocal、InheritableThreadLocal的ThreadLocalMap，初始化的时候，会拿到parent.InheritableThreadLocal。直接上代码可以看的很清楚。

class Thread {
	...
    /* 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;
  
  ...
  
  if (inheritThreadLocals && parent.inheritableThreadLocals != null)
    this.inheritableThreadLocals =
    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
}

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

2.4 线程池场景下传值

package com.test1;

import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class InheritableThreadLocal1 {
	static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,
            3,
            0,
            TimeUnit.SECONDS,
            new SynchronousQueue<>(),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());
 
    public static void main(String[] args) throws InterruptedException {
        InheritableThreadLocal<Object> threadLocal = new InheritableThreadLocal<>();
        threadLocal.set(5);
        for(int i = 0; i < 3; i++){
            threadPoolExecutor.submit(() ->{
            	System.out.println("threadlocal的值:"+threadLocal.get());
            });
           
        }
        threadLocal.remove();
        Thread.sleep(1000);
        threadLocal.set(3);
        for(int i = 0; i < 3; i++){
            threadPoolExecutor.submit(() ->{
            	System.out.println("threadlocal的值:"+threadLocal.get());
            });
        }
        threadLocal.remove();
    }
}

如果不加控制，直接在线程池下传值，数据是失败，结果
在这里插入图片描述
改进版代码如下

package com.test1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.threadpool.TtlExecutors;

public class InheritableThreadLocal2 {
	static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,
            3,
            0,
            TimeUnit.SECONDS,
            new SynchronousQueue<>(),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());
 
    public static void main(String[] args) throws InterruptedException {
        ExecutorService ttlExecutorService = TtlExecutors.getTtlExecutorService(threadPoolExecutor);
        InheritableThreadLocal<Object> threadLocal = new TransmittableThreadLocal<>();
        threadLocal.set(5);
        for(int i = 0; i < 3; i++){
            ttlExecutorService.submit(() ->{
            	System.out.println("threadlocal的值:"+threadLocal.get());
            });
        }
        threadLocal.remove();
        Thread.sleep(1000);
        threadLocal.set(3);
        for(int i = 0; i < 3; i++){
            ttlExecutorService.submit(() ->{
            	System.out.println("threadlocal的值:"+threadLocal.get());
            });
        }
        threadLocal.remove();
    }
}

执行结果
在这里插入图片描述
参考文章

https://www.jianshu.com/p/94ba4a918ff5
https://blog.csdn.net/weixin_38336658/article/details/105914390
https://blog.csdn.net/weixin_34080951/article/details/94632393
https://blog.csdn.net/weixin_41751625/article/details/116918284
https://blog.csdn.net/zyhui98/article/details/114459084
https://www.cnblogs.com/wudimanong/p/10457211.html
https://blog.csdn.net/yaomingyang/article/details/122350802

懒虫虫~
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
TransmittableThreadLocal：解决线程池 ThreadLocal 值传递
甘蓝的专栏
04-21 421
老司机必看，一定会遇到。使用 TransmittableThreadLocal 解决线程池与线程之间的ThreadLocal值传递。
ThreadLocal 跨线程传递
weixin_34176694的博客
12-19 1903
2019独角兽企业重金招聘Python工程师标准>>> ...
ThreadLocal
banning的博客
10-16 551
是什么 ThreadLocal提供线程局部变量，如果创建一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题。ThreadLocal实例通常是类中的私有静态字段。ThreadLocal并不解决线程间共享数据的问题。\color{#FF0000}{ThreadLocal 并不解决线程间共享数据的问题。}ThreadLocal并不解决线程间共享数据的问题。 使用场景 ThreadLocal 适用于变量在线
一文详解ThreadLocal与线程间的数据传递
weixin_43966424的博客
04-08 1722
ThreadLocal、InheritableThreadLocals、TransmittableThreadLocal、MDC在线程间的数据传递详解
ThreadLocal值传递问题
四问四不知的博客
02-04 1431
ThreadLocal相关问题
TransmittableThreadLocal详解
热门推荐
Mr1ght的博客
07-01 2万+
1、简介 TransmittableThreadLocal 是Alibaba开源的、用于解决 “在使用线程池等会缓存线程的组件情况下传递ThreadLocal” 问题的 InheritableThreadLocal 扩展。若希望 TransmittableThreadLocal 在线程池与主线程间传递，需配合 TtlRunnable 和 TtlCallable 使用。 2、使用场景 下面是几个典型场景例子。 分布式跟踪系统 应用容器或上层框架跨应用代码给下层SDK传递信息 日志收集记录系统上下文 3、源
TransmittableThreadLocal总结
weixin_43489232的博客
06-10 1486
在使用线程池等会池化复用线程的执行组件情况下，提供ThreadLocal值的传递功能，解决异步执行时上下文传递的问题。ThreadLocal使用场景针对线程不安全的例如SimpleDateFormat使用时能够支持多线程状态下的安全使用。同时不需要实例化过多实例和使用锁。} };上下文调用中屏蔽过多的方法栈中的传参（例如用户信息，客户端信息等存入，那么当前线程在任何地方需要时，都可以使用）} /*** 此方法可以支持在当前线程内任意地方获取客户端信息。
ThreadLocal垮线程池传递数据解决方案.docx
10-26
使用TransmittableThreadLocal 可以解决多种线程池之间的数据传递问题，如线程池之间的数据共享、线程池之间的任务传递等问题。 在实际应用中，TransmittableThreadLocal 可以应用于各种场景，如在微服务架构中，多...
ThreadLocal源码分析和使用
12-25
ThreadLocal 源码分析和使用 ThreadLocal 是 Java 语言中的一种多线程编程机制，用于解决多线程程序的并发问题。它不是一个 Thread，而是一个 Thread 的局部变量。ThreadLocal 的出现是为了解决多线程程序中的共享...
Java单线程ThreadLocal串值问题解决方案
08-19
Java单线程ThreadLocal串值问题解决方案 Java单线程ThreadLocal串值问题解决方案主要介绍了Java单线程...本文通过示例代码，详细介绍了ThreadLocal的使用、问题出现和解决方法，并解释了Tomcat服务器的线程池机制。
深入理解ThreadLocal工作原理及使用示例
08-28
在使用ThreadLocal时，我们一般会复写ThreadLocal的initialValue方法，使第一次调用get方法时返回一个我们设定的初始值。 ThreadLocal的使用示例： ```java private ThreadLocal<Integer> tlA = new ThreadLocal()...
ThreadLocal使用案例_动力节点Java学院整理
08-29
通过使用ThreadLocal，我们可以确保数据的一致性和线程安全。 ThreadLocal的使用可以带来许多好处，例如： * 实现线程安全的变量共享 * 提高代码的可读性和可维护性 * 简化多线程编程 然而，ThreadLocal也存在...
JAVA并发编程(六)：线程本地变量ThreadLocal与TransmittableThreadLocal
catalinaLi的博客
08-28 8903
我们知道有时候一个对象的共享变量会被多个线程所访问，这时就会有线程安全问题。当然我们可以使用synchorinized 关键字来为此变量加锁，进行同步处理。从而限制只能有一个线程来使用此变量，但是加锁会大大影响程序执行效率，此外我们还可以使用ThreadLocal来解决对某一个变量的访问冲突问题。 一、ThreadLocal 概述 当使用ThreadLocal维护变量的时候 它...
Threadlocal 传递研究
Tony的专栏
04-21 499
Threadlocal在线程池中使用传递变量实验
TransmittableThreadLocal - 线程池中也可以传递参数了
沮丧的南瓜
11-21 282
主线程如何通过ThreadLocal将参数传递给线程池中的线程？
ThreadLocal的使用
weixin_44335707的博客
03-19 1269
java的ThreadLocal的使用
阿里开源的TransmittableThreadLocal的正确使用姿势
m0_51681531的博客
04-28 8958
TransmittableThreadLocal是阿里巴巴开源的一个线程本地变量，它是ThreadLocal的一个增强版，可以在线程池等多线程环境下使用，解决了ThreadLocal在多线程环境下的一些问题。在多线程环境下，ThreadLocal可以避免线程安全问题，但是在使用线程池等多线程环境时，ThreadLocal可能会出现一些问题。例如，当使用线程池时，线程池中的线程可能会被多个任务共享，如果使用ThreadLocal存储数据，可能会导致数据被错误地共享。
Spring 异步线程中传递ThreadLocal
keep_learn的专栏
12-28 1489
ThreadLocal 的传递
InheritableThreadLocal和TransmittableThreadLocal详解
花明的博客
08-24 1728
InheritableThreadLocal 简介 由于ThreadLocal设计之初就是为了绑定当前线程，如果希望当前线程的ThreadLocal能够被子线程使用，实现方式就会相当困难（需要用户自己在代码中传递）。在此背景下，InheritableThreadLocal应运而生。 应用 调用链追踪：在调用链系统设计中，为了优化系统运行速度，会使用多线程编程，为了保证调用链ID能够自然的在多线程间传递，需要考虑ThreadLocal传递问题（大多数系统会使用线程池技术，这已经不仅仅是InheritableT
TransmittableThreadLocal与ThreadLocal的区别和相同
最新发布
06-04
TransmittableThreadLocal是一个可以在线程间传递值的ThreadLocal的扩展。相比于普通的ThreadLocal，TransmittableThreadLocal支持在线程池等场景下将值传递给子线程，使得子线程能够继承父线程的值，而普通的ThreadLocal则无法做到这一点。 TransmittableThreadLocal与ThreadLocal的相同点在于它们都是用于在线程内保存和获取值的工具，且都是线程安全的。两者都可以防止多个线程同时访问同一份数据而产生冲突。 不同点在于TransmittableThreadLocal可以在线程间传递值，而ThreadLocal则只能在当前线程内部传递值。此外，在使用线程池的情况下，TransmittableThreadLocal可以将值传递给子线程，而ThreadLocal则无法做到这一点。 下面是一个使用TransmittableThreadLocal的例子，展示了在子线程中获取到父线程的值的过程： ```python from threading import Thread from pyspin import Tqdm from pytransmit import Transmitter transmit = Transmitter() class MyThread(Thread): def run(self): print(f"子线程中获取到的值为：{transmit.get()}") if __name__ == '__main__': transmit.set("hello, world!") print(f"父线程中获取到的值为：{transmit.get()}") my_thread = MyThread() my_thread.start() ``` 输出为: ``` 父线程中获取到的值为：hello, world! 子线程中获取到的值为：hello, world! ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值